org.apache.commons.math.util

## Class FastMath

• java.lang.Object
• org.apache.commons.math.util.FastMath

• ```public class FastMath
extends java.lang.Object```
Faster, more accurate, portable alternative to `StrictMath`.

Additionally implements the following methods not found in StrictMath:

The following methods are found in StrictMath since 1.6 only
Since:
2.2
• ### Field Summary

Fields
Modifier and Type Field and Description
`static double` `E`
Napier's constant e, base of the natural logarithm.
`static double` `PI`
Archimede's constant PI, ratio of circle circumference to diameter.
• ### Method Summary

All Methods
Modifier and Type Method and Description
`static double` `abs(double x)`
Absolute value.
`static float` `abs(float x)`
Absolute value.
`static int` `abs(int x)`
Absolute value.
`static long` `abs(long x)`
Absolute value.
`static double` `acos(double x)`
Compute the arc cosine of a number.
`static double` `acosh(double a)`
Compute the inverse hyperbolic cosine of a number.
`static double` `asin(double x)`
Compute the arc sine of a number.
`static double` `asinh(double a)`
Compute the inverse hyperbolic sine of a number.
`static double` `atan(double x)`
Arctangent function
`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.
`static double` `exp(double x)`
Exponential function.
`static double` `expm1(double x)`
Compute exp(x) - 1
`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.
`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.
`static double` ```pow(double x, double y)```
Power function.
`static double` `random()`
Returns a pseudo-random number between 0.0 and 1.0.
`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.
`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.
`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

`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`
• ### Field Detail

• #### PI

`public static final double PI`
Archimede's constant PI, ratio of circle circumference to diameter.
See Also:
Constant Field Values
• #### E

`public static final double E`
Napier's constant e, base of the natural logarithm.
See Also:
Constant Field Values
• ### Method Detail

• #### sqrt

`public static double sqrt(double a)`
Compute the square root of a number.

Note: this implementation currently delegates to `Math.sqrt(double)`

Parameters:
`a` - number on which evaluation is done
Returns:
square root of a
• #### cosh

`public static double cosh(double x)`
Compute the hyperbolic cosine of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
hyperbolic cosine of x
• #### sinh

`public static double sinh(double x)`
Compute the hyperbolic sine of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
hyperbolic sine of x
• #### tanh

`public static double tanh(double x)`
Compute the hyperbolic tangent of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
hyperbolic tangent of x
• #### acosh

`public static double acosh(double a)`
Compute the inverse hyperbolic cosine of a number.
Parameters:
`a` - number on which evaluation is done
Returns:
inverse hyperbolic cosine of a
• #### asinh

`public static double asinh(double a)`
Compute the inverse hyperbolic sine of a number.
Parameters:
`a` - number on which evaluation is done
Returns:
inverse hyperbolic sine of a
• #### atanh

`public static double atanh(double a)`
Compute the inverse hyperbolic tangent of a number.
Parameters:
`a` - number on which evaluation is done
Returns:
inverse hyperbolic tangent of a
• #### signum

`public static double signum(double a)`
Compute the signum of a number. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
Parameters:
`a` - number on which evaluation is done
Returns:
-1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
• #### signum

`public static float signum(float a)`
Compute the signum of a number. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
Parameters:
`a` - number on which evaluation is done
Returns:
-1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
• #### nextUp

`public static double nextUp(double a)`
Compute next number towards positive infinity.
Parameters:
`a` - number to which neighbor should be computed
Returns:
neighbor of a towards positive infinity
• #### nextUp

`public static float nextUp(float a)`
Compute next number towards positive infinity.
Parameters:
`a` - number to which neighbor should be computed
Returns:
neighbor of a towards positive infinity
• #### random

`public static double random()`
Returns a pseudo-random number between 0.0 and 1.0.

Note: this implementation currently delegates to `Math.random()`

Returns:
a random number between 0.0 and 1.0
• #### exp

`public static double exp(double x)`
Exponential function. Computes exp(x), function result is nearly rounded. It will be correctly rounded to the theoretical value for 99.9% of input values, otherwise it will have a 1 UPL error. Method: Lookup intVal = exp(int(x)) Lookup fracVal = exp(int(x-int(x) / 1024.0) * 1024.0 ); Compute z as the exponential of the remaining bits by a polynomial minus one exp(x) = intVal * fracVal * (1 + z) Accuracy: Calculation is done with 63 bits of precision, so result should be correctly rounded for 99.9% of input values, with less than 1 ULP error otherwise.
Parameters:
`x` - a double
Returns:
double ex
• #### expm1

`public static double expm1(double x)`
Compute exp(x) - 1
Parameters:
`x` - number to compute shifted exponential
Returns:
exp(x) - 1
• #### log

`public static double log(double x)`
Natural logarithm.
Parameters:
`x` - a double
Returns:
log(x)
• #### log1p

`public static double log1p(double x)`
Compute log(1 + x).
Parameters:
`x` - a number
Returns:
log(1 + x)
• #### log10

`public static double log10(double x)`
Compute the base 10 logarithm.
Parameters:
`x` - a number
Returns:
log10(x)
• #### pow

```public static double pow(double x,
double y)```
Power function. Compute x^y.
Parameters:
`x` - a double
`y` - a double
Returns:
double
• #### sin

`public static double sin(double x)`
Sine function.
Parameters:
`x` - a number
Returns:
sin(x)
• #### cos

`public static double cos(double x)`
Cosine function
Parameters:
`x` - a number
Returns:
cos(x)
• #### tan

`public static double tan(double x)`
Tangent function
Parameters:
`x` - a number
Returns:
tan(x)
• #### atan

`public static double atan(double x)`
Arctangent function
Parameters:
`x` - a number
Returns:
atan(x)
• #### atan2

```public static double atan2(double y,
double x)```
Two arguments arctangent function
Parameters:
`y` - ordinate
`x` - abscissa
Returns:
phase angle of point (x,y) between `-PI` and `PI`
• #### asin

`public static double asin(double x)`
Compute the arc sine of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
arc sine of x
• #### acos

`public static double acos(double x)`
Compute the arc cosine of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
arc cosine of x
• #### cbrt

`public static double cbrt(double x)`
Compute the cubic root of a number.
Parameters:
`x` - number on which evaluation is done
Returns:
cubic root of x
• #### toRadians

`public static double toRadians(double x)`
Convert degrees to radians, with error of less than 0.5 ULP
Parameters:
`x` - angle in degrees
Returns:
x converted into radians
• #### toDegrees

`public static double toDegrees(double x)`
Convert radians to degrees, with error of less than 0.5 ULP
Parameters:
`x` - angle in radians
Returns:
x converted into degrees
• #### abs

`public static int abs(int x)`
Absolute value.
Parameters:
`x` - number from which absolute value is requested
Returns:
abs(x)
• #### abs

`public static long abs(long x)`
Absolute value.
Parameters:
`x` - number from which absolute value is requested
Returns:
abs(x)
• #### abs

`public static float abs(float x)`
Absolute value.
Parameters:
`x` - number from which absolute value is requested
Returns:
abs(x)
• #### abs

`public static double abs(double x)`
Absolute value.
Parameters:
`x` - number from which absolute value is requested
Returns:
abs(x)
• #### ulp

`public static double ulp(double x)`
Compute least significant bit (Unit in Last Position) for a number.
Parameters:
`x` - number from which ulp is requested
Returns:
ulp(x)
• #### ulp

`public static float ulp(float x)`
Compute least significant bit (Unit in Last Position) for a number.
Parameters:
`x` - number from which ulp is requested
Returns:
ulp(x)
• #### scalb

```public static double scalb(double d,
int n)```
Multiply a double number by a power of 2.
Parameters:
`d` - number to multiply
`n` - power of 2
Returns:
d × 2n
• #### scalb

```public static float scalb(float f,
int n)```
Multiply a float number by a power of 2.
Parameters:
`f` - number to multiply
`n` - power of 2
Returns:
f × 2n
• #### nextAfter

```public static double nextAfter(double d,
double direction)```
Get the next machine representable number after a number, moving in the direction of another number.

The ordering is as follows (increasing):

• -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 <= x < f + 1.0
• #### ceil

`public static double ceil(double x)`
Get the smallest whole number larger than x.
Parameters:
`x` - number from which ceil is requested
Returns:
a double number c such that c is an integer c - 1.0 < x <= c
• #### rint

`public static double rint(double x)`
Get the whole number that is the nearest to x, or the even one if x is exactly half way between two integers.
Parameters:
`x` - number from which nearest whole number is requested
Returns:
a double number r such that r is an integer r - 0.5 <= x <= r + 0.5
• #### round

`public static long round(double x)`
Get the closest long to x.
Parameters:
`x` - number from which closest long is requested
Returns:
closest long to x
• #### round

`public static int round(float x)`
Get the closest int to x.
Parameters:
`x` - number from which closest int is requested
Returns:
closest int to x
• #### min

```public static int min(int a,
int b)```
Compute the minimum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
a if a is lesser or equal to b, b otherwise
• #### min

```public static long min(long a,
long b)```
Compute the minimum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
a if a is lesser or equal to b, b otherwise
• #### min

```public static float min(float a,
float b)```
Compute the minimum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
a if a is lesser or equal to b, b otherwise
• #### min

```public static double min(double a,
double b)```
Compute the minimum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
a if a is lesser or equal to b, b otherwise
• #### max

```public static int max(int a,
int b)```
Compute the maximum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
b if a is lesser or equal to b, a otherwise
• #### max

```public static long max(long a,
long b)```
Compute the maximum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
b if a is lesser or equal to b, a otherwise
• #### max

```public static float max(float a,
float b)```
Compute the maximum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
b if a is lesser or equal to b, a otherwise
• #### max

```public static double max(double a,
double b)```
Compute the maximum of two values
Parameters:
`a` - first value
`b` - second value
Returns:
b if a is lesser or equal to b, a otherwise
• #### hypot

```public static double hypot(double x,
double y)```
Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x2 +y2)
avoiding intermediate overflow or underflow.
• 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(x2 +y2)
• #### IEEEremainder

```public static double IEEEremainder(double dividend,
double divisor)```
Computes the remainder as prescribed by the IEEE 754 standard. The remainder value is mathematically equal to `x - y*n` where `n` is the mathematical integer closest to the exact mathematical value of the quotient `x/y`. If two mathematical integers are equally close to `x/y` then `n` is the integer that is even.

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

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

Parameters:
`dividend` - the number to be divided
`divisor` - the number by which to divide
Returns:
the remainder, rounded
• #### copySign

```public static double copySign(double magnitude,
double sign)```
Returns the first argument with the sign of the second argument. A NaN `sign` argument is treated as positive.
Parameters:
`magnitude` - the value to return
`sign` - the sign for the returned value
Returns:
the magnitude with the same sign as the `sign` argument
• #### copySign

```public static float copySign(float magnitude,
float sign)```
Returns the first argument with the sign of the second argument. A NaN `sign` argument is treated as positive.
Parameters:
`magnitude` - the value to return
`sign` - the sign for the returned value
Returns:
the magnitude with the same sign as the `sign` argument
• #### getExponent

`public static int getExponent(double d)`
Return the exponent of a double number, removing the bias.

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

Parameters:
`d` - number from which exponent is requested
Returns:
exponent for d in IEEE754 representation, without bias
• #### getExponent

`public static int getExponent(float f)`
Return the exponent of a float number, removing the bias.

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

Parameters:
`f` - number from which exponent is requested
Returns:
exponent for d in IEEE754 representation, without bias

Copyright © 2010 - 2020 Adobe. All Rights Reserved