org.apache.commons.math3.analysis.solvers

## Class BaseSecantSolver

- java.lang.Object
- - org.apache.commons.math3.analysis.solvers.BaseAbstractUnivariateSolver<UnivariateFunction>
  - - org.apache.commons.math3.analysis.solvers.AbstractUnivariateSolver
    - - org.apache.commons.math3.analysis.solvers.BaseSecantSolver

All Implemented Interfaces:
  BaseUnivariateSolver<UnivariateFunction>, BracketedUnivariateSolver<UnivariateFunction>, UnivariateSolver

Direct Known Subclasses:
  IllinoisSolver, PegasusSolver, RegulaFalsiSolver

    public abstract class BaseSecantSolver
    extends AbstractUnivariateSolver
    implements BracketedUnivariateSolver<UnivariateFunction>

Base class for all bracketing Secant-based methods for root-finding (approximating a zero of a univariate real function).

Implementation of the `Regula Falsi` and `Illinois` methods is based on the following article: M. Dowell and P. Jarratt, A modified regula falsi method for computing the root of an equation, BIT Numerical Mathematics, volume 11, number 2, pages 168-174, Springer, 1971.

Implementation of the `Pegasus` method is based on the following article: M. Dowell and P. Jarratt, The "Pegasus" method for computing the root of an equation, BIT Numerical Mathematics, volume 12, number 4, pages 503-508, Springer, 1972.

The `Secant` method is not a bracketing method, so it is not implemented here. It has a separate implementation.

Since:
  3.0
Version:
  $Id: BaseSecantSolver.java 1379560 2012-08-31 19:40:30Z erans $

### Nested Class Summary

Nested Classes
`protected static class` `BaseSecantSolver.Method` Secant-based root-finding methods.

### Field Summary

Fields
`private AllowedSolution` `allowed` The kinds of solutions that the algorithm may accept.
`protected static double` `DEFAULT_ABSOLUTE_ACCURACY` Default absolute accuracy.
`private BaseSecantSolver.Method` `method` The Secant-based root-finding method to use.

### Constructor Summary

Constructors
`protected` `BaseSecantSolver(double absoluteAccuracy, BaseSecantSolver.Method method)` Construct a solver.
`protected` `BaseSecantSolver(double relativeAccuracy, double absoluteAccuracy, BaseSecantSolver.Method method)` Construct a solver.
`protected` `BaseSecantSolver(double relativeAccuracy, double absoluteAccuracy, double functionValueAccuracy, BaseSecantSolver.Method method)` Construct a solver.

### Method Summary

Methods
`protected double` `doSolve()` Method for implementing actual optimization algorithms in derived classes.
`double` `solve(int maxEval, UnivariateFunction f, double min, double max, AllowedSolution allowedSolution)` Solve for a zero in the given interval.
`double` `solve(int maxEval, UnivariateFunction f, double min, double max, double startValue)` Solve for a zero in the given interval, start at `startValue`.
`double` `solve(int maxEval, UnivariateFunction f, double min, double max, double startValue, AllowedSolution allowedSolution)` Solve for a zero in the given interval, start at `startValue`.

### Methods inherited from class org.apache.commons.math3.analysis.solvers.BaseAbstractUnivariateSolver

`computeObjectiveValue, getAbsoluteAccuracy, getEvaluations, getFunctionValueAccuracy, getMax, getMaxEvaluations, getMin, getRelativeAccuracy, getStartValue, incrementEvaluationCount, isBracketing, isSequence, setup, solve, solve, verifyBracketing, verifyInterval, verifySequence`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface org.apache.commons.math3.analysis.solvers.BaseUnivariateSolver

`getAbsoluteAccuracy, getEvaluations, getFunctionValueAccuracy, getMaxEvaluations, getRelativeAccuracy, solve, solve`

### Field Detail

#### DEFAULT_ABSOLUTE_ACCURACY

    protected static final double DEFAULT_ABSOLUTE_ACCURACY

Default absolute accuracy.

See Also:
  Constant Field Values

#### allowed

    private AllowedSolution allowed

The kinds of solutions that the algorithm may accept.

#### method

    private final BaseSecantSolver.Method method

The Secant-based root-finding method to use.

### Constructor Detail

#### BaseSecantSolver

    protected BaseSecantSolver(double absoluteAccuracy,
                    BaseSecantSolver.Method method)

Construct a solver.

Parameters:
  `absoluteAccuracy` - Absolute accuracy.
  `method` - Secant-based root-finding method to use.

#### BaseSecantSolver

    protected BaseSecantSolver(double relativeAccuracy,
                    double absoluteAccuracy,
                    BaseSecantSolver.Method method)

Construct a solver.

Parameters:
  `relativeAccuracy` - Relative accuracy.
  `absoluteAccuracy` - Absolute accuracy.
  `method` - Secant-based root-finding method to use.

#### BaseSecantSolver

    protected BaseSecantSolver(double relativeAccuracy,
                    double absoluteAccuracy,
                    double functionValueAccuracy,
                    BaseSecantSolver.Method method)

Construct a solver.

Parameters:
  `relativeAccuracy` - Maximum relative error.
  `absoluteAccuracy` - Maximum absolute error.
  `functionValueAccuracy` - Maximum function value error.
  `method` - Secant-based root-finding method to use

### Method Detail

#### solve

    public double solve(int maxEval,
               UnivariateFunction f,
               double min,
               double max,
               AllowedSolution allowedSolution)

Solve for a zero in the given interval. A solver may require that the interval brackets a single zero root. Solvers that do require bracketing should be able to handle the case where one of the endpoints is itself a root.

Specified by:
  `solve` in interface `BracketedUnivariateSolver<UnivariateFunction>`
Parameters:
  `maxEval` - Maximum number of evaluations.
  `f` - Function to solve.
  `min` - Lower bound for the interval.
  `max` - Upper bound for the interval.
  `allowedSolution` - The kind of solutions that the root-finding algorithm may accept as solutions.
Returns:
  A value where the function is zero.

#### solve

    public double solve(int maxEval,
               UnivariateFunction f,
               double min,
               double max,
               double startValue,
               AllowedSolution allowedSolution)

Solve for a zero in the given interval, start at `startValue`. A solver may require that the interval brackets a single zero root. Solvers that do require bracketing should be able to handle the case where one of the endpoints is itself a root.

Specified by:
  `solve` in interface `BracketedUnivariateSolver<UnivariateFunction>`
Parameters:
  `maxEval` - Maximum number of evaluations.
  `f` - Function to solve.
  `min` - Lower bound for the interval.
  `max` - Upper bound for the interval.
  `startValue` - Start value to use.
  `allowedSolution` - The kind of solutions that the root-finding algorithm may accept as solutions.
Returns:
  A value where the function is zero.

#### solve

    public double solve(int maxEval,
               UnivariateFunction f,
               double min,
               double max,
               double startValue)

Solve for a zero in the given interval, start at `startValue`. A solver may require that the interval brackets a single zero root. Solvers that do require bracketing should be able to handle the case where one of the endpoints is itself a root.

Specified by:
  `solve` in interface `BaseUnivariateSolver<UnivariateFunction>`
Overrides:
  `solve` in class `BaseAbstractUnivariateSolver<UnivariateFunction>`
Parameters:
  `maxEval` - Maximum number of evaluations.
  `f` - Function to solve.
  `min` - Lower bound for the interval.
  `max` - Upper bound for the interval.
  `startValue` - Start value to use.
Returns:
  a value where the function is zero.

#### doSolve

    protected final double doSolve()
                            throws ConvergenceException,
                                   MathInternalError

Method for implementing actual optimization algorithms in derived classes.

Specified by:
  `doSolve` in class `BaseAbstractUnivariateSolver<UnivariateFunction>`
Returns:
  the root.
Throws:
  `ConvergenceException` - if the algorithm failed due to finite precision.
  `MathInternalError`