Class FastMath

java.lang.Object

org.apache.commons.math3.util.FastMath

public class FastMath
extends Object

Faster, more accurate, portable alternative to Math and StrictMath 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) or Math.cbrt(y)), user can directly change the class and use the methods as is (using FastMath.sin(x) or FastMath.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:

• asinh(double)
• acosh(double)
• atanh(double)

The following methods are found in Math/StrictMath since 1.6 only, they are provided by FastMath even in 1.5 Java virtual machines

• copySign(double, double)
• getExponent(double)
• nextAfter(double,double)
• nextUp(double)
• scalb(double, int)
• copySign(float, float)
• getExponent(float)
• nextAfter(float,double)
• nextUp(float)
• scalb(float, int)

Since:

2.2

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 final double[]	CBRTTWO	Table of 2^((n+2)/3)
private static final double[]	COSINE_TABLE_A	Cosine table (high bits).
private static final double[]	COSINE_TABLE_B	Cosine table (low bits).
static final double	E	Napier's constant e, base of the natural logarithm.
private static final double[]	EIGHTHS	Eighths.
(package private) static final int	EXP_FRAC_TABLE_LEN	Exponential fractions table length.
(package private) static final int	EXP_INT_TABLE_LEN	Length of the array of integer exponentials.
(package private) static final int	EXP_INT_TABLE_MAX_INDEX	Index of exp(0) in the array of integer exponentials.
private static final double	F_1_11	Constant: 0.09090909090909091.
private static final double	F_1_13	Constant: 0.07692307692307693.
private static final double	F_1_15	Constant: 0.06666666666666667.
private static final double	F_1_17	Constant: 0.058823529411764705.
private static final double	F_1_2	Constant: 0.5.
private static final double	F_1_3	Constant: 0.3333333333333333.
private static final double	F_1_4	Constant: 0.25.
private static final double	F_1_5	Constant: 0.2.
private static final double	F_1_7	Constant: 0.14285714285714285.
private static final double	F_1_9	Constant: 0.1111111111111111.
private static final double	F_11_12	Constant: 0.9166666666666666.
private static final double	F_13_14	Constant: 0.9285714285714286.
private static final double	F_15_16	Constant: 0.9375.
private static final double	F_3_4	Constant: 0.75.
private static final double	F_5_6	Constant: 0.8333333333333334.
private static final double	F_7_8	Constant: 0.875.
private static final double	F_9_10	Constant: 0.9.
private static final long	HEX_40000000	0x40000000 - used to split a double into two parts, both with the low order bits cleared.
private static final long	IMPLICIT_HIGH_BIT	Mask used to add implicit high order bit for normalized double.
private static final double	LN_2_A	log(2) (high bits).
private static final double	LN_2_B	log(2) (low bits).
private static final double[][]	LN_HI_PREC_COEF	Coefficients for log in the range of 1.0 invalid input: '<' x invalid input: '<' 1.0 + 2^-10.
(package private) static final int	LN_MANT_LEN	Logarithm table length.
private static final double[][]	LN_QUICK_COEF	Coefficients for log, when input 0.99 invalid input: '<' x invalid input: '<' 1.01.
private static final double	LOG_MAX_VALUE	StrictMath.log(Double.MAX_VALUE):
private static final long	MASK_30BITS	Mask used to clear low order 30 bits
private static final long	MASK_DOUBLE_EXPONENT	Mask used to extract exponent from double bits.
private static final long	MASK_DOUBLE_MANTISSA	Mask used to extract mantissa from double bits.
private static final int	MASK_NON_SIGN_INT	Mask used to clear the non-sign part of an int.
private static final long	MASK_NON_SIGN_LONG	Mask used to clear the non-sign part of a long.
static final double	PI	Archimede's constant PI, ratio of circle circumference to diameter.
private static final long[]	PI_O_4_BITS	Bits of pi/4, need for reducePayneHanek().
private static final long[]	RECIP_2PI	Bits of 1/(2*pi), need for reducePayneHanek().
private static final boolean	RECOMPUTE_TABLES_AT_RUNTIME	Indicator for tables initialization.
private static final double[]	SINE_TABLE_A	Sine table (high bits).
private static final double[]	SINE_TABLE_B	Sine table (low bits).
private static final int	SINE_TABLE_LEN	Sine, Cosine, Tangent tables are for 0, 1/8, 2/8, ...
private static final double[]	TANGENT_TABLE_A	Tangent table, used by atan() (high bits).
private static final double[]	TANGENT_TABLE_B	Tangent table, used by atan() (low bits).
private static final 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

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 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.
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) - 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	floorDiv(int a, int b)	Finds q such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 0.
static long	floorDiv(long a, long b)	Finds q such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 0.
static int	floorMod(int a, int b)	Finds r such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 0.
static long	floorMod(long a, long b)	Finds r such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 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 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(String[] a)	Print out contents of arrays, and check the length.
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 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| invalid input: '<' 1/16.
private static double	polySine(double x)	Computes sin(x) - x, where |x| invalid input: '<' 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 invalid input: '<' x invalid input: '<' 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 ULP
static int	toIntExact(long n)	Convert a long to interger, detecting overflows
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 Object

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

Field Details

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 invalid input: '<' x invalid input: '<' 1.01.

LN_HI_PREC_COEF

private static final double[][] LN_HI_PREC_COEF

Coefficients for log in the range of 1.0 invalid input: '<' x invalid input: '<' 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

Constructor Details

FastMath

private FastMath()

Private Constructor

Method Details

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 e^x

exp

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

Internal helper method for exponential function.

Parameters:

x - original argument of the exponential function

extra - extra bits of precision on input (To Be Confirmed)

hiPrec - extra bits of precision on output (To Be Confirmed)

Returns:

exp(x)

expm1

public static double expm1(double x)

Compute exp(x) - 1

Parameters:

x - number to compute shifted exponential

Returns:

exp(x) - 1

expm1

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

Internal helper method for expm1

Parameters:

x - number to compute shifted exponential

hiPrecOut - receive high precision result for -1.0 invalid input: '<' x invalid input: '<' 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 function

hiPrec - 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. Returns NaN if either argument is negative. If base is 0 and x is positive, 0 is returned. If base is positive and x is 0, Double.NEGATIVE_INFINITY is returned. If both arguments are 0, the result is NaN.

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 that basey = 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 double

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

d^e

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:

d^e

Since:

3.6

polySine

private static double polySine(double x)

Computes sin(x) - x, where |x| invalid input: '<' 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| invalid input: '<' 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 invalid input: '<' x invalid input: '<' 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 invalid input: '<' x invalid input: '<' 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 invalid input: '<' x invalid input: '<' 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 - 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 requested

xb - extra bits for x (may be 0.0)

leftPlane - if true, result angle must be put in the left half plane

Returns:

atan(xa + xb) (or angle shifted by PI if leftPlane is true)

atan2

public static double atan2(double y,
 double x)

Two arguments arctangent function

Parameters:

y - ordinate

x - abscissa

Returns:

phase angle of point (x,y) between -PI and PI

asin

public static double asin(double x)

Compute the arc sine of a number.

Parameters:

x - number on which evaluation is done

Returns:

arc sine of x

acos

public static double acos(double x)

Compute the arc cosine of a number.

Parameters:

x - number on which evaluation is done

Returns:

arc cosine of x

cbrt

public static double cbrt(double x)

Compute the cubic root of a number.

Parameters:

x - number on which evaluation is done

Returns:

cubic root of x

toRadians

public static double toRadians(double x)

Convert degrees to radians, with error of less than 0.5 ULP

Parameters:

x - angle in degrees

Returns:

x converted into radians

toDegrees

public static double toDegrees(double x)

Convert radians to degrees, with error of less than 0.5 ULP

Parameters:

x - angle in radians

Returns:

x converted into degrees

abs

public static int abs(int x)

Absolute value.

Parameters:

x - number from which absolute value is requested

Returns:

abs(x)

abs

public static long abs(long x)

Absolute value.

Parameters:

x - number from which absolute value is requested

Returns:

abs(x)

abs

public static float abs(float x)

Absolute value.

Parameters:

x - number from which absolute value is requested

Returns:

abs(x)

abs

public static double abs(double x)

Absolute value.

Parameters:

x - number from which absolute value is requested

Returns:

abs(x)

ulp

public static double ulp(double x)

Compute least significant bit (Unit in Last Position) for a number.

Parameters:

x - number from which ulp is requested

Returns:

ulp(x)

ulp

public static float ulp(float x)

Compute least significant bit (Unit in Last Position) for a number.

Parameters:

x - number from which ulp is requested

Returns:

ulp(x)

scalb

public static double scalb(double d,
 int n)

Multiply a double number by a power of 2.

Parameters:

d - number to multiply

n - power of 2

Returns:

d × 2ⁿ

scalb

public static float scalb(float f,
 int n)

Multiply a float number by a power of 2.

Parameters:

f - number to multiply

n - power of 2

Returns:

f × 2ⁿ

nextAfter

public static double nextAfter(double d,
 double direction)

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

The ordering is as follows (increasing):

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

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

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

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

Parameters:

d - base number

direction - (the only important thing is whether direction is greater or smaller than d)

Returns:

the next machine representable number in the specified direction

nextAfter

public static float nextAfter(float f,
 double direction)

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

The ordering is as follows (increasing):

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

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

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

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

Parameters:

f - base number

direction - (the only important thing is whether direction is greater or smaller than f)

Returns:

the next machine representable number in the specified direction

floor

public static double floor(double x)

Get the largest whole number smaller than x.

Parameters:

x - number from which floor is requested

Returns:

a double number f such that f is an integer f invalid input: '<'= x invalid input: '<' 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 invalid input: '<' x invalid input: '<'= 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 invalid input: '<'= x invalid input: '<'= r + 0.5

round

public static long round(double x)

Get the closest long to x.

Parameters:

x - number from which closest long is requested

Returns:

closest long to x

round

public static int round(float x)

Get the closest int to x.

Parameters:

x - number from which closest int is requested

Returns:

closest int to x

min

public static int min(int a,
 int b)

Compute the minimum of two values

Parameters:

a - first value

b - second value

Returns:

a if a is lesser or equal to b, b otherwise

min

public static long min(long a,
 long b)

Compute the minimum of two values

Parameters:

a - first value

b - second value

Returns:

a if a is lesser or equal to b, b otherwise

min

public static float min(float a,
 float b)

Compute the minimum of two values

Parameters:

a - first value

b - second value

Returns:

a if a is lesser or equal to b, b otherwise

min

public static double min(double a,
 double b)

Compute the minimum of two values

Parameters:

a - first value

b - second value

Returns:

a if a is lesser or equal to b, b otherwise

max

public static int max(int a,
 int b)

Compute the maximum of two values

Parameters:

a - first value

b - second value

Returns:

b if a is lesser or equal to b, a otherwise

max

public static long max(long a,
 long b)

Compute the maximum of two values

Parameters:

a - first value

b - second value

Returns:

b if a is lesser or equal to b, a otherwise

max

public static float max(float a,
 float b)

Compute the maximum of two values

Parameters:

a - first value

b - second value

Returns:

b if a is lesser or equal to b, a otherwise

max

public static double max(double a,
 double b)

Compute the maximum of two values

Parameters:

a - first value

b - second value

Returns:

b if a is lesser or equal to b, a otherwise

hypot

public static double hypot(double x,
 double y)

Returns the hypotenuse of a triangle with sides x and y - sqrt(x² +y²)
avoiding intermediate overflow or underflow.

• If either argument is infinite, then the result is positive infinity.
• else, if either argument is NaN then the result is NaN.

Parameters:

x - a value

y - a value

Returns:

sqrt(x² +y²)

IEEEremainder

public static double IEEEremainder(double dividend,
 double divisor)

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

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

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

Parameters:

dividend - the number to be divided

divisor - the number by which to divide

Returns:

the remainder, rounded

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 add

b - 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 add

b - 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 number

b - 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 number

b - 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 multiply

b - 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 multiply

b - 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 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 - dividend

b - divisor

Returns:

q such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 - dividend

b - divisor

Returns:

q such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 - dividend

b - divisor

Returns:

r such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 - dividend

b - divisor

Returns:

r such that a = q b + r with 0 invalid input: '<'= r invalid input: '<' b if b > 0 and b invalid input: '<' r invalid input: '<'= 0 if b invalid input: '<' 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 NaN sign argument is treated as positive.

Parameters:

magnitude - the value to return

sign - the sign for the returned value

Returns:

the magnitude with the same sign as the sign argument

copySign

public static float copySign(float magnitude,
 float sign)

Returns the first argument with the sign of the second argument. A NaN sign argument is treated as positive.

Parameters:

magnitude - the value to return

sign - the sign for the returned value

Returns:

the magnitude with the same sign as the sign argument

getExponent

public static int getExponent(double d)

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

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

Parameters:

d - number from which exponent is requested

Returns:

exponent for d in IEEE754 representation, without bias

getExponent

public static int getExponent(float f)

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

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

Parameters:

f - number from which exponent is requested

Returns:

exponent for d in IEEE754 representation, without bias

main

public static void main(String[] a)

Print out contents of arrays, and check the length.

used to generate the preset arrays originally.

Parameters:

a - unused