BaseAbstractUnivariateSolver.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* This is not the original file distributed by the Apache Software Foundation
* It has been modified by the Hipparchus project
*/
package org.hipparchus.analysis.solvers;
import org.hipparchus.analysis.UnivariateFunction;
import org.hipparchus.exception.MathIllegalArgumentException;
import org.hipparchus.exception.MathIllegalStateException;
import org.hipparchus.exception.NullArgumentException;
import org.hipparchus.util.Incrementor;
import org.hipparchus.util.MathUtils;
/**
* Provide a default implementation for several functions useful to generic
* solvers.
* The default values for relative and function tolerances are 1e-14
* and 1e-15, respectively. It is however highly recommended to not
* rely on the default, but rather carefully consider values that match
* user's expectations, as well as the specifics of each implementation.
*
* @param <F> Type of function to solve.
*
*/
public abstract class BaseAbstractUnivariateSolver<F extends UnivariateFunction>
implements BaseUnivariateSolver<F> {
/** Default relative accuracy. */
private static final double DEFAULT_RELATIVE_ACCURACY = 1e-14;
/** Default function value accuracy. */
private static final double DEFAULT_FUNCTION_VALUE_ACCURACY = 1e-15;
/** Function value accuracy. */
private final double functionValueAccuracy;
/** Absolute accuracy. */
private final double absoluteAccuracy;
/** Relative accuracy. */
private final double relativeAccuracy;
/** Evaluations counter. */
private Incrementor evaluations;
/** Lower end of search interval. */
private double searchMin;
/** Higher end of search interval. */
private double searchMax;
/** Initial guess. */
private double searchStart;
/** Function to solve. */
private F function;
/**
* Construct a solver with given absolute accuracy.
*
* @param absoluteAccuracy Maximum absolute error.
*/
protected BaseAbstractUnivariateSolver(final double absoluteAccuracy) {
this(DEFAULT_RELATIVE_ACCURACY,
absoluteAccuracy,
DEFAULT_FUNCTION_VALUE_ACCURACY);
}
/**
* Construct a solver with given accuracies.
*
* @param relativeAccuracy Maximum relative error.
* @param absoluteAccuracy Maximum absolute error.
*/
protected BaseAbstractUnivariateSolver(final double relativeAccuracy,
final double absoluteAccuracy) {
this(relativeAccuracy,
absoluteAccuracy,
DEFAULT_FUNCTION_VALUE_ACCURACY);
}
/**
* Construct a solver with given accuracies.
*
* @param relativeAccuracy Maximum relative error.
* @param absoluteAccuracy Maximum absolute error.
* @param functionValueAccuracy Maximum function value error.
*/
protected BaseAbstractUnivariateSolver(final double relativeAccuracy,
final double absoluteAccuracy,
final double functionValueAccuracy) {
this.absoluteAccuracy = absoluteAccuracy;
this.relativeAccuracy = relativeAccuracy;
this.functionValueAccuracy = functionValueAccuracy;
this.evaluations = new Incrementor();
}
/** {@inheritDoc} */
@Override
public int getEvaluations() {
return evaluations.getCount();
}
/** Get lower end of the search interval.
* @return the lower end of the search interval
*/
public double getMin() {
return searchMin;
}
/** Get higher end of the search interval.
* @return the higher end of the search interval
*/
public double getMax() {
return searchMax;
}
/** Get initial guess.
* @return the initial guess
*/
public double getStartValue() {
return searchStart;
}
/**
* {@inheritDoc}
*/
@Override
public double getAbsoluteAccuracy() {
return absoluteAccuracy;
}
/**
* {@inheritDoc}
*/
@Override
public double getRelativeAccuracy() {
return relativeAccuracy;
}
/**
* {@inheritDoc}
*/
@Override
public double getFunctionValueAccuracy() {
return functionValueAccuracy;
}
/**
* Compute the objective function value.
*
* @param point Point at which the objective function must be evaluated.
* @return the objective function value at specified point.
* @throws MathIllegalStateException if the maximal number of evaluations
* is exceeded.
*/
protected double computeObjectiveValue(double point)
throws MathIllegalStateException {
incrementEvaluationCount();
return function.value(point);
}
/**
* Prepare for computation.
* Subclasses must call this method if they override any of the
* {@code solve} methods.
*
* @param f Function to solve.
* @param min Lower bound for the interval.
* @param max Upper bound for the interval.
* @param startValue Start value to use.
* @param maxEval Maximum number of evaluations.
* @exception NullArgumentException if f is null
*/
protected void setup(int maxEval,
F f,
double min, double max,
double startValue)
throws NullArgumentException {
// Checks.
MathUtils.checkNotNull(f);
// Reset.
searchMin = min;
searchMax = max;
searchStart = startValue;
function = f;
evaluations = evaluations.withMaximalCount(maxEval);
}
/** {@inheritDoc} */
@Override
public double solve(int maxEval, F f, double min, double max, double startValue)
throws MathIllegalArgumentException, MathIllegalStateException {
// Initialization.
setup(maxEval, f, min, max, startValue);
// Perform computation.
return doSolve();
}
/** {@inheritDoc} */
@Override
public double solve(int maxEval, F f, double min, double max) {
return solve(maxEval, f, min, max, min + 0.5 * (max - min));
}
/** {@inheritDoc} */
@Override
public double solve(int maxEval, F f, double startValue)
throws MathIllegalArgumentException, MathIllegalStateException {
return solve(maxEval, f, Double.NaN, Double.NaN, startValue);
}
/**
* Method for implementing actual optimization algorithms in derived
* classes.
*
* @return the root.
* @throws MathIllegalStateException if the maximal number of evaluations
* is exceeded.
* @throws MathIllegalArgumentException if the initial search interval does not bracket
* a root and the solver requires it.
*/
protected abstract double doSolve()
throws MathIllegalArgumentException, MathIllegalStateException;
/**
* Check whether the function takes opposite signs at the endpoints.
*
* @param lower Lower endpoint.
* @param upper Upper endpoint.
* @return {@code true} if the function values have opposite signs at the
* given points.
*/
protected boolean isBracketing(final double lower,
final double upper) {
return UnivariateSolverUtils.isBracketing(function, lower, upper);
}
/**
* Check whether the arguments form a (strictly) increasing sequence.
*
* @param start First number.
* @param mid Second number.
* @param end Third number.
* @return {@code true} if the arguments form an increasing sequence.
*/
protected boolean isSequence(final double start,
final double mid,
final double end) {
return UnivariateSolverUtils.isSequence(start, mid, end);
}
/**
* Check that the endpoints specify an interval.
*
* @param lower Lower endpoint.
* @param upper Upper endpoint.
* @throws MathIllegalArgumentException if {@code lower >= upper}.
*/
protected void verifyInterval(final double lower,
final double upper)
throws MathIllegalArgumentException {
UnivariateSolverUtils.verifyInterval(lower, upper);
}
/**
* Check that {@code lower < initial < upper}.
*
* @param lower Lower endpoint.
* @param initial Initial value.
* @param upper Upper endpoint.
* @throws MathIllegalArgumentException if {@code lower >= initial} or
* {@code initial >= upper}.
*/
protected void verifySequence(final double lower,
final double initial,
final double upper)
throws MathIllegalArgumentException {
UnivariateSolverUtils.verifySequence(lower, initial, upper);
}
/**
* Check that the endpoints specify an interval and the function takes
* opposite signs at the endpoints.
*
* @param lower Lower endpoint.
* @param upper Upper endpoint.
* @throws NullArgumentException if the function has not been set.
* @throws MathIllegalArgumentException if the function has the same sign at
* the endpoints.
*/
protected void verifyBracketing(final double lower,
final double upper)
throws MathIllegalArgumentException, NullArgumentException {
UnivariateSolverUtils.verifyBracketing(function, lower, upper);
}
/**
* Increment the evaluation count by one.
* Method {@link #computeObjectiveValue(double)} calls this method internally.
* It is provided for subclasses that do not exclusively use
* {@code computeObjectiveValue} to solve the function.
* See e.g. {@link AbstractUnivariateDifferentiableSolver}.
*
* @throws MathIllegalStateException when the allowed number of function
* evaluations has been exhausted.
*/
protected void incrementEvaluationCount()
throws MathIllegalStateException {
evaluations.increment();
}
}