org.apache.commons.math.util
Class FastMath

java.lang.Object
  extended by org.apache.commons.math.util.FastMath

public class FastMath
extends 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
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
private FastMath()
          Private Constructor
 
Method Summary
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):


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


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.

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.

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