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

import org.apache.commons.math3.analysis.solvers.BracketingNthOrderBrentSolver; //导入依赖的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.BracketingNthOrderBrentSolver; //导入依赖的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.BracketingNthOrderBrentSolver; //导入依赖的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.BracketingNthOrderBrentSolver; //导入依赖的package包/类
private static GeodeticPoint computeLimitVisibilityPoint(final ICentralBody centralBody,
                                                         final TopocentricFrame frame,
                                                         final double radius,
                                                         final double azimuth,
                                                         final double elevation) throws OrekitException
{
    // based on orekit 6.1 TopocentricFrame.computeLimitVisibilityPoint()
    // but with variable equatorial radius of the central body.

    try {
        // convergence threshold on point position: 1mm
        final double deltaP = 0.001;
        final UnivariateSolver solver =
                new BracketingNthOrderBrentSolver(deltaP / centralBody.getEquatorialRadius(),
                                                  deltaP, deltaP, 5);

        // find the distance such that a point in the specified direction and at the solved-for
        // distance is exactly at the specified radius
        final double distance = solver.solve(1000, new UnivariateFunction() {
            /** {@inheritDoc} */
            @Override
            public double value(final double x) {
                try {
                    final GeodeticPoint gp = frame.pointAtDistance(azimuth, elevation, x);
                    return frame.getParentShape().transform(gp).getNorm() - radius;
                } catch (OrekitException oe) {
                    throw new OrekitExceptionWrapper(oe);
                }
            }
        }, 0, 2 * radius);

        // return the limit point
        return frame.pointAtDistance(azimuth, elevation, distance);

    } catch (TooManyEvaluationsException tmee) {
        throw new OrekitException(tmee);
    } catch (OrekitExceptionWrapper lwe) {
        throw lwe.getException();
    }
}