org.apache.commons.math.util

## Class FastMath

- java.lang.Object
- - org.apache.commons.math.util.FastMath

-     public class FastMath
      extends java.lang.Object

  Faster, more accurate, portable alternative to `StrictMath`.

  Additionally implements the following methods not found in StrictMath:

  - `asinh(double)`
  - `acosh(double)`
  - `atanh(double)`
  The following methods are found in StrictMath since 1.6 only
  - `copySign(double, double)`
  - `getExponent(double)`
  - `nextAfter(double,double)`
  - `nextUp(double)`
  - `scalb(double, int)`
  - `copySign(float, float)`
  - `getExponent(float)`
  - `nextAfter(float,double)`
  - `nextUp(float)`
  - `scalb(float, int)`
  Since:
    2.2
  Version:
    $Revision: 1074294 $ $Date: 2011-02-24 22:18:59 +0100 (jeu. 24 févr. 2011) $

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private static double[]` | `CBRTTWO` Table of 2^((n+2)/3)
    `private static double[]` | `COSINE_TABLE_A` Cosine table (high bits).
    `private static double[]` | `COSINE_TABLE_B` Cosine table (low bits).
    `static double` | `E` Napier's constant e, base of the natural logarithm.
    `private static double[]` | `EIGHTHS` Eighths.
    `private static double[]` | `EXP_FRAC_TABLE_A` Exponential over the range of 0 - 1 in increments of 2^-10 exp(x/1024) = expFracTableA[x] + expFracTableB[x].
    `private static double[]` | `EXP_FRAC_TABLE_B` Exponential over the range of 0 - 1 in increments of 2^-10 exp(x/1024) = expFracTableA[x] + expFracTableB[x].
    `private static double[]` | `EXP_INT_TABLE_A` Exponential evaluated at integer values, exp(x) = expIntTableA[x + 750] + expIntTableB[x+750].
    `private static double[]` | `EXP_INT_TABLE_B` Exponential evaluated at integer values, exp(x) = expIntTableA[x + 750] + expIntTableB[x+750]
    `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_2_A` log(2) (high bits).
    `private static double` | `LN_2_B` log(2) (low bits).
    `private static double[][]` | `LN_HI_PREC_COEF` Coefficients for log in the range of 1.0 < x < 1.0 + 2^-10.
    `private static double[][]` | `LN_MANT` Extended precision logarithm table over the range 1 - 2 in increments of 2^-10.
    `private static double[][]` | `LN_QUICK_COEF` Coefficients for log, when input 0.99 < x < 1.01.
    `private static double[][]` | `LN_SPLIT_COEF` Coefficients for slowLog.
    `private static long` | `MASK_30BITS` Mask used to clear low order 30 bits
    `static double` | `PI` Archimede's constant PI, ratio of circle circumference to diameter.
    `private static long[]` | `PI_O_4_BITS` Bits of pi/4, need for reducePayneHanek().
    `private static long[]` | `RECIP_2PI` Bits of 1/(2*pi), need for reducePayneHanek().
    `private static double[]` | `SINE_TABLE_A` Sine table (high bits).
    `private static double[]` | `SINE_TABLE_B` Sine table (low bits).
    `private static double[]` | `TANGENT_TABLE_A` Tangent table, used by atan() (high bits).
    `private static double[]` | `TANGENT_TABLE_B` Tangent table, used by atan() (low bits).
    `private static double` | `TWO_POWER_52` 2^52 - double numbers this large must be integral (no fraction) or NaN or Infinite

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `private` | `FastMath()` Private Constructor

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `static double` | `abs(double x)` Absolute value.
    `static float` | `abs(float x)` Absolute value.
    `static int` | `abs(int x)` Absolute value.
    `static long` | `abs(long x)` Absolute value.
    `static double` | `acos(double x)` Compute the arc cosine of a number.
    `static double` | `acosh(double a)` Compute the inverse hyperbolic cosine of a number.
    `static double` | `asin(double x)` Compute the arc sine of a number.
    `static double` | `asinh(double a)` Compute the inverse hyperbolic sine of a number.
    `static double` | `atan(double x)` Arctangent function
    `private static double` | `atan(double xa, double xb, boolean leftPlane)` Internal helper function to compute arctangent.
    `static double` | `atan2(double y, double x)` Two arguments arctangent function
    `static double` | `atanh(double a)` Compute the inverse hyperbolic tangent of a number.
    `private static void` | `buildSinCosTables()` Build the sine and cosine tables.
    `static double` | `cbrt(double x)` Compute the cubic root of a number.
    `static double` | `ceil(double x)` Get the smallest whole number larger than x.
    `static double` | `copySign(double magnitude, double sign)` Returns the first argument with the sign of the second argument.
    `static float` | `copySign(float magnitude, float sign)` Returns the first argument with the sign of the second argument.
    `static double` | `cos(double x)` Cosine function
    `static double` | `cosh(double x)` Compute the hyperbolic cosine of a number.
    `private static double` | `cosQ(double xa, double xb)` Compute cosine in the first quadrant by subtracting input from PI/2 and then calling sinQ.
    `private static double` | `doubleHighPart(double d)` Get the high order bits from the mantissa.
    `static double` | `exp(double x)` Exponential function.
    `private static double` | `exp(double x, double extra, double[] hiPrec)` Internal helper method for exponential function.
    `private static double` | `expint(int p, double[] result)` Compute exp(p) for a integer p in extended precision.
    `static double` | `expm1(double x)` Compute exp(x) - 1
    `private static double` | `expm1(double x, double[] hiPrecOut)` Internal helper method for expm1
    `static double` | `floor(double x)` Get the largest whole number smaller than x.
    `static int` | `getExponent(double d)` Return the exponent of a double number, removing the bias.
    `static int` | `getExponent(float f)` Return the exponent of a float number, removing the bias.
    `static double` | `hypot(double x, double y)` Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2) avoiding intermediate overflow or underflow.
    `static double` | `IEEEremainder(double dividend, double divisor)` Computes the remainder as prescribed by the IEEE 754 standard.
    `static double` | `log(double x)` Natural logarithm.
    `private static double` | `log(double x, double[] hiPrec)` Internal helper method for natural logarithm function.
    `static double` | `log10(double x)` Compute the base 10 logarithm.
    `static double` | `log1p(double x)` Compute log(1 + x).
    `static double` | `max(double a, double b)` Compute the maximum of two values
    `static float` | `max(float a, float b)` Compute the maximum of two values
    `static int` | `max(int a, int b)` Compute the maximum of two values
    `static long` | `max(long a, long b)` Compute the maximum of two values
    `static double` | `min(double a, double b)` Compute the minimum of two values
    `static float` | `min(float a, float b)` Compute the minimum of two values
    `static int` | `min(int a, int b)` Compute the minimum of two values
    `static long` | `min(long a, long b)` Compute the minimum of two values
    `static double` | `nextAfter(double d, double direction)` Get the next machine representable number after a number, moving in the direction of another number.
    `static float` | `nextAfter(float f, double direction)` Get the next machine representable number after a number, moving in the direction of another number.
    `static double` | `nextUp(double a)` Compute next number towards positive infinity.
    `static float` | `nextUp(float a)` Compute next number towards positive infinity.
    `private static double` | `polyCosine(double x)` Computes cos(x) - 1, where |x| < 1/16.
    `private static double` | `polySine(double x)` Computes sin(x) - x, where |x| < 1/16.
    `static double` | `pow(double x, double y)` Power function.
    `private static void` | `quadMult(double[] a, double[] b, double[] result)` Compute (a[0] + a[1]) * (b[0] + b[1]) in extended precision.
    `static double` | `random()` Returns a pseudo-random number between 0.0 and 1.0.
    `private static void` | `reducePayneHanek(double x, double[] result)` Reduce the input argument using the Payne and Hanek method.
    `private static void` | `resplit(double[] a)` Recompute a split.
    `static double` | `rint(double x)` Get the whole number that is the nearest to x, or the even one if x is exactly half way between two integers.
    `static long` | `round(double x)` Get the closest long to x.
    `static int` | `round(float x)` Get the closest int to x.
    `static double` | `scalb(double d, int n)` Multiply a double number by a power of 2.
    `static float` | `scalb(float f, int n)` Multiply a float number by a power of 2.
    `static double` | `signum(double a)` Compute the signum of a number.
    `static float` | `signum(float a)` Compute the signum of a number.
    `static double` | `sin(double x)` Sine function.
    `static double` | `sinh(double x)` Compute the hyperbolic sine of a number.
    `private static double` | `sinQ(double xa, double xb)` Compute sine over the first quadrant (0 < x < pi/2).
    `private static double` | `slowCos(double x, double[] result)` For x between 0 and pi/4 compute cosine
    `private static double` | `slowexp(double x, double[] result)` For x between 0 and 1, returns exp(x), uses extended precision
    `private static double[]` | `slowLog(double xi)` xi in the range of [1, 2].
    `private static double` | `slowSin(double x, double[] result)` For x between 0 and pi/4 compute sine.
    `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.
    `private static void` | `splitReciprocal(double[] in, double[] result)` Compute the reciprocal of in.
    `static double` | `sqrt(double a)` Compute the square root of a number.
    `static double` | `tan(double x)` Tangent function
    `static double` | `tanh(double x)` Compute the hyperbolic tangent of a number.
    `private static double` | `tanQ(double xa, double xb, boolean cotanFlag)` Compute tangent (or cotangent) over the first quadrant.
    `static double` | `toDegrees(double x)` Convert radians to degrees, with error of less than 0.5 ULP
    `static double` | `toRadians(double x)` Convert degrees to radians, with error of less than 0.5 ULP
    `static double` | `ulp(double x)` Compute least significant bit (Unit in Last Position) for a number.
    `static float` | `ulp(float x)` Compute least significant bit (Unit in Last Position) for a number.

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

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

- - ### Field Detail

    - #### PI

          public static final double PI

      Archimede's constant PI, ratio of circle circumference to diameter.
      See Also:
        Constant Field Values

    - #### E

          public static final double E

      Napier's constant e, base of the natural logarithm.
      See Also:
        Constant Field Values

    - #### EXP_INT_TABLE_A

          private static final double[] EXP_INT_TABLE_A

      Exponential evaluated at integer values, exp(x) = expIntTableA[x + 750] + expIntTableB[x+750].

    - #### EXP_INT_TABLE_B

          private static final double[] EXP_INT_TABLE_B

      Exponential evaluated at integer values, exp(x) = expIntTableA[x + 750] + expIntTableB[x+750]

    - #### EXP_FRAC_TABLE_A

          private static final double[] EXP_FRAC_TABLE_A

      Exponential over the range of 0 - 1 in increments of 2^-10 exp(x/1024) = expFracTableA[x] + expFracTableB[x].

    - #### EXP_FRAC_TABLE_B

          private static final double[] EXP_FRAC_TABLE_B

      Exponential over the range of 0 - 1 in increments of 2^-10 exp(x/1024) = expFracTableA[x] + expFracTableB[x].

    - #### FACT

          private static final double[] FACT

      Factorial table, for Taylor series expansions.

    - #### LN_MANT

          private static final double[][] LN_MANT

      Extended precision logarithm table over the range 1 - 2 in increments of 2^-10.

    - #### LN_2_A

          private static final double LN_2_A

      log(2) (high bits).
      See Also:
        Constant Field Values

    - #### LN_2_B

          private static final double LN_2_B

      log(2) (low bits).
      See Also:
        Constant Field Values

    - #### LN_SPLIT_COEF

          private static final double[][] LN_SPLIT_COEF

      Coefficients for slowLog.

    - #### LN_QUICK_COEF

          private static final double[][] LN_QUICK_COEF

      Coefficients for log, when input 0.99 < x < 1.01.

    - #### LN_HI_PREC_COEF

          private static final double[][] LN_HI_PREC_COEF

      Coefficients for log in the range of 1.0 < x < 1.0 + 2^-10.

    - #### SINE_TABLE_A

          private static final double[] SINE_TABLE_A

      Sine table (high bits).

    - #### SINE_TABLE_B

          private static final double[] SINE_TABLE_B

      Sine table (low bits).

    - #### COSINE_TABLE_A

          private static final double[] COSINE_TABLE_A

      Cosine table (high bits).

    - #### COSINE_TABLE_B

          private static final double[] COSINE_TABLE_B

      Cosine table (low bits).

    - #### TANGENT_TABLE_A

          private static final double[] TANGENT_TABLE_A

      Tangent table, used by atan() (high bits).

    - #### TANGENT_TABLE_B

          private static final double[] TANGENT_TABLE_B

      Tangent table, used by atan() (low bits).

    - #### RECIP_2PI

          private static final long[] RECIP_2PI

      Bits of 1/(2*pi), need for reducePayneHanek().

    - #### PI_O_4_BITS

          private static final long[] PI_O_4_BITS

      Bits of pi/4, need for reducePayneHanek().

    - #### EIGHTHS

          private static final double[] EIGHTHS

      Eighths. This is used by sinQ, because its faster to do a table lookup than a multiply in this time-critical routine

    - #### CBRTTWO

          private static final double[] CBRTTWO

      Table of 2^((n+2)/3)

    - #### 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

    - #### MASK_30BITS

          private static final long MASK_30BITS

      Mask used to clear low order 30 bits
      See Also:
        Constant Field Values

    - #### TWO_POWER_52

          private static final double TWO_POWER_52

      2^52 - double numbers this large must be integral (no fraction) or NaN or Infinite
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### FastMath

          private FastMath()

      Private Constructor

  - ### Method Detail

    - #### doubleHighPart

          private static double doubleHighPart(double d)

      Get the high order bits from the mantissa. Equivalent to adding and subtracting HEX_40000 but also works for very large numbers
      Parameters:
        `d` - the value to split
      Returns:
        the high order part of the mantissa

    - #### sqrt

          public static double sqrt(double a)

      Compute the square root of a number.

      Note: this implementation currently delegates to `Math.sqrt(double)`

      Parameters:
        `a` - number on which evaluation is done
      Returns:
        square root of a

    - #### cosh

          public static double cosh(double x)

      Compute the hyperbolic cosine of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        hyperbolic cosine of x

    - #### sinh

          public static double sinh(double x)

      Compute the hyperbolic sine of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        hyperbolic sine of x

    - #### tanh

          public static double tanh(double x)

      Compute the hyperbolic tangent of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        hyperbolic tangent of x

    - #### acosh

          public static double acosh(double a)

      Compute the inverse hyperbolic cosine of a number.
      Parameters:
        `a` - number on which evaluation is done
      Returns:
        inverse hyperbolic cosine of a

    - #### asinh

          public static double asinh(double a)

      Compute the inverse hyperbolic sine of a number.
      Parameters:
        `a` - number on which evaluation is done
      Returns:
        inverse hyperbolic sine of a

    - #### atanh

          public static double atanh(double a)

      Compute the inverse hyperbolic tangent of a number.
      Parameters:
        `a` - number on which evaluation is done
      Returns:
        inverse hyperbolic tangent of a

    - #### signum

          public static double signum(double a)

      Compute the signum of a number. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
      Parameters:
        `a` - number on which evaluation is done
      Returns:
        -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a

    - #### signum

          public static float signum(float a)

      Compute the signum of a number. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
      Parameters:
        `a` - number on which evaluation is done
      Returns:
        -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a

    - #### nextUp

          public static double nextUp(double a)

      Compute next number towards positive infinity.
      Parameters:
        `a` - number to which neighbor should be computed
      Returns:
        neighbor of a towards positive infinity

    - #### nextUp

          public static float nextUp(float a)

      Compute next number towards positive infinity.
      Parameters:
        `a` - number to which neighbor should be computed
      Returns:
        neighbor of a towards positive infinity

    - #### random

          public static double random()

      Returns a pseudo-random number between 0.0 and 1.0.

      Note: this implementation currently delegates to `Math.random()`

      Returns:
        a random number between 0.0 and 1.0

    - #### exp

          public static double exp(double x)

      Exponential function. Computes exp(x), function result is nearly rounded. It will be correctly rounded to the theoretical value for 99.9% of input values, otherwise it will have a 1 UPL error. Method: Lookup intVal = exp(int(x)) Lookup fracVal = exp(int(x-int(x) / 1024.0) * 1024.0 ); Compute z as the exponential of the remaining bits by a polynomial minus one exp(x) = intVal * fracVal * (1 + z) Accuracy: Calculation is done with 63 bits of precision, so result should be correctly rounded for 99.9% of input values, with less than 1 ULP error otherwise.
      Parameters:
        `x` - a double
      Returns:
        double ex

    - #### exp

          private static double exp(double x,
                   double extra,
                   double[] hiPrec)

      Internal helper method for exponential function.
      Parameters:
        `x` - original argument of the exponential function
        `extra` - extra bits of precision on input (To Be Confirmed)
        `hiPrec` - extra bits of precision on output (To Be Confirmed)
      Returns:
        exp(x)

    - #### expm1

          public static double expm1(double x)

      Compute exp(x) - 1
      Parameters:
        `x` - number to compute shifted exponential
      Returns:
        exp(x) - 1

    - #### expm1

          private static double expm1(double x,
                     double[] hiPrecOut)

      Internal helper method for expm1
      Parameters:
        `x` - number to compute shifted exponential
        `hiPrecOut` - receive high precision result for -1.0 < x < 1.0
      Returns:
        exp(x) - 1

    - #### slowexp

          private 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

          private 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

          private 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])

    - #### log

          public static double log(double x)

      Natural logarithm.
      Parameters:
        `x` - a double
      Returns:
        log(x)

    - #### log

          private static double log(double x,
                   double[] hiPrec)

      Internal helper method for natural logarithm function.
      Parameters:
        `x` - original argument of the natural logarithm function
        `hiPrec` - extra bits of precision on output (To Be Confirmed)
      Returns:
        log(x)

    - #### log1p

          public static double log1p(double x)

      Compute log(1 + x).
      Parameters:
        `x` - a number
      Returns:
        log(1 + x)

    - #### log10

          public static double log10(double x)

      Compute the base 10 logarithm.
      Parameters:
        `x` - a number
      Returns:
        log10(x)

    - #### pow

          public static double pow(double x,
                   double y)

      Power function. Compute x^y.
      Parameters:
        `x` - a double
        `y` - a double
      Returns:
        double

    - #### slowLog

          private 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)

    - #### slowSin

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

      For x between 0 and pi/4 compute sine.
      Parameters:
        `x` - number from which sine is requested
        `result` - placeholder where to put the result in extended precision
      Returns:
        sin(x)

    - #### slowCos

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

      For x between 0 and pi/4 compute cosine
      Parameters:
        `x` - number from which cosine is requested
        `result` - placeholder where to put the result in extended precision
      Returns:
        cos(x)

    - #### buildSinCosTables

          private static void buildSinCosTables()

      Build the sine and cosine tables.

    - #### polySine

          private static double polySine(double x)

      Computes sin(x) - x, where |x| < 1/16. Use a Remez polynomial approximation.
      Parameters:
        `x` - a number smaller than 1/16
      Returns:
        sin(x) - x

    - #### polyCosine

          private static double polyCosine(double x)

      Computes cos(x) - 1, where |x| < 1/16. Use a Remez polynomial approximation.
      Parameters:
        `x` - a number smaller than 1/16
      Returns:
        cos(x) - 1

    - #### sinQ

          private static double sinQ(double xa,
                    double xb)

      Compute sine over the first quadrant (0 < x < pi/2). Use combination of table lookup and rational polynomial expansion.
      Parameters:
        `xa` - number from which sine is requested
        `xb` - extra bits for x (may be 0.0)
      Returns:
        sin(xa + xb)

    - #### cosQ

          private static double cosQ(double xa,
                    double xb)

      Compute cosine in the first quadrant by subtracting input from PI/2 and then calling sinQ. This is more accurate as the input approaches PI/2.
      Parameters:
        `xa` - number from which cosine is requested
        `xb` - extra bits for x (may be 0.0)
      Returns:
        cos(xa + xb)

    - #### tanQ

          private static double tanQ(double xa,
                    double xb,
                    boolean cotanFlag)

      Compute tangent (or cotangent) over the first quadrant. 0 < x < pi/2 Use combination of table lookup and rational polynomial expansion.
      Parameters:
        `xa` - number from which sine is requested
        `xb` - extra bits for x (may be 0.0)
        `cotanFlag` - if true, compute the cotangent instead of the tangent
      Returns:
        tan(xa+xb) (or cotangent, depending on cotanFlag)

    - #### reducePayneHanek

          private static void reducePayneHanek(double x,
                              double[] result)

      Reduce the input argument using the Payne and Hanek method. This is good for all inputs 0.0 < x < inf Output is remainder after dividing by PI/2 The result array should contain 3 numbers. result[0] is the integer portion, so mod 4 this gives the quadrant. result[1] is the upper bits of the remainder result[2] is the lower bits of the remainder
      Parameters:
        `x` - number to reduce
        `result` - placeholder where to put the result

    - #### sin

          public static double sin(double x)

      Sine function.
      Parameters:
        `x` - a number
      Returns:
        sin(x)

    - #### cos

          public static double cos(double x)

      Cosine function
      Parameters:
        `x` - a number
      Returns:
        cos(x)

    - #### tan

          public static double tan(double x)

      Tangent function
      Parameters:
        `x` - a number
      Returns:
        tan(x)

    - #### atan

          public static double atan(double x)

      Arctangent function
      Parameters:
        `x` - a number
      Returns:
        atan(x)

    - #### atan

          private static double atan(double xa,
                    double xb,
                    boolean leftPlane)

      Internal helper function to compute arctangent.
      Parameters:
        `xa` - number from which arctangent is requested
        `xb` - extra bits for x (may be 0.0)
        `leftPlane` - if true, result angle must be put in the left half plane
      Returns:
        atan(xa + xb) (or angle shifted by `PI` if leftPlane is true)

    - #### atan2

          public static double atan2(double y,
                     double x)

      Two arguments arctangent function
      Parameters:
        `y` - ordinate
        `x` - abscissa
      Returns:
        phase angle of point (x,y) between `-PI` and `PI`

    - #### asin

          public static double asin(double x)

      Compute the arc sine of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        arc sine of x

    - #### acos

          public static double acos(double x)

      Compute the arc cosine of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        arc cosine of x

    - #### cbrt

          public static double cbrt(double x)

      Compute the cubic root of a number.
      Parameters:
        `x` - number on which evaluation is done
      Returns:
        cubic root of x

    - #### toRadians

          public static double toRadians(double x)

      Convert degrees to radians, with error of less than 0.5 ULP
      Parameters:
        `x` - angle in degrees
      Returns:
        x converted into radians

    - #### toDegrees

          public static double toDegrees(double x)

      Convert radians to degrees, with error of less than 0.5 ULP
      Parameters:
        `x` - angle in radians
      Returns:
        x converted into degrees

    - #### abs

          public static int abs(int x)

      Absolute value.
      Parameters:
        `x` - number from which absolute value is requested
      Returns:
        abs(x)

    - #### abs

          public static long abs(long x)

      Absolute value.
      Parameters:
        `x` - number from which absolute value is requested
      Returns:
        abs(x)

    - #### abs

          public static float abs(float x)

      Absolute value.
      Parameters:
        `x` - number from which absolute value is requested
      Returns:
        abs(x)

    - #### abs

          public static double abs(double x)

      Absolute value.
      Parameters:
        `x` - number from which absolute value is requested
      Returns:
        abs(x)

    - #### ulp

          public static double ulp(double x)

      Compute least significant bit (Unit in Last Position) for a number.
      Parameters:
        `x` - number from which ulp is requested
      Returns:
        ulp(x)

    - #### ulp

          public static float ulp(float x)

      Compute least significant bit (Unit in Last Position) for a number.
      Parameters:
        `x` - number from which ulp is requested
      Returns:
        ulp(x)

    - #### scalb

          public static double scalb(double d,
                     int n)

      Multiply a double number by a power of 2.
      Parameters:
        `d` - number to multiply
        `n` - power of 2
      Returns:
        d × 2n

    - #### scalb

          public static float scalb(float f,
                    int n)

      Multiply a float number by a power of 2.
      Parameters:
        `f` - number to multiply
        `n` - power of 2
      Returns:
        f × 2n

    - #### nextAfter

          public static double nextAfter(double d,
                         double direction)

      Get the next machine representable number after a number, moving in the direction of another number.

      The ordering is as follows (increasing):

      - -INFINITY
      - -MAX_VALUE
      - -MIN_VALUE
      - -0.0
      - +0.0
      - +MIN_VALUE
      - +MAX_VALUE
      - +INFINITY

      If arguments compare equal, then the second argument is returned.

      If `direction` is greater than `d`, the smallest machine representable number strictly greater than `d` is returned; if less, then the largest representable number strictly less than `d` is returned.

      If `d` is infinite and direction does not bring it back to finite numbers, it is returned unchanged.

      Parameters:
        `d` - base number
        `direction` - (the only important thing is whether `direction` is greater or smaller than `d`)
      Returns:
        the next machine representable number in the specified direction

    - #### nextAfter

          public static float nextAfter(float f,
                        double direction)

      Get the next machine representable number after a number, moving in the direction of another number.

      The ordering is as follows (increasing):

      - -INFINITY
      - -MAX_VALUE
      - -MIN_VALUE
      - -0.0
      - +0.0
      - +MIN_VALUE
      - +MAX_VALUE
      - +INFINITY

      If arguments compare equal, then the second argument is returned.

      If `direction` is greater than `f`, the smallest machine representable number strictly greater than `f` is returned; if less, then the largest representable number strictly less than `f` is returned.

      If `f` is infinite and direction does not bring it back to finite numbers, it is returned unchanged.

      Parameters:
        `f` - base number
        `direction` - (the only important thing is whether `direction` is greater or smaller than `f`)
      Returns:
        the next machine representable number in the specified direction

    - #### floor

          public static double floor(double x)

      Get the largest whole number smaller than x.
      Parameters:
        `x` - number from which floor is requested
      Returns:
        a double number f such that f is an integer f <= x < f + 1.0

    - #### ceil

          public static double ceil(double x)

      Get the smallest whole number larger than x.
      Parameters:
        `x` - number from which ceil is requested
      Returns:
        a double number c such that c is an integer c - 1.0 < x <= c

    - #### rint

          public static double rint(double x)

      Get the whole number that is the nearest to x, or the even one if x is exactly half way between two integers.
      Parameters:
        `x` - number from which nearest whole number is requested
      Returns:
        a double number r such that r is an integer r - 0.5 <= x <= r + 0.5

    - #### round

          public static long round(double x)

      Get the closest long to x.
      Parameters:
        `x` - number from which closest long is requested
      Returns:
        closest long to x

    - #### round

          public static int round(float x)

      Get the closest int to x.
      Parameters:
        `x` - number from which closest int is requested
      Returns:
        closest int to x

    - #### min

          public static int min(int a,
                int b)

      Compute the minimum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        a if a is lesser or equal to b, b otherwise

    - #### min

          public static long min(long a,
                 long b)

      Compute the minimum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        a if a is lesser or equal to b, b otherwise

    - #### min

          public static float min(float a,
                  float b)

      Compute the minimum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        a if a is lesser or equal to b, b otherwise

    - #### min

          public static double min(double a,
                   double b)

      Compute the minimum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        a if a is lesser or equal to b, b otherwise

    - #### max

          public static int max(int a,
                int b)

      Compute the maximum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        b if a is lesser or equal to b, a otherwise

    - #### max

          public static long max(long a,
                 long b)

      Compute the maximum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        b if a is lesser or equal to b, a otherwise

    - #### max

          public static float max(float a,
                  float b)

      Compute the maximum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        b if a is lesser or equal to b, a otherwise

    - #### max

          public static double max(double a,
                   double b)

      Compute the maximum of two values
      Parameters:
        `a` - first value
        `b` - second value
      Returns:
        b if a is lesser or equal to b, a otherwise

    - #### hypot

          public static double hypot(double x,
                     double y)

      Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2)
      avoiding intermediate overflow or underflow.
      - If either argument is infinite, then the result is positive infinity.
      - else, if either argument is NaN then the result is NaN.
      Parameters:
        `x` - a value
        `y` - a value
      Returns:
        sqrt(x2 +y2)

    - #### IEEEremainder

          public static double IEEEremainder(double dividend,
                             double divisor)

      Computes the remainder as prescribed by the IEEE 754 standard. The remainder value is mathematically equal to `x - y*n` where `n` is the mathematical integer closest to the exact mathematical value of the quotient `x/y`. If two mathematical integers are equally close to `x/y` then `n` is the integer that is even.

      - If either operand is NaN, the result is NaN.
      - If the result is not NaN, the sign of the result equals the sign of the dividend.
      - If the dividend is an infinity, or the divisor is a zero, or both, the result is NaN.
      - If the dividend is finite and the divisor is an infinity, the result equals the dividend.
      - If the dividend is a zero and the divisor is finite, the result equals the dividend.

      Note: this implementation currently delegates to `StrictMath.IEEEremainder(double, double)`

      Parameters:
        `dividend` - the number to be divided
        `divisor` - the number by which to divide
      Returns:
        the remainder, rounded

    - #### copySign

          public static double copySign(double magnitude,
                        double sign)

      Returns the first argument with the sign of the second argument. A NaN `sign` argument is treated as positive.
      Parameters:
        `magnitude` - the value to return
        `sign` - the sign for the returned value
      Returns:
        the magnitude with the same sign as the `sign` argument

    - #### copySign

          public static float copySign(float magnitude,
                       float sign)

      Returns the first argument with the sign of the second argument. A NaN `sign` argument is treated as positive.
      Parameters:
        `magnitude` - the value to return
        `sign` - the sign for the returned value
      Returns:
        the magnitude with the same sign as the `sign` argument

    - #### getExponent

          public static int getExponent(double d)

      Return the exponent of a double number, removing the bias.

      For double numbers of the form 2x, the unbiased exponent is exactly x.

      Parameters:
        `d` - number from which exponent is requested
      Returns:
        exponent for d in IEEE754 representation, without bias

    - #### getExponent

          public static int getExponent(float f)

      Return the exponent of a float number, removing the bias.

      For float numbers of the form 2x, the unbiased exponent is exactly x.

      Parameters:
        `f` - number from which exponent is requested
      Returns:
        exponent for d in IEEE754 representation, without bias

Copyright (c) 2003-2013 Apache Software Foundation