FastMath (Commons MATH 2.2)

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:
The following methods are found in StrictMath since 1.6 only
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

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(x² +y²) 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 e^x
  - 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 × 2ⁿ
  - 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 × 2ⁿ
  - 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
    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
    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(x² +y²)
    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(x² +y²)
  - 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 2^x, 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 2^x, the unbiased exponent is exactly x.
    
    Parameters:
    f - number from which exponent is requested
    
    Returns:
    exponent for d in IEEE754 representation, without bias

Class FastMath

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI

E

EXP_INT_TABLE_A

EXP_INT_TABLE_B

EXP_FRAC_TABLE_A

EXP_FRAC_TABLE_B

FACT

LN_MANT

LN_2_A

LN_2_B

LN_SPLIT_COEF

LN_QUICK_COEF

LN_HI_PREC_COEF

SINE_TABLE_A

SINE_TABLE_B

COSINE_TABLE_A

COSINE_TABLE_B

TANGENT_TABLE_A

TANGENT_TABLE_B

RECIP_2PI

PI_O_4_BITS

EIGHTHS

CBRTTWO

HEX_40000000

MASK_30BITS

TWO_POWER_52

Constructor Detail

FastMath

Method Detail

doubleHighPart

sqrt

cosh

sinh

tanh

acosh

asinh

atanh

signum

signum

nextUp

nextUp

random

exp

exp

expm1

expm1

slowexp

split

resplit

splitMult

splitAdd

splitReciprocal

quadMult

expint

log

log

log1p

log10

pow

slowLog

slowSin

slowCos

buildSinCosTables

polySine

polyCosine

sinQ

cosQ

tanQ

reducePayneHanek

sin

cos

tan

atan

atan