Class FastMath
- java.lang.Object
-
- org.apache.commons.math3.util.FastMath
-
public class FastMath extends java.lang.Object
Faster, more accurate, portable alternative toMath
andStrictMath
for large scale computation.FastMath is a drop-in replacement for both Math and StrictMath. This means that for any method in Math (say
Math.sin(x)
orMath.cbrt(y)
), user can directly change the class and use the methods as is (usingFastMath.sin(x)
orFastMath.cbrt(y)
in the previous example).FastMath speed is achieved by relying heavily on optimizing compilers to native code present in many JVMs today and use of large tables. The larger tables are lazily initialised on first use, so that the setup time does not penalise methods that don't need them.
Note that FastMath is extensively used inside Apache Commons Math, so by calling some algorithms, the overhead when the the tables need to be intialised will occur regardless of the end-user calling FastMath methods directly or not. Performance figures for a specific JVM and hardware can be evaluated by running the FastMathTestPerformance tests in the test directory of the source distribution.
FastMath accuracy should be mostly independent of the JVM as it relies only on IEEE-754 basic operations and on embedded tables. Almost all operations are accurate to about 0.5 ulp throughout the domain range. This statement, of course is only a rough global observed behavior, it is not a guarantee for every double numbers input (see William Kahan's Table Maker's Dilemma).
FastMath additionally implements the following methods not found in Math/StrictMath:
The following methods are found in Math/StrictMath since 1.6 only, they are provided by FastMath even in 1.5 Java virtual machines- Since:
- 2.2
-
-
Nested Class Summary
Nested Classes Modifier and Type Class Description private static class
FastMath.CodyWaite
Enclose the Cody/Waite reduction (used in "sin", "cos" and "tan").private static class
FastMath.ExpFracTable
Enclose large data table in nested static class so it's only loaded on first access.private static class
FastMath.ExpIntTable
Enclose large data table in nested static class so it's only loaded on first access.private static class
FastMath.lnMant
Enclose large data table in nested static class so it's only loaded on first access.private static class
FastMath.Split
Class operator on double numbers split into one 26 bits number and one 27 bits number.
-
Field Summary
Fields Modifier and Type Field 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.(package private) static int
EXP_FRAC_TABLE_LEN
Exponential fractions table length.(package private) static int
EXP_INT_TABLE_LEN
Length of the array of integer exponentials.(package private) static int
EXP_INT_TABLE_MAX_INDEX
Index of exp(0) in the array of integer exponentials.private static double
F_1_11
Constant: 0.09090909090909091.private static double
F_1_13
Constant: 0.07692307692307693.private static double
F_1_15
Constant: 0.06666666666666667.private static double
F_1_17
Constant: 0.058823529411764705.private static double
F_1_2
Constant: 0.5.private static double
F_1_3
Constant: 0.3333333333333333.private static double
F_1_4
Constant: 0.25.private static double
F_1_5
Constant: 0.2.private static double
F_1_7
Constant: 0.14285714285714285.private static double
F_1_9
Constant: 0.1111111111111111.private static double
F_11_12
Constant: 0.9166666666666666.private static double
F_13_14
Constant: 0.9285714285714286.private static double
F_15_16
Constant: 0.9375.private static double
F_3_4
Constant: 0.75.private static double
F_5_6
Constant: 0.8333333333333334.private static double
F_7_8
Constant: 0.875.private static double
F_9_10
Constant: 0.9.private static long
HEX_40000000
0x40000000 - used to split a double into two parts, both with the low order bits cleared.private static long
IMPLICIT_HIGH_BIT
Mask used to add implicit high order bit for normalized double.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.(package private) static int
LN_MANT_LEN
Logarithm table length.private static double[][]
LN_QUICK_COEF
Coefficients for log, when input 0.99 < x < 1.01.private static double
LOG_MAX_VALUE
StrictMath.log(Double.MAX_VALUE):private static long
MASK_30BITS
Mask used to clear low order 30 bitsprivate static long
MASK_DOUBLE_EXPONENT
Mask used to extract exponent from double bits.private static long
MASK_DOUBLE_MANTISSA
Mask used to extract mantissa from double bits.private static int
MASK_NON_SIGN_INT
Mask used to clear the non-sign part of an int.private static long
MASK_NON_SIGN_LONG
Mask used to clear the non-sign part of a long.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 boolean
RECOMPUTE_TABLES_AT_RUNTIME
Indicator for tables initialization.private static double[]
SINE_TABLE_A
Sine table (high bits).private static double[]
SINE_TABLE_B
Sine table (low bits).private static int
SINE_TABLE_LEN
Sine, Cosine, Tangent tables are for 0, 1/8, 2/8, ...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 Description private
FastMath()
Private Constructor
-
Method Summary
All Methods Static Methods Concrete Methods Modifier and Type Method 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 int
addExact(int a, int b)
Add two numbers, detecting overflows.static long
addExact(long a, long b)
Add two numbers, detecting overflows.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 functionprivate 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 functionstatic double
atanh(double a)
Compute the inverse hyperbolic tangent of a number.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.static int
decrementExact(int n)
Decrement a number, detecting overflows.static long
decrementExact(long n)
Decrement a number, detecting overflows.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.static double
expm1(double x)
Compute exp(x) - 1private static double
expm1(double x, double[] hiPrecOut)
Internal helper method for expm1static double
floor(double x)
Get the largest whole number smaller than x.static int
floorDiv(int a, int b)
Finds q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.static long
floorDiv(long a, long b)
Finds q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.static int
floorMod(int a, int b)
Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.static long
floorMod(long a, long b)
Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.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 sidesx
andy
- 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 int
incrementExact(int n)
Increment a number, detecting overflows.static long
incrementExact(long n)
Increment a number, detecting overflows.static double
log(double x)
Natural logarithm.static double
log(double base, double x)
Computes the logarithm in a given base.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)
Computes log(1 + x).static void
main(java.lang.String[] a)
Print out contents of arrays, and check the length.static double
max(double a, double b)
Compute the maximum of two valuesstatic float
max(float a, float b)
Compute the maximum of two valuesstatic int
max(int a, int b)
Compute the maximum of two valuesstatic long
max(long a, long b)
Compute the maximum of two valuesstatic double
min(double a, double b)
Compute the minimum of two valuesstatic float
min(float a, float b)
Compute the minimum of two valuesstatic int
min(int a, int b)
Compute the minimum of two valuesstatic long
min(long a, long b)
Compute the minimum of two valuesstatic int
multiplyExact(int a, int b)
Multiply two numbers, detecting overflows.static long
multiplyExact(long a, long b)
Multiply two numbers, detecting overflows.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
nextDown(double a)
Compute next number towards negative infinity.static float
nextDown(float a)
Compute next number towards negative infinity.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.static double
pow(double d, int e)
Raise a double to an int power.static double
pow(double d, long e)
Raise a double to a long power.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.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).static double
sqrt(double a)
Compute the square root of a number.static int
subtractExact(int a, int b)
Subtract two numbers, detecting overflows.static long
subtractExact(long a, long b)
Subtract two numbers, detecting overflows.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 ULPstatic int
toIntExact(long n)
Convert a long to interger, detecting overflowsstatic double
toRadians(double x)
Convert degrees to radians, with error of less than 0.5 ULPstatic 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.
-
-
-
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_MAX_INDEX
static final int EXP_INT_TABLE_MAX_INDEX
Index of exp(0) in the array of integer exponentials.- See Also:
- Constant Field Values
-
EXP_INT_TABLE_LEN
static final int EXP_INT_TABLE_LEN
Length of the array of integer exponentials.- See Also:
- Constant Field Values
-
LN_MANT_LEN
static final int LN_MANT_LEN
Logarithm table length.- See Also:
- Constant Field Values
-
EXP_FRAC_TABLE_LEN
static final int EXP_FRAC_TABLE_LEN
Exponential fractions table length.- See Also:
- Constant Field Values
-
LOG_MAX_VALUE
private static final double LOG_MAX_VALUE
StrictMath.log(Double.MAX_VALUE):
-
RECOMPUTE_TABLES_AT_RUNTIME
private static final boolean RECOMPUTE_TABLES_AT_RUNTIME
Indicator for tables initialization.This compile-time constant should be set to true only if one explicitly wants to compute the tables at class loading time instead of using the already computed ones provided as literal arrays below.
- See Also:
- Constant Field Values
-
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_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_LEN
private static final int SINE_TABLE_LEN
Sine, Cosine, Tangent tables are for 0, 1/8, 2/8, ... 13/8 = PI/2 approx.- See Also:
- Constant Field Values
-
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
-
MASK_NON_SIGN_INT
private static final int MASK_NON_SIGN_INT
Mask used to clear the non-sign part of an int.- See Also:
- Constant Field Values
-
MASK_NON_SIGN_LONG
private static final long MASK_NON_SIGN_LONG
Mask used to clear the non-sign part of a long.- See Also:
- Constant Field Values
-
MASK_DOUBLE_EXPONENT
private static final long MASK_DOUBLE_EXPONENT
Mask used to extract exponent from double bits.- See Also:
- Constant Field Values
-
MASK_DOUBLE_MANTISSA
private static final long MASK_DOUBLE_MANTISSA
Mask used to extract mantissa from double bits.- See Also:
- Constant Field Values
-
IMPLICIT_HIGH_BIT
private static final long IMPLICIT_HIGH_BIT
Mask used to add implicit high order bit for normalized double.- 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
-
F_1_3
private static final double F_1_3
Constant: 0.3333333333333333.- See Also:
- Constant Field Values
-
F_1_5
private static final double F_1_5
Constant: 0.2.- See Also:
- Constant Field Values
-
F_1_7
private static final double F_1_7
Constant: 0.14285714285714285.- See Also:
- Constant Field Values
-
F_1_9
private static final double F_1_9
Constant: 0.1111111111111111.- See Also:
- Constant Field Values
-
F_1_11
private static final double F_1_11
Constant: 0.09090909090909091.- See Also:
- Constant Field Values
-
F_1_13
private static final double F_1_13
Constant: 0.07692307692307693.- See Also:
- Constant Field Values
-
F_1_15
private static final double F_1_15
Constant: 0.06666666666666667.- See Also:
- Constant Field Values
-
F_1_17
private static final double F_1_17
Constant: 0.058823529411764705.- See Also:
- Constant Field Values
-
F_3_4
private static final double F_3_4
Constant: 0.75.- See Also:
- Constant Field Values
-
F_15_16
private static final double F_15_16
Constant: 0.9375.- See Also:
- Constant Field Values
-
F_13_14
private static final double F_13_14
Constant: 0.9285714285714286.- See Also:
- Constant Field Values
-
F_11_12
private static final double F_11_12
Constant: 0.9166666666666666.- See Also:
- Constant Field Values
-
F_9_10
private static final double F_9_10
Constant: 0.9.- See Also:
- Constant Field Values
-
F_7_8
private static final double F_7_8
Constant: 0.875.- See Also:
- Constant Field Values
-
F_5_6
private static final double F_5_6
Constant: 0.8333333333333334.- See Also:
- Constant Field Values
-
F_1_2
private static final double F_1_2
Constant: 0.5.- See Also:
- Constant Field Values
-
F_1_4
private static final double F_1_4
Constant: 0.25.- See Also:
- Constant Field Values
-
-
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
-
nextDown
public static double nextDown(double a)
Compute next number towards negative infinity.- Parameters:
a
- number to which neighbor should be computed- Returns:
- neighbor of a towards negative infinity
- Since:
- 3.4
-
nextDown
public static float nextDown(float a)
Compute next number towards negative infinity.- Parameters:
a
- number to which neighbor should be computed- Returns:
- neighbor of a towards negative infinity
- Since:
- 3.4
-
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 ULP 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 functionextra
- 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 exponentialhiPrecOut
- receive high precision result for -1.0 < x < 1.0- Returns:
- exp(x) - 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 functionhiPrec
- extra bits of precision on output (To Be Confirmed)- Returns:
- log(x)
-
log1p
public static double log1p(double x)
Computes log(1 + x).- Parameters:
x
- Number.- Returns:
log(1 + x)
.
-
log10
public static double log10(double x)
Compute the base 10 logarithm.- Parameters:
x
- a number- Returns:
- log10(x)
-
log
public static double log(double base, double x)
Computes the logarithm in a given base. ReturnsNaN
if either argument is negative. Ifbase
is 0 andx
is positive, 0 is returned. Ifbase
is positive andx
is 0,Double.NEGATIVE_INFINITY
is returned. If both arguments are 0, the result isNaN
.- Parameters:
base
- Base of the logarithm, must be greater than 0.x
- Argument, must be greater than 0.- Returns:
- the value of the logarithm, i.e. the number
y
such thatbasey = x
. - Since:
- 1.2 (previously in
MathUtils
, moved as of version 3.0)
-
pow
public static double pow(double x, double y)
Power function. Compute x^y.- Parameters:
x
- a doubley
- a double- Returns:
- double
-
pow
public static double pow(double d, int e)
Raise a double to an int power.- Parameters:
d
- Number to raise.e
- Exponent.- Returns:
- de
- Since:
- 3.1
-
pow
public static double pow(double d, long e)
Raise a double to a long power.- Parameters:
d
- Number to raise.e
- Exponent.- Returns:
- de
- Since:
- 3.6
-
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 requestedxb
- 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 requestedxb
- 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 requestedxb
- 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 reduceresult
- placeholder where to put the result
-
sin
public static double sin(double x)
Sine function.- Parameters:
x
- Argument.- Returns:
- sin(x)
-
cos
public static double cos(double x)
Cosine function.- Parameters:
x
- Argument.- Returns:
- cos(x)
-
tan
public static double tan(double x)
Tangent function.- Parameters:
x
- Argument.- 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 requestedxb
- 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
- ordinatex
- abscissa- Returns:
- phase angle of point (x,y) between
-PI
andPI
-
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 multiplyn
- 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 multiplyn
- 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 thand
, the smallest machine representable number strictly greater thand
is returned; if less, then the largest representable number strictly less thand
is returned.If
d
is infinite and direction does not bring it back to finite numbers, it is returned unchanged.- Parameters:
d
- base numberdirection
- (the only important thing is whetherdirection
is greater or smaller thand
)- 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 thanf
, the smallest machine representable number strictly greater thanf
is returned; if less, then the largest representable number strictly less thanf
is returned.If
f
is infinite and direction does not bring it back to finite numbers, it is returned unchanged.- Parameters:
f
- base numberdirection
- (the only important thing is whetherdirection
is greater or smaller thanf
)- 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 valueb
- 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 valueb
- 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 valueb
- 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 valueb
- 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 valueb
- 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 valueb
- 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 valueb
- 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 valueb
- 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 sidesx
andy
- 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 valuey
- 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 tox - y*n
wheren
is the mathematical integer closest to the exact mathematical value of the quotientx/y
. If two mathematical integers are equally close tox/y
thenn
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 divideddivisor
- the number by which to divide- Returns:
- the remainder, rounded
-
toIntExact
public static int toIntExact(long n) throws MathArithmeticException
Convert a long to interger, detecting overflows- Parameters:
n
- number to convert to int- Returns:
- integer with same valie as n if no overflows occur
- Throws:
MathArithmeticException
- if n cannot fit into an int- Since:
- 3.4
-
incrementExact
public static int incrementExact(int n) throws MathArithmeticException
Increment a number, detecting overflows.- Parameters:
n
- number to increment- Returns:
- n+1 if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
incrementExact
public static long incrementExact(long n) throws MathArithmeticException
Increment a number, detecting overflows.- Parameters:
n
- number to increment- Returns:
- n+1 if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
decrementExact
public static int decrementExact(int n) throws MathArithmeticException
Decrement a number, detecting overflows.- Parameters:
n
- number to decrement- Returns:
- n-1 if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
decrementExact
public static long decrementExact(long n) throws MathArithmeticException
Decrement a number, detecting overflows.- Parameters:
n
- number to decrement- Returns:
- n-1 if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
addExact
public static int addExact(int a, int b) throws MathArithmeticException
Add two numbers, detecting overflows.- Parameters:
a
- first number to addb
- second number to add- Returns:
- a+b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
addExact
public static long addExact(long a, long b) throws MathArithmeticException
Add two numbers, detecting overflows.- Parameters:
a
- first number to addb
- second number to add- Returns:
- a+b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
subtractExact
public static int subtractExact(int a, int b)
Subtract two numbers, detecting overflows.- Parameters:
a
- first numberb
- second number to subtract from a- Returns:
- a-b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
subtractExact
public static long subtractExact(long a, long b)
Subtract two numbers, detecting overflows.- Parameters:
a
- first numberb
- second number to subtract from a- Returns:
- a-b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
multiplyExact
public static int multiplyExact(int a, int b)
Multiply two numbers, detecting overflows.- Parameters:
a
- first number to multiplyb
- second number to multiply- Returns:
- a*b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
multiplyExact
public static long multiplyExact(long a, long b)
Multiply two numbers, detecting overflows.- Parameters:
a
- first number to multiplyb
- second number to multiply- Returns:
- a*b if no overflows occur
- Throws:
MathArithmeticException
- if an overflow occurs- Since:
- 3.4
-
floorDiv
public static int floorDiv(int a, int b) throws MathArithmeticException
Finds q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.This methods returns the same value as integer division when a and b are same signs, but returns a different value when they are opposite (i.e. q is negative).
- Parameters:
a
- dividendb
- divisor- Returns:
- q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
- Throws:
MathArithmeticException
- if b == 0- Since:
- 3.4
- See Also:
floorMod(int, int)
-
floorDiv
public static long floorDiv(long a, long b) throws MathArithmeticException
Finds q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.This methods returns the same value as integer division when a and b are same signs, but returns a different value when they are opposite (i.e. q is negative).
- Parameters:
a
- dividendb
- divisor- Returns:
- q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
- Throws:
MathArithmeticException
- if b == 0- Since:
- 3.4
- See Also:
floorMod(long, long)
-
floorMod
public static int floorMod(int a, int b) throws MathArithmeticException
Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.This methods returns the same value as integer modulo when a and b are same signs, but returns a different value when they are opposite (i.e. q is negative).
- Parameters:
a
- dividendb
- divisor- Returns:
- r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
- Throws:
MathArithmeticException
- if b == 0- Since:
- 3.4
- See Also:
floorDiv(int, int)
-
floorMod
public static long floorMod(long a, long b)
Finds r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0.This methods returns the same value as integer modulo when a and b are same signs, but returns a different value when they are opposite (i.e. q is negative).
- Parameters:
a
- dividendb
- divisor- Returns:
- r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
- Throws:
MathArithmeticException
- if b == 0- Since:
- 3.4
- See Also:
floorDiv(long, long)
-
copySign
public static double copySign(double magnitude, double sign)
Returns the first argument with the sign of the second argument. A NaNsign
argument is treated as positive.- Parameters:
magnitude
- the value to returnsign
- 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 NaNsign
argument is treated as positive.- Parameters:
magnitude
- the value to returnsign
- 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
-
main
public static void main(java.lang.String[] a)
Print out contents of arrays, and check the length.used to generate the preset arrays originally.
- Parameters:
a
- unused
-
-