## org.jscience.mathematics.analysis Class NumericalMathUtils

```java.lang.Object
org.jscience.mathematics.analysis.NumericalMathUtils
```

`public final class NumericalMathUtilsextends 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.