    All Packages  Class Hierarchy  This Package  Previous  Next  Index

# Class JSci.maths.NumericalMath

    java.lang.Object
       |
       +----JSci.maths.AbstractMath
               |
               +----JSci.maths.NumericalMath

public final class NumericalMath
extends AbstractMath

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

##

differentiate(int, Mapping, double, double)
  Numerical differentiation.
differentiate(NMapping, double[], double[])
  Numerical differentiation in multiple dimensions.
euler(double[], Mapping, double)
  Uses the Euler method to solve an ODE.
gaussian4(int, Mapping, double, double)
  Numerical integration using the Gaussian integration formula (4 points).
gaussian8(int, Mapping, double, double)
  Numerical integration using the Gaussian integration formula (8 points).
leapFrog(double[], Mapping, double)
  Uses the Leap-Frog method to solve an ODE.
metropolis(double[], Mapping, double)
  The Metropolis algorithm.
richardson(int, Mapping, double, double)
  Numerical integration using the Richardson extrapolation.
rungeKutta2(double[], Mapping, double)
  Uses the 2nd order Runge-Kutta method to solve an ODE.
rungeKutta4(double[], Mapping, double)
  Uses the 4th order Runge-Kutta method to solve an ODE.
simpson(int, Mapping, double, double)
  Numerical integration using Simpson's rule.
solveQuadratic(double, double, double)
  Calculates the roots of the quadratic equation ax2+bx+c=0.
trapezium(int, Mapping, double, double)
  Numerical integration using the trapezium rule.

##

solveQuadratic

     public static double[] solveQuadratic(double a,
                                           double b,
                                           double c)

  Calculates the roots of the quadratic equation ax2+bx+c=0.

  Returns:
    an array containing the two roots

euler

     public static double[] euler(double y[],
                                  Mapping 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
    dt - step size
  Returns:
    y

leapFrog

     public static double[] leapFrog(double y[],
                                     Mapping 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
    dt - step size
  Returns:
    y

rungeKutta2

     public static double[] rungeKutta2(double y[],
                                        Mapping 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
    dt - step size
  Returns:
    y

rungeKutta4

     public static double[] rungeKutta4(double y[],
                                        Mapping 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
    dt - step size
  Returns:
    y

trapezium

     public static double trapezium(int N,
                                    Mapping 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,
                                  Mapping 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,
                                     Mapping 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,
                                    Mapping 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,
                                    Mapping 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,
                                          Mapping 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(NMapping 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[],
                                       Mapping 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

    All Packages  Class Hierarchy  This Package  Previous  Next  Index