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
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `BaseSecantSolver.Method` Secant-based root-finding methods.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier | Constructor and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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