import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/** Simple constructor.
 * @param handler event handler
 * @param maxCheckInterval maximal time interval between switching
 * function checks (this interval prevents missing sign changes in
 * case the integration steps becomes very large)
 * @param convergence convergence threshold in the event time search
 * @param maxIterationCount upper limit of the iteration count in
 * the event time search
 * @param solver Root-finding algorithm to use to detect state events
 */
public EventState(final EventHandler handler, final double maxCheckInterval,
                  final double convergence, final int maxIterationCount,
                  final UnivariateSolver solver) {
    this.handler           = handler;
    this.maxCheckInterval  = maxCheckInterval;
    this.convergence       = FastMath.abs(convergence);
    this.maxIterationCount = maxIterationCount;
    this.solver            = solver;

    // some dummy values ...
    expandable        = null;
    t0                = Double.NaN;
    g0                = Double.NaN;
    g0Positive        = true;
    pendingEvent      = false;
    pendingEventTime  = Double.NaN;
    previousEventTime = Double.NaN;
    increasing        = true;
    nextAction        = EventHandler.Action.CONTINUE;

}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/** Simple constructor.
 * @param handler event handler
 * @param maxCheckInterval maximal time interval between switching
 * function checks (this interval prevents missing sign changes in
 * case the integration steps becomes very large)
 * @param convergence convergence threshold in the event time search
 * @param maxIterationCount upper limit of the iteration count in
 * the event time search
 * @param solver Root-finding algorithm to use to detect state events
 */
public EventState(final EventHandler handler, final double maxCheckInterval,
                  final double convergence, final int maxIterationCount,
                  final UnivariateSolver solver) {
    this.handler           = handler;
    this.maxCheckInterval  = maxCheckInterval;
    this.convergence       = FastMath.abs(convergence);
    this.maxIterationCount = maxIterationCount;
    this.solver            = solver;

    // some dummy values ...
    t0                = Double.NaN;
    g0                = Double.NaN;
    g0Positive        = true;
    pendingEvent      = false;
    pendingEventTime  = Double.NaN;
    previousEventTime = Double.NaN;
    increasing        = true;
    nextAction        = EventHandler.Action.CONTINUE;

}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public void addEventHandler(final EventHandler function,
                            final double maxCheckInterval,
                            final double convergence,
                            final int maxIterationCount,
                            final UnivariateSolver solver) {
  super.addEventHandler(function, maxCheckInterval, convergence,
                        maxIterationCount, solver);

  // reinitialize the arrays
  initializeArrays();

}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/** {@inheritDoc} */
public void addEventHandler(final EventHandler handler,
                            final double maxCheckInterval,
                            final double convergence,
                            final int maxIterationCount,
                            final UnivariateSolver solver) {
    eventsStates.add(new EventState(handler, maxCheckInterval, convergence,
                                    maxIterationCount, solver));
}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/**
 * @param updateFormula formula to use for updating the β parameter,
 * must be one of {@link ConjugateGradientFormula#FLETCHER_REEVES} or {@link
 * ConjugateGradientFormula#POLAK_RIBIERE}.
 * @param checker Convergence checker.
 * @param lineSearchSolver Solver to use during line search.
 * @param preconditioner Preconditioner.
 */
public NonLinearConjugateGradientOptimizer(final ConjugateGradientFormula updateFormula,
                                           ConvergenceChecker<PointValuePair> checker,
                                           final UnivariateSolver lineSearchSolver,
                                           final Preconditioner preconditioner) {
    super(checker);

    this.updateFormula = updateFormula;
    solver = lineSearchSolver;
    this.preconditioner = preconditioner;
    initialStep = 1.0;
}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/**
 * @param updateFormula formula to use for updating the β parameter,
 * must be one of {@link Formula#FLETCHER_REEVES} or
 * {@link Formula#POLAK_RIBIERE}.
 * @param checker Convergence checker.
 * @param lineSearchSolver Solver to use during line search.
 * @param preconditioner Preconditioner.
 * @deprecated as of 3.3. Please use
 * {@link #NonLinearConjugateGradientOptimizer(Formula,ConvergenceChecker,double,double,double,Preconditioner)} instead.
 */
@Deprecated
public NonLinearConjugateGradientOptimizer(final Formula updateFormula,
                                           ConvergenceChecker<PointValuePair> checker,
                                           final UnivariateSolver lineSearchSolver,
                                           final Preconditioner preconditioner) {
    this(updateFormula,
         checker,
         lineSearchSolver.getRelativeAccuracy(),
         lineSearchSolver.getAbsoluteAccuracy(),
         lineSearchSolver.getAbsoluteAccuracy(),
         preconditioner);
}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/** Locate pixel along sensor line.
 * @param date current date
 * @return pixel location ({@code Double.NaN} if the first and last
 * pixels of the line do not bracket a location)
 * @exception RuggedException if the maximum number of evaluations is exceeded
 */
public double locatePixel(final AbsoluteDate date) throws RuggedException {
    try {

        // set up function evaluating to 0.0 where target matches pixel
        final UnivariateFunction f = new UnivariateFunction() {
            /** {@inheritDoc} */
            @Override
            public double value(final double x) throws RuggedExceptionWrapper {
                try {
                    return Vector3D.angle(cross, getLOS(date, x)) - 0.5 * FastMath.PI;
                } catch (RuggedException re) {
                    throw new RuggedExceptionWrapper(re);
                }
            }
        };

        // find the root
        final UnivariateSolver solver =
                new BracketingNthOrderBrentSolver(0.0, accuracy, 5);
        return solver.solve(maxEval, f, -MARGIN, sensor.getNbPixels() - 1 + MARGIN);

    } catch (NoBracketingException nbe) {
        // there are no solutions in the search interval
        return Double.NaN;
    } catch (TooManyEvaluationsException tmee) {
        throw new RuggedException(tmee);
    } catch (RuggedExceptionWrapper rew) {
        throw rew.getException();
    }
}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
private double mleMu(int[] cytosines, int[] depth, double theta) {
		final UnivariateFunction function = new UnivariateFunction() {
			private double muEst;

			{
				muEst = (double) sumArray(cytosines) / (double) sumArray(depth);
//				System.err.println("muEst "+ muEst);
			}

			@Override
			public double value(double mu) {

				return muDerivative(mu, cytosines, depth, theta, muEst);
			}
		};

		final double relativeAccuracy = 1.0e-12;
		final double absoluteAccuracy = 1.0e-8;
		final int maxOrder = 5;
		UnivariateSolver solver = new BracketingNthOrderBrentSolver(relativeAccuracy, absoluteAccuracy, maxOrder);
		if (ArrayUtils.sumArray(cytosines) == ArrayUtils.sumArray(depth)) {
			return 1.0d - 1e-10;
		} else if (ArrayUtils.sumArray(cytosines) == 0) {
			return 0.0d + 1e-10;
		} else return solver.solve(1000, function, 0.0d + 1e-10, 1.0d - 1e-10);

	}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
private double mleTheta(int[] treatmentCytosines, int[] treatmentDepth, int[] controlCytosines, int[]
			controlDepth) {
		final UnivariateFunction function = new UnivariateFunction() {

			@Override
			public double value(double theta) {
				// TODO Auto-generated method stub
				return thetaDerivative(theta, treatmentCytosines, treatmentDepth, controlCytosines, controlDepth);
			}
		};

		final double relativeAccuracy = 1.0e-6;
		final double absoluteAccuracy = 1.0e-3;
		final int maxOrder = 5;
		UnivariateSolver solver = new BracketingNthOrderBrentSolver(relativeAccuracy, absoluteAccuracy, maxOrder);

		double[] interval = new double[]{0.001, 1e6};

		double estPhi = 0.0d;
//		System.err.println("thetaDerivative("+interval[0]+") = "+function.value(interval[0]));
//		System.err.println("thetaDerivative("+interval[1]+") = "+function.value(interval[1]));

		if (Double.isNaN(function.value(interval[1])) || function.value(interval[1]) >= 0) {
			estPhi = interval[1];

		} else if (function.value(interval[0]) <= 0) {
			estPhi = interval[0];
		} else {
			estPhi = solver.solve(1000, function, interval[0], interval[1]);
		}

		return estPhi;
	}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/**
 * @param updateFormula formula to use for updating the β parameter,
 * must be one of {@link Formula#FLETCHER_REEVES} or
 * {@link Formula#POLAK_RIBIERE}.
 * @param checker Convergence checker.
 * @param lineSearchSolver Solver to use during line search.
 * @param preconditioner Preconditioner.
 */
public NonLinearConjugateGradientOptimizer(final Formula updateFormula,
                                           ConvergenceChecker<PointValuePair> checker,
                                           final UnivariateSolver lineSearchSolver,
                                           final Preconditioner preconditioner) {
    super(checker);

    this.updateFormula = updateFormula;
    solver = lineSearchSolver;
    this.preconditioner = preconditioner;
    initialStep = 1;
}
 

import org.apache.commons.math3.analysis.solvers.UnivariateSolver; //导入依赖的package包/类
/**
 * @param updateFormula
 *            formula to use for updating the β parameter,
 *            must be one of {@link Formula#FLETCHER_REEVES} or {@link Formula#POLAK_RIBIERE}.
 * @param checker
 *            Convergence checker.
 * @param lineSearchSolver
 *            Solver to use during line search.
 * @param preconditioner
 *            Preconditioner.
 */
public BoundedNonLinearConjugateGradientOptimizer(final Formula updateFormula,
		ConvergenceChecker<PointValuePair> checker, final UnivariateSolver lineSearchSolver,
		final Preconditioner preconditioner)
{
	super(checker);

	this.updateFormula = updateFormula;
	solver = lineSearchSolver;
	this.preconditioner = preconditioner;
	initialStep = 1;
}