FieldBracketingNthOrderBrentSolver (Apache Commons Math 3.6.1 API)

org.apache.commons.math3.analysis.solvers

## Class FieldBracketingNthOrderBrentSolver<T extends RealFieldElement<T>>

- java.lang.Object
- - org.apache.commons.math3.analysis.solvers.FieldBracketingNthOrderBrentSolver<T>

- Type Parameters:
    `T` - the type of the field elements
  All Implemented Interfaces:
    BracketedRealFieldUnivariateSolver<T>
  Direct Known Subclasses:
    BracketingNthOrderBrentSolverDFP

      public class FieldBracketingNthOrderBrentSolver<T extends RealFieldElement<T>>
      extends Object
      implements BracketedRealFieldUnivariateSolver<T>

  This class implements a modification of the Brent algorithm.

  The changes with respect to the original Brent algorithm are:

  - the returned value is chosen in the current interval according to user specified `AllowedSolution`
  - the maximal order for the invert polynomial root search is user-specified instead of being invert quadratic only

  The given interval must bracket the root.

  Since:
    3.6

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `FieldBracketingNthOrderBrentSolver(T relativeAccuracy, T absoluteAccuracy, T functionValueAccuracy, int maximalOrder)` Construct a solver.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `T` | `getAbsoluteAccuracy()` Get the absolute accuracy.
    `int` | `getEvaluations()` Get the number of evaluations of the objective function.
    `T` | `getFunctionValueAccuracy()` Get the function accuracy.
    `int` | `getMaxEvaluations()` Get the maximal number of function evaluations.
    `int` | `getMaximalOrder()` Get the maximal order.
    `T` | `getRelativeAccuracy()` Get the relative accuracy.
    `T` | `solve(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, AllowedSolution allowedSolution)` Solve for a zero in the given interval.
    `T` | `solve(int maxEval, RealFieldUnivariateFunction<T> f, T min, T max, T startValue, AllowedSolution allowedSolution)` Solve for a zero in the given interval, start at `startValue`.

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

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

- - ### Constructor Detail

    - #### FieldBracketingNthOrderBrentSolver

          public FieldBracketingNthOrderBrentSolver(T relativeAccuracy,
                                            T absoluteAccuracy,
                                            T functionValueAccuracy,
                                            int maximalOrder)
                                             throws NumberIsTooSmallException

      Construct a solver.
      Parameters:
        `relativeAccuracy` - Relative accuracy.
        `absoluteAccuracy` - Absolute accuracy.
        `functionValueAccuracy` - Function value accuracy.
        `maximalOrder` - maximal order.
      Throws:
        `NumberIsTooSmallException` - if maximal order is lower than 2

  - ### Method Detail

    - #### getMaximalOrder

          public int getMaximalOrder()

      Get the maximal order.
      Returns:
        maximal order

    - #### getMaxEvaluations

          public int getMaxEvaluations()

      Get the maximal number of function evaluations.
      Specified by:
        `getMaxEvaluations` in interface `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      Returns:
        the maximal number of function evaluations.

    - #### getEvaluations

          public int getEvaluations()

      Get the number of evaluations of the objective function. The number of evaluations corresponds to the last call to the `optimize` method. It is 0 if the method has not been called yet.
      Specified by:
        `getEvaluations` in interface `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      Returns:
        the number of evaluations of the objective function.

    - #### getAbsoluteAccuracy

          public T getAbsoluteAccuracy()

      Get the absolute accuracy.
      Specified by:
        `getAbsoluteAccuracy` in interface `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      Returns:
        absolute accuracy

    - #### getRelativeAccuracy

          public T getRelativeAccuracy()

      Get the relative accuracy.
      Specified by:
        `getRelativeAccuracy` in interface `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      Returns:
        relative accuracy

    - #### getFunctionValueAccuracy

          public T getFunctionValueAccuracy()

      Get the function accuracy.
      Specified by:
        `getFunctionValueAccuracy` in interface `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      Returns:
        function accuracy

    - #### solve

          public T solve(int maxEval,
                RealFieldUnivariateFunction<T> f,
                T min,
                T max,
                AllowedSolution allowedSolution)
                                              throws NullArgumentException,
                                                     NoBracketingException

      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 `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      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.
      Throws:
        `NullArgumentException` - if f is null.
        `NoBracketingException` - if root cannot be bracketed

    - #### solve

          public T solve(int maxEval,
                RealFieldUnivariateFunction<T> f,
                T min,
                T max,
                T startValue,
                AllowedSolution allowedSolution)
                                              throws NullArgumentException,
                                                     NoBracketingException

      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 `BracketedRealFieldUnivariateSolver<T extends RealFieldElement<T>>`
      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.
      Throws:
        `NullArgumentException` - if f is null.
        `NoBracketingException` - if root cannot be bracketed

Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.