org.jscience.mathematics.analysis
Class NumericalMathUtils

java.lang.Object
  extended by org.jscience.mathematics.analysis.NumericalMathUtils

public final class NumericalMathUtils
extends java.lang.Object

The numerical math library. This class cannot be subclassed or instantiated because all methods are static.


Method Summary
static double[] differentiate(int N, PrimitiveMapping func, double a, double b)
          Numerical differentiation.
static double[][] differentiate(PrimitiveMappingND func, double[] x, double[] dx)
          Numerical differentiation in multiple dimensions.
static double[] euler(double[] y, PrimitiveMapping func, double dt)
          Uses the Euler method to solve an ODE.
static double gaussian4(int N, PrimitiveMapping func, double a, double b)
          Numerical integration using the Gaussian integration formula (4 points).
static double gaussian8(int N, PrimitiveMapping func, double a, double b)
          Numerical integration using the Gaussian integration formula (8 points).
static double[] leapFrog(double[] y, PrimitiveMapping func, double dt)
          Uses the Leap-Frog method to solve an ODE.
static double[] metropolis(double[] list, PrimitiveMapping func, double dx)
          The Metropolis algorithm.
static double richardson(int N, PrimitiveMapping func, double a, double b)
          Numerical integration using the Richardson extrapolation.
static double[] rungeKutta2(double[] y, DoubleFunction2D func, double t0, double dt)
          Uses the 2nd order Runge-Kutta method to solve an ODE.
static double[] rungeKutta2(double[] y, PrimitiveMapping func, double dt)
          Uses the 2nd order Runge-Kutta method to solve an ODE.
static double[] rungeKutta4(double[] y, DoubleFunction2D func, double t0, double dt)
          Uses the 4th order Runge-Kutta method to solve an ODE.
static double[] rungeKutta4(double[] y, PrimitiveMapping func, double dt)
          Uses the 4th order Runge-Kutta method to solve an ODE.
static double simpson(int N, PrimitiveMapping func, double a, double b)
          Numerical integration using Simpson's rule.
static double[] solveCubic(double a, double b, double c, double d)
          Calculates the roots of the cubic equation, a must be different from 0 (or use quadratic equation solver).
static double[] solveLinear(double a, double b)
          Calculates the roots of the linear equation, a must be different from 0.
static double[] solveQuadratic(double a, double b, double c)
          Calculates the roots of the quadratic equation, a must be different from 0 (or use linear equation solver).
static double[] solveQuartic(double a, double b, double c, double d, double e)
          Calculates the roots of the quartics equation, a must be different from 0 (or use cubic equation solver).
static double trapezium(int N, PrimitiveMapping func, double a, double b)
          Numerical integration using the trapezium rule.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Method Detail

solveLinear

public static double[] solveLinear(double a,
                                   double b)
Calculates the roots of the linear equation, a must be different from 0. ax+b=0.

Returns:
an array containing the root.

solveQuadratic

public static double[] solveQuadratic(double a,
                                      double b,
                                      double c)
Calculates the roots of the quadratic equation, a must be different from 0 (or use linear equation solver). Furthermore, if b*b-4.0*a*c < 0 then the solution is not defined on R. ax2+bx+c=0.

Returns:
an array containing the two roots.

solveCubic

public static double[] solveCubic(double a,
                                  double b,
                                  double c,
                                  double d)
Calculates the roots of the cubic equation, a must be different from 0 (or use quadratic equation solver). Furthermore, there may be only one real solution. ax3+bx2+cx+d=0.

Returns:
an array containing the three roots.

solveQuartic

public static double[] solveQuartic(double a,
                                    double b,
                                    double c,
                                    double d,
                                    double e)
Calculates the roots of the quartics equation, a must be different from 0 (or use cubic equation solver). ax4+bx3+cx2+dx+e=0. Furthermore, there may be no roots in R.

Returns:
an array containing the four roots.

euler

public static double[] euler(double[] y,
                             PrimitiveMapping func,
                             double dt)
Uses the Euler method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0] to initial condition.
func - dy/dt as a function of y.
dt - step size.
Returns:
y.

leapFrog

public static double[] leapFrog(double[] y,
                                PrimitiveMapping func,
                                double dt)
Uses the Leap-Frog method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0], y[1] to initial conditions.
func - dy/dt as a function of y.
dt - step size.
Returns:
y.

rungeKutta2

public static double[] rungeKutta2(double[] y,
                                   PrimitiveMapping func,
                                   double dt)
Uses the 2nd order Runge-Kutta method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0] to initial condition.
func - dy/dt as a function of y.
dt - step size.
Returns:
y.

rungeKutta2

public static double[] rungeKutta2(double[] y,
                                   DoubleFunction2D func,
                                   double t0,
                                   double dt)
Uses the 2nd order Runge-Kutta method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0] to initial condition.
func - dy/dt as a function of y and t.
t0 - initial time.
dt - step size.
Returns:
y.

rungeKutta4

public static double[] rungeKutta4(double[] y,
                                   PrimitiveMapping func,
                                   double dt)
Uses the 4th order Runge-Kutta method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0] to initial condition.
func - dy/dt as a function of y.
dt - step size.
Returns:
y.

rungeKutta4

public static double[] rungeKutta4(double[] y,
                                   DoubleFunction2D func,
                                   double t0,
                                   double dt)
Uses the 4th order Runge-Kutta method to solve an ODE.

Parameters:
y - an array to be filled with y values, set y[0] to initial condition.
func - dy/dt as a function of y and t.
dt - step size.
Returns:
y.

trapezium

public static double trapezium(int N,
                               PrimitiveMapping func,
                               double a,
                               double b)
Numerical integration using the trapezium rule.

Parameters:
N - the number of strips to use.
func - a function.
a - the first ordinate.
b - the last ordinate.

simpson

public static double simpson(int N,
                             PrimitiveMapping func,
                             double a,
                             double b)
Numerical integration using Simpson's rule.

Parameters:
N - the number of strip pairs to use.
func - a function.
a - the first ordinate.
b - the last ordinate.

richardson

public static double richardson(int N,
                                PrimitiveMapping func,
                                double a,
                                double b)
Numerical integration using the Richardson extrapolation.

Parameters:
N - the number of strip pairs to use (lower value).
func - a function.
a - the first ordinate.
b - the last ordinate.

gaussian4

public static double gaussian4(int N,
                               PrimitiveMapping func,
                               double a,
                               double b)
Numerical integration using the Gaussian integration formula (4 points).

Parameters:
N - the number of strips to use.
func - a function.
a - the first ordinate.
b - the last ordinate.

gaussian8

public static double gaussian8(int N,
                               PrimitiveMapping func,
                               double a,
                               double b)
Numerical integration using the Gaussian integration formula (8 points).

Parameters:
N - the number of strips to use.
func - a function.
a - the first ordinate.
b - the last ordinate.

differentiate

public static double[] differentiate(int N,
                                     PrimitiveMapping func,
                                     double a,
                                     double b)
Numerical differentiation.

Parameters:
N - the number of points to use.
func - a function.
a - the first ordinate.
b - the last ordinate.

differentiate

public static double[][] differentiate(PrimitiveMappingND func,
                                       double[] x,
                                       double[] dx)
Numerical differentiation in multiple dimensions.

Parameters:
func - a function.
x - coordinates at which to differentiate about.
dx - step size.
Returns:
an array Mij=dfi/dxj.

metropolis

public static double[] metropolis(double[] list,
                                  PrimitiveMapping func,
                                  double dx)
The Metropolis algorithm.

Parameters:
list - an array to be filled with values distributed according to func, set list[0] to initial value.
func - distribution function.
dx - step size.
Returns:
list.