## 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
`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
`private` `FastMathCalc()` Private Constructor.

Method Summary
`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

Copyright (c) 2003-2013 Apache Software Foundation