ProGAL.math

Class RootFinding

java.lang.Object

ProGAL.math.RootFinding

public class RootFinding
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
RootFinding()

Method Summary

Modifier and Type	Method and Description
static java.lang.Double	bisection(Function f, double a, double b, double tol, int nMax) Root-finding algorithm that repeatedly bisects an interval and then selects a subinterval in which a root must lie for further processing.
static java.lang.Double	brent(Function f, double a, double b, double tol, double delta, int nMax) Root-finding algorithm combining the bisection method, the secant method and inverse quadratic interpolation.
static java.lang.Double	dekker(Function f, double a, double b, double tol, int nMax)
static java.lang.Double	inverseQuadraticInterpolation(Function f, double x, double x1, double x2, double tol, int nMax) Root-finding algorithm that uses quadratic interpolation to approximate the inverse of f.
static void	main(java.lang.String[] args)
static java.lang.Double	newton(Function f, double x, double x1, double tol, int nMax) Root-finding algorithm that starts with an initial guess which is reasonably close to the true root, then the function is approximated by its tangent line (which can be computed using the tools of calculus), and one computes the x-intercept of this tangent line (which is easily done with elementary algebra).
static java.lang.Double	secant(Function f, double x, double x1, double tol, int nMax) Root-finding algorithm that uses a succession of roots of secant lines to better approximate a root of a function f.

Methods inherited from class java.lang.Object

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

Constructor Detail

RootFinding

public RootFinding()

Method Detail

bisection

public static java.lang.Double bisection(Function f,
                                         double a,
                                         double b,
                                         double tol,
                                         int nMax)

Root-finding algorithm that repeatedly bisects an interval and then selects a subinterval in which a root must lie for further processing. It is a very simple and robust method, but it is also relatively slow. Because of this, it is often used to obtain a rough approximation to a solution which is then used as a starting point for more rapidly converging methods The method is also called the interval halving method, the binary search method, or the dichotomy method.

secant

public static java.lang.Double secant(Function f,
                                      double x,
                                      double x1,
                                      double tol,
                                      int nMax)

Root-finding algorithm that uses a succession of roots of secant lines to better approximate a root of a function f. The secant method can be thought of as a finite difference approximation of Newton's method. However, the method was developed independently of Newton's method, and predated the latter by over 3,000 years.

newton

public static java.lang.Double newton(Function f,
                                      double x,
                                      double x1,
                                      double tol,
                                      int nMax)

Root-finding algorithm that starts with an initial guess which is reasonably close to the true root, then the function is approximated by its tangent line (which can be computed using the tools of calculus), and one computes the x-intercept of this tangent line (which is easily done with elementary algebra). This x-intercept will typically be a better approximation to the function's root than the original guess, and the method can be iterated.

inverseQuadraticInterpolation

public static java.lang.Double inverseQuadraticInterpolation(Function f,
                                                             double x,
                                                             double x1,
                                                             double x2,
                                                             double tol,
                                                             int nMax)

Root-finding algorithm that uses quadratic interpolation to approximate the inverse of f. This algorithm is rarely used on its own, but it is important because it forms part of the popular Brent's method.

dekker

public static java.lang.Double dekker(Function f,
                                      double a,
                                      double b,
                                      double tol,
                                      int nMax)

brent

public static java.lang.Double brent(Function f,
                                     double a,
                                     double b,
                                     double tol,
                                     double delta,
                                     int nMax)

Root-finding algorithm combining the bisection method, the secant method and inverse quadratic interpolation. It has the reliability of bisection but it can be as quick as some of the less reliable methods. The algorithm tries to use the potentially fast-converging secant method or inverse quadratic interpolation if possible, but it falls back to the more robust bisection method if necessary.

Parameters:

args -

main

public static void main(java.lang.String[] args)