|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.apache.commons.math.util.FastMath
public class FastMath
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 onlycopySign(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)
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 |
---|
public static final double PI
public static final double E
private static final double[] EXP_INT_TABLE_A
private static final double[] EXP_INT_TABLE_B
private static final double[] EXP_FRAC_TABLE_A
private static final double[] EXP_FRAC_TABLE_B
private static final double[] FACT
private static final double[][] LN_MANT
private static final double LN_2_A
private static final double LN_2_B
private static final double[][] LN_SPLIT_COEF
private static final double[][] LN_QUICK_COEF
private static final double[][] LN_HI_PREC_COEF
private static final double[] SINE_TABLE_A
private static final double[] SINE_TABLE_B
private static final double[] COSINE_TABLE_A
private static final double[] COSINE_TABLE_B
private static final double[] TANGENT_TABLE_A
private static final double[] TANGENT_TABLE_B
private static final long[] RECIP_2PI
private static final long[] PI_O_4_BITS
private static final double[] EIGHTHS
private static final double[] CBRTTWO
private static final long HEX_40000000
private static final long MASK_30BITS
private static final double TWO_POWER_52
Constructor Detail |
---|
private FastMath()
Method Detail |
---|
private static double doubleHighPart(double d)
d
- the value to split
public static double sqrt(double a)
Note: this implementation currently delegates to Math.sqrt(double)
a
- number on which evaluation is done
public static double cosh(double x)
x
- number on which evaluation is done
public static double sinh(double x)
x
- number on which evaluation is done
public static double tanh(double x)
x
- number on which evaluation is done
public static double acosh(double a)
a
- number on which evaluation is done
public static double asinh(double a)
a
- number on which evaluation is done
public static double atanh(double a)
a
- number on which evaluation is done
public static double signum(double a)
a
- number on which evaluation is done
public static float signum(float a)
a
- number on which evaluation is done
public static double nextUp(double a)
a
- number to which neighbor should be computed
public static float nextUp(float a)
a
- number to which neighbor should be computed
public static double random()
Note: this implementation currently delegates to Math.random()
public static double exp(double x)
x
- a double
private static double exp(double x, double extra, double[] hiPrec)
x
- original argument of the exponential functionextra
- extra bits of precision on input (To Be Confirmed)hiPrec
- extra bits of precision on output (To Be Confirmed)
public static double expm1(double x)
x
- number to compute shifted exponential
private static double expm1(double x, double[] hiPrecOut)
x
- number to compute shifted exponentialhiPrecOut
- receive high precision result for -1.0 < x < 1.0
private static double slowexp(double x, double[] result)
x
- argument of exponentialresult
- placeholder where to place exp(x) split in two terms
for extra precision (i.e. exp(x) = result[0] ° result[1]
private static void split(double d, double[] split)
d
- number to splitsplit
- placeholder where to place the resultprivate static void resplit(double[] a)
a
- input/out array containing the split, changed
on outputprivate static void splitMult(double[] a, double[] b, double[] ans)
a
- first term of multiplicationb
- second term of multiplicationans
- placeholder where to put the resultprivate static void splitAdd(double[] a, double[] b, double[] ans)
a
- first term of additionb
- second term of additionans
- placeholder where to put the resultprivate static void splitReciprocal(double[] in, double[] result)
in
- initial number, in split formresult
- placeholder where to put the resultprivate static void quadMult(double[] a, double[] b, double[] result)
a
- first term of the multiplicationb
- second term of the multiplicationresult
- placeholder where to put the resultprivate static double expint(int p, double[] result)
p
- integer whose exponential is requestedresult
- placeholder where to put the result in extended precision
public static double log(double x)
x
- a double
private static double log(double x, double[] hiPrec)
x
- original argument of the natural logarithm functionhiPrec
- extra bits of precision on output (To Be Confirmed)
public static double log1p(double x)
x
- a number
public static double log10(double x)
x
- a number
public static double pow(double x, double y)
x
- a doubley
- a double
private static double[] slowLog(double xi)
xi
- number from which log is requested
private static double slowSin(double x, double[] result)
x
- number from which sine is requestedresult
- placeholder where to put the result in extended precision
private static double slowCos(double x, double[] result)
x
- number from which cosine is requestedresult
- placeholder where to put the result in extended precision
private static void buildSinCosTables()
private static double polySine(double x)
x
- a number smaller than 1/16
private static double polyCosine(double x)
x
- a number smaller than 1/16
private static double sinQ(double xa, double xb)
xa
- number from which sine is requestedxb
- extra bits for x (may be 0.0)
private static double cosQ(double xa, double xb)
xa
- number from which cosine is requestedxb
- extra bits for x (may be 0.0)
private static double tanQ(double xa, double xb, boolean cotanFlag)
xa
- number from which sine is requestedxb
- extra bits for x (may be 0.0)cotanFlag
- if true, compute the cotangent instead of the tangent
private static void reducePayneHanek(double x, double[] result)
x
- number to reduceresult
- placeholder where to put the resultpublic static double sin(double x)
x
- a number
public static double cos(double x)
x
- a number
public static double tan(double x)
x
- a number
public static double atan(double x)
x
- a number
private static double atan(double xa, double xb, boolean leftPlane)
xa
- number from which arctangent is requestedxb
- extra bits for x (may be 0.0)leftPlane
- if true, result angle must be put in the left half plane
PI
if leftPlane is true)public static double atan2(double y, double x)
y
- ordinatex
- abscissa
-PI
and PI
public static double asin(double x)
x
- number on which evaluation is done
public static double acos(double x)
x
- number on which evaluation is done
public static double cbrt(double x)
x
- number on which evaluation is done
public static double toRadians(double x)
x
- angle in degrees
public static double toDegrees(double x)
x
- angle in radians
public static int abs(int x)
x
- number from which absolute value is requested
public static long abs(long x)
x
- number from which absolute value is requested
public static float abs(float x)
x
- number from which absolute value is requested
public static double abs(double x)
x
- number from which absolute value is requested
public static double ulp(double x)
x
- number from which ulp is requested
public static float ulp(float x)
x
- number from which ulp is requested
public static double scalb(double d, int n)
d
- number to multiplyn
- power of 2
public static float scalb(float f, int n)
f
- number to multiplyn
- power of 2
public static double nextAfter(double d, double direction)
The ordering is as follows (increasing):
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.
d
- base numberdirection
- (the only important thing is whether
direction
is greater or smaller than d
)
public static float nextAfter(float f, double direction)
The ordering is as follows (increasing):
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.
f
- base numberdirection
- (the only important thing is whether
direction
is greater or smaller than f
)
public static double floor(double x)
x
- number from which floor is requested
public static double ceil(double x)
x
- number from which ceil is requested
public static double rint(double x)
x
- number from which nearest whole number is requested
public static long round(double x)
x
- number from which closest long is requested
public static int round(float x)
x
- number from which closest int is requested
public static int min(int a, int b)
a
- first valueb
- second value
public static long min(long a, long b)
a
- first valueb
- second value
public static float min(float a, float b)
a
- first valueb
- second value
public static double min(double a, double b)
a
- first valueb
- second value
public static int max(int a, int b)
a
- first valueb
- second value
public static long max(long a, long b)
a
- first valueb
- second value
public static float max(float a, float b)
a
- first valueb
- second value
public static double max(double a, double b)
a
- first valueb
- second value
public static double hypot(double x, double y)
x
and y
- sqrt(x2 +y2)
x
- a valuey
- a value
public static double IEEEremainder(double dividend, double divisor)
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)
dividend
- the number to be divideddivisor
- the number by which to divide
public static double copySign(double magnitude, double sign)
sign
argument is treated as positive.
magnitude
- the value to returnsign
- the sign for the returned value
sign
argumentpublic static float copySign(float magnitude, float sign)
sign
argument is treated as positive.
magnitude
- the value to returnsign
- the sign for the returned value
sign
argumentpublic static int getExponent(double d)
For double numbers of the form 2x, the unbiased exponent is exactly x.
d
- number from which exponent is requested
public static int getExponent(float f)
For float numbers of the form 2x, the unbiased exponent is exactly x.
f
- number from which exponent is requested
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |