org.apache.commons.math3.util

## Class FastMathCalc

- java.lang.Object
- - org.apache.commons.math3.util.FastMathCalc

     class FastMathCalc
    extends java.lang.Object

Class used to compute the classical functions tables.

Since:
  3.0
Version:
  $Id: FastMathCalc.java 1416643 2012-12-03 19:37:14Z tn $

### Field Summary

Fields
`private static double[]` `FACT` Factorial table, for Taylor series expansions.
`private static long` `HEX_40000000` 0x40000000 - used to split a double into two parts, both with the low order bits cleared.
`private static double[][]` `LN_SPLIT_COEF` Coefficients for slowLog.
`private static java.lang.String` `TABLE_END_DECL` Table end declaration.
`private static java.lang.String` `TABLE_START_DECL` Table start declaration.

### Constructor Summary

Constructors
`private` `FastMathCalc()` Private Constructor.

### Method Summary

Methods
`private static void` `buildSinCosTables(double[] SINE_TABLE_A, double[] SINE_TABLE_B, double[] COSINE_TABLE_A, double[] COSINE_TABLE_B, int SINE_TABLE_LEN, double[] TANGENT_TABLE_A, double[] TANGENT_TABLE_B)` Build the sine and cosine tables.
`private static void` `checkLen(int expectedLen, int actual)` Check two lengths are equal.
`(package private) static double` `expint(int p, double[] result)` Compute exp(p) for a integer p in extended precision.
`(package private) static java.lang.String` `format(double d)` Format a double.
`(package private) static void` `printarray(java.io.PrintStream out, java.lang.String name, int expectedLen, double[] array)` Print an array.
`(package private) static void` `printarray(java.io.PrintStream out, java.lang.String name, int expectedLen, double[][] array2d)` Print an array.
`private static void` `quadMult(double[] a, double[] b, double[] result)` Compute (a[0] + a[1]) * (b[0] + b[1]) in extended precision.
`private static void` `resplit(double[] a)` Recompute a split.
`(package private) static double` `slowCos(double x, double[] result)` For x between 0 and pi/4 compute cosine using Talor series cos(x) = 1 - x^2/2! + x^4/4! ...
`(package private) static double` `slowexp(double x, double[] result)` For x between 0 and 1, returns exp(x), uses extended precision
`(package private) static double[]` `slowLog(double xi)` xi in the range of [1, 2].
`(package private) static double` `slowSin(double x, double[] result)` For x between 0 and pi/4 compute sine using Taylor expansion: sin(x) = x - x^3/3! + x^5/5! - x^7/7! ...
`private static void` `split(double d, double[] split)` Compute split[0], split[1] such that their sum is equal to d, and split[0] has its 30 least significant bits as zero.
`private static void` `splitAdd(double[] a, double[] b, double[] ans)` Add two numbers in split form.
`private static void` `splitMult(double[] a, double[] b, double[] ans)` Multiply two numbers in split form.
`(package private) static void` `splitReciprocal(double[] in, double[] result)` Compute the reciprocal of in.

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

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

### Field Detail

#### HEX_40000000

    private static final long HEX_40000000

0x40000000 - used to split a double into two parts, both with the low order bits cleared. Equivalent to 2^30.

See Also:
  Constant Field Values

#### FACT

    private static final double[] FACT

Factorial table, for Taylor series expansions. 0!, 1!, 2!, ... 19!

#### LN_SPLIT_COEF

    private static final double[][] LN_SPLIT_COEF

Coefficients for slowLog.

#### TABLE_START_DECL

    private static final java.lang.String TABLE_START_DECL

Table start declaration.

See Also:
  Constant Field Values

#### TABLE_END_DECL

    private static final java.lang.String TABLE_END_DECL

Table end declaration.

See Also:
  Constant Field Values

### Constructor Detail

#### FastMathCalc

    private FastMathCalc()

Private Constructor.

### Method Detail

#### buildSinCosTables

    private static void buildSinCosTables(double[] SINE_TABLE_A,
                         double[] SINE_TABLE_B,
                         double[] COSINE_TABLE_A,
                         double[] COSINE_TABLE_B,
                         int SINE_TABLE_LEN,
                         double[] TANGENT_TABLE_A,
                         double[] TANGENT_TABLE_B)

Build the sine and cosine tables.

Parameters:
  `SINE_TABLE_A` - table of the most significant part of the sines
  `SINE_TABLE_B` - table of the least significant part of the sines
  `COSINE_TABLE_A` - table of the most significant part of the cosines
  `COSINE_TABLE_B` - table of the most significant part of the cosines
  `SINE_TABLE_LEN` - length of the tables
  `TANGENT_TABLE_A` - table of the most significant part of the tangents
  `TANGENT_TABLE_B` - table of the most significant part of the tangents

#### slowCos

    static double slowCos(double x,
                 double[] result)

For x between 0 and pi/4 compute cosine using Talor series cos(x) = 1 - x^2/2! + x^4/4! ...

Parameters:
  `x` - number from which cosine is requested
  `result` - placeholder where to put the result in extended precision (may be null)
Returns:
  cos(x)

#### slowSin

    static double slowSin(double x,
                 double[] result)

For x between 0 and pi/4 compute sine using Taylor expansion: sin(x) = x - x^3/3! + x^5/5! - x^7/7! ...

Parameters:
  `x` - number from which sine is requested
  `result` - placeholder where to put the result in extended precision (may be null)
Returns:
  sin(x)

#### slowexp

    static double slowexp(double x,
                 double[] result)

For x between 0 and 1, returns exp(x), uses extended precision

Parameters:
  `x` - argument of exponential
  `result` - placeholder where to place exp(x) split in two terms for extra precision (i.e. exp(x) = result[0] + result[1]
Returns:
  exp(x)

#### split

    private static void split(double d,
             double[] split)

Compute split[0], split[1] such that their sum is equal to d, and split[0] has its 30 least significant bits as zero.

Parameters:
  `d` - number to split
  `split` - placeholder where to place the result

#### resplit

    private static void resplit(double[] a)

Recompute a split.

Parameters:
  `a` - input/out array containing the split, changed on output

#### splitMult

    private static void splitMult(double[] a,
                 double[] b,
                 double[] ans)

Multiply two numbers in split form.

Parameters:
  `a` - first term of multiplication
  `b` - second term of multiplication
  `ans` - placeholder where to put the result

#### splitAdd

    private static void splitAdd(double[] a,
                double[] b,
                double[] ans)

Add two numbers in split form.

Parameters:
  `a` - first term of addition
  `b` - second term of addition
  `ans` - placeholder where to put the result

#### splitReciprocal

    static void splitReciprocal(double[] in,
                       double[] result)

Compute the reciprocal of in. Use the following algorithm. in = c + d. want to find x + y such that x+y = 1/(c+d) and x is much larger than y and x has several zero bits on the right. Set b = 1/(2^22), a = 1 - b. Thus (a+b) = 1. Use following identity to compute (a+b)/(c+d) (a+b)/(c+d) = a/c + (bc - ad) / (c^2 + cd) set x = a/c and y = (bc - ad) / (c^2 + cd) This will be close to the right answer, but there will be some rounding in the calculation of X. So by carefully computing 1 - (c+d)(x+y) we can compute an error and add that back in. This is done carefully so that terms of similar size are subtracted first.

Parameters:
  `in` - initial number, in split form
  `result` - placeholder where to put the result

#### quadMult

    private static void quadMult(double[] a,
                double[] b,
                double[] result)

Compute (a[0] + a[1]) * (b[0] + b[1]) in extended precision.

Parameters:
  `a` - first term of the multiplication
  `b` - second term of the multiplication
  `result` - placeholder where to put the result

#### expint

    static double expint(int p,
                double[] result)

Compute exp(p) for a integer p in extended precision.

Parameters:
  `p` - integer whose exponential is requested
  `result` - placeholder where to put the result in extended precision
Returns:
  exp(p) in standard precision (equal to result[0] + result[1])

#### slowLog

    static double[] slowLog(double xi)

xi in the range of [1, 2]. 3 5 7 x+1 / x x x \ ln ----- = 2 * | x + ---- + ---- + ---- + ... | 1-x \ 3 5 7 / So, compute a Remez approximation of the following function ln ((sqrt(x)+1)/(1-sqrt(x))) / x This will be an even function with only positive coefficents. x is in the range [0 - 1/3]. Transform xi for input to the above function by setting x = (xi-1)/(xi+1). Input to the polynomial is x^2, then the result is multiplied by x.

Parameters:
  `xi` - number from which log is requested
Returns:
  log(xi)

#### printarray

    static void printarray(java.io.PrintStream out,
                  java.lang.String name,
                  int expectedLen,
                  double[][] array2d)

Print an array.

Parameters:
  `out` - text output stream where output should be printed
  `name` - array name
  `expectedLen` - expected length of the array
  `array2d` - array data

#### printarray

    static void printarray(java.io.PrintStream out,
                  java.lang.String name,
                  int expectedLen,
                  double[] array)

Print an array.

Parameters:
  `out` - text output stream where output should be printed
  `name` - array name
  `expectedLen` - expected length of the array
  `array` - array data

#### format

    static java.lang.String format(double d)

Format a double.

Parameters:
  `d` - double number to format
Returns:
  formatted number

#### checkLen

    private static void checkLen(int expectedLen,
                int actual)
                          throws DimensionMismatchException

Check two lengths are equal.

Parameters:
  `expectedLen` - expected length
  `actual` - actual length
Throws:
  `DimensionMismatchException` - if the two lengths are not equal