org.apache.commons.math3.analysis.solvers.UnivariateSolver Java Examples

@Override
public double getConvergenceValue() {
	UnivariateSolver solver = new BrentSolver(0, 1.0d);
	double convergencePoint = -1;
	int upperIntervalBound = 10000;
	int retriesLeft = 8;
	while (retriesLeft > 0 && convergencePoint == -1) {
		try {
			convergencePoint = solver.solve(1000, x -> this.getDerivativeCurveValue(x) - 0.0000001, 1, upperIntervalBound);
		} catch (NoBracketingException e) {
			this.logger.warn(String.format("No solution could be found in interval [1,%d]", upperIntervalBound));
			retriesLeft--;
			upperIntervalBound *= 2;
		}
	}
	if (convergencePoint == -1) {
		throw new IllegalStateException(String.format("No solution could be found in interval [1,%d]", upperIntervalBound));
	}
	return this.getCurveValue(convergencePoint);
}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** 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;

}
 

/** {@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));
}
 

/**
 * @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;
}
 

/**
 * @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;
}
 

/** {@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));
}
 

/** {@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();

}
 

/** {@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();

}
 

/** {@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();

}
 

/** {@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));
}
 

/**
 * @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;
}
 

/**
 * @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;
}
 

/**
 * @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);
}
 

@Test
public void whenUnivariateSolverSolver_thenCorrect() {
    final UnivariateFunction function = v -> Math.pow(v, 2) - 2;
    UnivariateSolver solver = new BracketingNthOrderBrentSolver(1.0e-12, 1.0e-8, 5);
    double c = solver.solve(100, function, -10.0, 10.0, 0);

    Assert.assertEquals(-Math.sqrt(2), c, 1e-7);
}
 

/**
 * @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;
}
 

/** {@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();

}
 

/**
 * @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;
}
 

/** {@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));
}
 

/** {@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();

}
 

/**
 * @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;
}
 

/**
 * @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;
}
 

/** {@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));
}
 

/** {@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));
}