## 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
`protected static class` `BaseSecantSolver.Method` Secant-based root-finding methods.

Field Summary
`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
`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
`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`

Copyright (c) 2003-2013 Apache Software Foundation