java.lang.Object
- org.hipparchus.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 initialized on first use, so that the setup time does not penalize methods that don't need them.
Note that FastMath is extensively used inside Hipparchus, so by calling some algorithms, the overhead when the the tables need to be initialized 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

Field Summary

Fields
Modifier and Type	Field	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 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 <T extends RealFieldElement<T>> T`	`abs(T x)`	Absolute value.
`static double`	`acos(double x)`	Compute the arc cosine of a number.
`static <T extends RealFieldElement<T>> T`	`acos(T x)`	Compute the arc cosine of a number.
`static double`	`acosh(double a)`	Compute the inverse hyperbolic cosine of a number.
`static <T extends RealFieldElement<T>> T`	`acosh(T 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 <T extends RealFieldElement<T>> T`	`asin(T x)`	Compute the arc sine of a number.
`static double`	`asinh(double a)`	Compute the inverse hyperbolic sine of a number.
`static <T extends RealFieldElement<T>> T`	`asinh(T a)`	Compute the inverse hyperbolic sine of a number.
`static double`	`atan(double x)`	Arctangent function
`static <T extends RealFieldElement<T>> T`	`atan(T x)`	Arctangent function
`static double`	`atan2(double y, double x)`	Two arguments arctangent function
`static <T extends RealFieldElement<T>> T`	`atan2(T y, T x)`	Two arguments arctangent function
`static double`	`atanh(double a)`	Compute the inverse hyperbolic tangent of a number.
`static <T extends RealFieldElement<T>> T`	`atanh(T a)`	Compute the inverse hyperbolic tangent of a number.
`static double`	`cbrt(double x)`	Compute the cubic root of a number.
`static <T extends RealFieldElement<T>> T`	`cbrt(T x)`	Compute the cubic root of a number.
`static double`	`ceil(double x)`	Get the smallest whole number larger than x.
`static <T extends RealFieldElement<T>> T`	`ceil(T 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 <T extends RealFieldElement<T>> T`	`copySign(T magnitude, double sign)`	Returns the first argument with the sign of the second argument.
`static <T extends RealFieldElement<T>> T`	`copySign(T magnitude, T sign)`	Returns the first argument with the sign of the second argument.
`static double`	`cos(double x)`	Cosine function.
`static <T extends RealFieldElement<T>> T`	`cos(T x)`	Cosine function.
`static double`	`cosh(double x)`	Compute the hyperbolic cosine of a number.
`static <T extends RealFieldElement<T>> T`	`cosh(T x)`	Compute the hyperbolic cosine of a number.
`static int`	`decrementExact(int n)`	Decrement a number, detecting overflows.
`static long`	`decrementExact(long n)`	Decrement a number, detecting overflows.
`static double`	`exp(double x)`	Exponential function.
`static <T extends RealFieldElement<T>> T`	`exp(T x)`	Exponential function.
`static double`	`expm1(double x)`	Compute exp(x) - 1
`static <T extends RealFieldElement<T>> T`	`expm1(T x)`	Compute exp(x) - 1
`static double`	`floor(double x)`	Get the largest whole number smaller than x.
`static <T extends RealFieldElement<T>> T`	`floor(T 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, 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 int`	`floorMod(long 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 double`	`fma(double a, double b, double c)`	Compute Fused-multiply-add operation a * b + c.
`static float`	`fma(float a, float b, float c)`	Compute Fused-multiply-add operation a * b + c.
`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(x² +y²) avoiding intermediate overflow or underflow.
`static <T extends RealFieldElement<T>> T`	`hypot(T x, T y)`	Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x² +y²) avoiding intermediate overflow or underflow.
`static double`	`IEEEremainder(double dividend, double divisor)`	Computes the remainder as prescribed by the IEEE 754 standard.
`static <T extends RealFieldElement<T>> T`	`IEEEremainder(T dividend, double divisor)`	Computes the remainder as prescribed by the IEEE 754 standard.
`static <T extends RealFieldElement<T>> T`	`IEEEremainder(T dividend, T 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.
`static <T extends RealFieldElement<T>> T`	`log(T x)`	Natural logarithm.
`static double`	`log10(double x)`	Compute the base 10 logarithm.
`static <T extends RealFieldElement<T>> T`	`log10(T x)`	Compute the base 10 logarithm.
`static double`	`log1p(double x)`	Computes log(1 + x).
`static <T extends RealFieldElement<T>> T`	`log1p(T 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 <T extends RealFieldElement<T>> T`	`max(T a, T 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 <T extends RealFieldElement<T>> T`	`min(T a, T b)`	Compute the minimum of two values
`static int`	`multiplyExact(int a, int b)`	Multiply two numbers, detecting overflows.
`static long`	`multiplyExact(long a, int b)`	Multiply two numbers, detecting overflows.
`static long`	`multiplyExact(long a, long b)`	Multiply two numbers, detecting overflows.
`static long`	`multiplyFull(int a, int b)`	Multiply two integers and give an exact result without overflow.
`static long`	`multiplyHigh(long a, long b)`	Multiply two long integers and give the 64 most significant bits of the result.
`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.
`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 <T extends RealFieldElement<T>> T`	`pow(T d, int e)`	Raise a double to an int power.
`static <T extends RealFieldElement<T>> T`	`pow(T x, T 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 <T extends RealFieldElement<T>> T`	`rint(T 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 <T extends RealFieldElement<T>> long`	`round(T x)`	Get the closest long 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 <T extends RealFieldElement<T>> T`	`scalb(T d, int n)`	Multiply a double 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 <T extends RealFieldElement<T>> T`	`signum(T a)`	Compute the signum of a number.
`static double`	`sin(double x)`	Sine function.
`static <T extends RealFieldElement<T>> T`	`sin(T x)`	Sine function.
`static SinCos`	`sinCos(double x)`	Combined Sine and Cosine function.
`static <T extends RealFieldElement<T>> FieldSinCos<T>`	`sinCos(T x)`	Combined Sine and Cosine function.
`static double`	`sinh(double x)`	Compute the hyperbolic sine of a number.
`static <T extends RealFieldElement<T>> T`	`sinh(T x)`	Compute the hyperbolic sine of a number.
`static double`	`sqrt(double a)`	Compute the square root of a number.
`static <T extends RealFieldElement<T>> T`	`sqrt(T 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 <T extends RealFieldElement<T>> T`	`tan(T x)`	Tangent function.
`static double`	`tanh(double x)`	Compute the hyperbolic tangent of a number.
`static <T extends RealFieldElement<T>> T`	`tanh(T 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 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 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PI
```
public static final double PI
```
    Archimede's constant PI, ratio of circle circumference to diameter.
    
    See Also:
    
    Constant Field Values
  - E
```
public static final double E
```
    Napier's constant e, base of the natural logarithm.
    
    See Also:
    
    Constant Field Values
- 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
  - 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
  - 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
  - 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
  - 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)
```
    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 base^y = x.
  - 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
  - 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
  - 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)
  - sinCos
```
public static SinCos sinCos(double x)
```
    Combined Sine and Cosine function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    [sin(x), cos(x)]
  - sinCos
```
public static <T extends RealFieldElement<T>> FieldSinCos<T> sinCos(T x)
```
    Combined Sine and Cosine function.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    [sin(x), cos(x)]
    
    Since:
    
    1.4
  - 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)
  - 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 <= 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(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.
    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 MathRuntimeException
```
    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:
    
    MathRuntimeException - if n cannot fit into an int
  - incrementExact
```
public static int incrementExact(int n)
                          throws MathRuntimeException
```
    Increment a number, detecting overflows.
    
    Parameters:
    
    n - number to increment
    
    Returns:
    
    n+1 if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - incrementExact
```
public static long incrementExact(long n)
                           throws MathRuntimeException
```
    Increment a number, detecting overflows.
    
    Parameters:
    
    n - number to increment
    
    Returns:
    
    n+1 if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - decrementExact
```
public static int decrementExact(int n)
                          throws MathRuntimeException
```
    Decrement a number, detecting overflows.
    
    Parameters:
    
    n - number to decrement
    
    Returns:
    
    n-1 if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - decrementExact
```
public static long decrementExact(long n)
                           throws MathRuntimeException
```
    Decrement a number, detecting overflows.
    
    Parameters:
    
    n - number to decrement
    
    Returns:
    
    n-1 if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - addExact
```
public static int addExact(int a,
                           int b)
                    throws MathRuntimeException
```
    Add two numbers, detecting overflows.
    
    Parameters:
    
    a - first number to add
    
    b - second number to add
    
    Returns:
    
    a+b if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - addExact
```
public static long addExact(long a,
                            long b)
                     throws MathRuntimeException
```
    Add two numbers, detecting overflows.
    
    Parameters:
    
    a - first number to add
    
    b - second number to add
    
    Returns:
    
    a+b if no overflows occur
    
    Throws:
    
    MathRuntimeException - if an overflow occurs
  - 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:
    
    MathRuntimeException - if an overflow occurs
  - 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:
    
    MathRuntimeException - if an overflow occurs
  - 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:
    
    MathRuntimeException - if an overflow occurs
  - multiplyExact
```
public static long multiplyExact(long 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:
    
    MathRuntimeException - if an overflow occurs
    
    Since:
    
    1.3
  - 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:
    
    MathRuntimeException - if an overflow occurs
  - multiplyFull
```
public static long multiplyFull(int a,
                                int b)
```
    Multiply two integers and give an exact result without overflow.
    
    Parameters:
    
    a - first factor
    
    b - second factor
    
    Returns:
    
    a * b exactly
    
    Since:
    
    1.3
  - multiplyHigh
```
public static long multiplyHigh(long a,
                                long b)
```
    Multiply two long integers and give the 64 most significant bits of the result.
    Beware that as Java primitive long are always considered to be signed, there are some intermediate values a and b for which a * b exceeds Long.MAX_VALUE but this method will still return 0l. This happens for example for a = 2³¹ and b = 2³² as a * b = 2⁶³ = Long.MAX_VALUE + 1, so it exceeds the max value for a long, but still fits in 64 bits, so this method correctly returns 0l in this case, but multiplication result would be considered negative (and in fact equal to Long.MIN_VALUE
    
    Parameters:
    
    a - first factor
    
    b - second factor
    
    Returns:
    
    a * b / 2⁶⁴
    
    Since:
    
    1.3
  - floorDiv
```
public static int floorDiv(int a,
                           int b)
                    throws MathRuntimeException
```
    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 - dividend
    
    b - divisor
    
    Returns:
    
    q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    See Also:
    
    floorMod(int, int)
  - floorDiv
```
public static long floorDiv(long a,
                            int b)
                     throws MathRuntimeException
```
    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 - dividend
    
    b - divisor
    
    Returns:
    
    q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    Since:
    
    1.3
    
    See Also:
    
    floorMod(long, int)
  - floorDiv
```
public static long floorDiv(long a,
                            long b)
                     throws MathRuntimeException
```
    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 - dividend
    
    b - divisor
    
    Returns:
    
    q such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    See Also:
    
    floorMod(long, long)
  - floorMod
```
public static int floorMod(int a,
                           int b)
                    throws MathRuntimeException
```
    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 - dividend
    
    b - divisor
    
    Returns:
    
    r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    See Also:
    
    floorDiv(int, int)
  - floorMod
```
public static int floorMod(long 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.
    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 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    Since:
    
    1.3
    
    See Also:
    
    floorDiv(long, 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 - dividend
    
    b - divisor
    
    Returns:
    
    r such that a = q b + r with 0 <= r < b if b > 0 and b < r <= 0 if b < 0
    
    Throws:
    
    MathRuntimeException - if b == 0
    
    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
  - fma
```
public static double fma(double a,
                         double b,
                         double c)
```
    Compute Fused-multiply-add operation a * b + c.
    This method was introduced in the regular Math and StrictMath methods with Java 9, and then added to Hipparchus for consistency. However, a more general method was available in Hipparchus that also allow to repeat this computation across several terms: MathArrays.linearCombination(double[], double[]). The linear combination method should probably be preferred in most cases.
    
    Parameters:
    
    a - first factor
    
    b - second factor
    
    c - additive term
    
    Returns:
    
    a * b + c, using extended precision in the multiplication
    
    Since:
    
    1.3
    
    See Also:
    
    MathArrays.linearCombination(double[], double[]), MathArrays.linearCombination(double, double, double, double), MathArrays.linearCombination(double, double, double, double, double, double), MathArrays.linearCombination(double, double, double, double, double, double, double, double)
  - fma
```
public static float fma(float a,
                        float b,
                        float c)
```
    Compute Fused-multiply-add operation a * b + c.
    This method was introduced in the regular Math and StrictMath methods with Java 9, and then added to Hipparchus for consistency. However, a more general method was available in Hipparchus that also allow to repeat this computation across several terms: MathArrays.linearCombination(double[], double[]). The linear combination method should probably be preferred in most cases.
    
    Parameters:
    
    a - first factor
    
    b - second factor
    
    c - additive term
    
    Returns:
    
    a * b + c, using extended precision in the multiplication
    
    See Also:
    
    MathArrays.linearCombination(double[], double[]), MathArrays.linearCombination(double, double, double, double), MathArrays.linearCombination(double, double, double, double, double, double), MathArrays.linearCombination(double, double, double, double, double, double, double, double)
  - sqrt
```
public static <T extends RealFieldElement<T>> T sqrt(T a)
```
    Compute the square root of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    square root of a
    
    Since:
    
    1.3
  - cosh
```
public static <T extends RealFieldElement<T>> T cosh(T x)
```
    Compute the hyperbolic cosine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    hyperbolic cosine of x
    
    Since:
    
    1.3
  - sinh
```
public static <T extends RealFieldElement<T>> T sinh(T x)
```
    Compute the hyperbolic sine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    hyperbolic sine of x
    
    Since:
    
    1.3
  - tanh
```
public static <T extends RealFieldElement<T>> T tanh(T x)
```
    Compute the hyperbolic tangent of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    hyperbolic tangent of x
    
    Since:
    
    1.3
  - acosh
```
public static <T extends RealFieldElement<T>> T acosh(T a)
```
    Compute the inverse hyperbolic cosine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    inverse hyperbolic cosine of a
    
    Since:
    
    1.3
  - asinh
```
public static <T extends RealFieldElement<T>> T asinh(T a)
```
    Compute the inverse hyperbolic sine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    inverse hyperbolic sine of a
    
    Since:
    
    1.3
  - atanh
```
public static <T extends RealFieldElement<T>> T atanh(T a)
```
    Compute the inverse hyperbolic tangent of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    inverse hyperbolic tangent of a
    
    Since:
    
    1.3
  - signum
```
public static <T extends RealFieldElement<T>> T signum(T a)
```
    Compute the signum of a number. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
    
    Since:
    
    1.3
  - exp
```
public static <T extends RealFieldElement<T>> T exp(T 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.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a double
    
    Returns:
    
    double e^x
    
    Since:
    
    1.3
  - expm1
```
public static <T extends RealFieldElement<T>> T expm1(T x)
```
    Compute exp(x) - 1
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number to compute shifted exponential
    
    Returns:
    
    exp(x) - 1
    
    Since:
    
    1.3
  - log
```
public static <T extends RealFieldElement<T>> T log(T x)
```
    Natural logarithm.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a double
    
    Returns:
    
    log(x)
    
    Since:
    
    1.3
  - log1p
```
public static <T extends RealFieldElement<T>> T log1p(T x)
```
    Computes log(1 + x).
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - Number.
    
    Returns:
    
    log(1 + x).
    
    Since:
    
    1.3
  - log10
```
public static <T extends RealFieldElement<T>> T log10(T x)
```
    Compute the base 10 logarithm.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a number
    
    Returns:
    
    log10(x)
    
    Since:
    
    1.3
  - pow
```
public static <T extends RealFieldElement<T>> T pow(T x,
                                                    T y)
```
    Power function. Compute x^y.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a double
    
    y - a double
    
    Returns:
    
    x^y
    
    Since:
    
    1.3
  - pow
```
public static <T extends RealFieldElement<T>> T pow(T d,
                                                    int e)
```
    Raise a double to an int power.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    d - Number to raise.
    
    e - Exponent.
    
    Returns:
    
    d^e
    
    Since:
    
    1.3
  - sin
```
public static <T extends RealFieldElement<T>> T sin(T x)
```
    Sine function.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    sin(x)
    
    Since:
    
    1.3
  - cos
```
public static <T extends RealFieldElement<T>> T cos(T x)
```
    Cosine function.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    cos(x)
    
    Since:
    
    1.3
  - tan
```
public static <T extends RealFieldElement<T>> T tan(T x)
```
    Tangent function.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    tan(x)
    
    Since:
    
    1.3
  - atan
```
public static <T extends RealFieldElement<T>> T atan(T x)
```
    Arctangent function
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a number
    
    Returns:
    
    atan(x)
    
    Since:
    
    1.3
  - atan2
```
public static <T extends RealFieldElement<T>> T atan2(T y,
                                                      T x)
```
    Two arguments arctangent function
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    y - ordinate
    
    x - abscissa
    
    Returns:
    
    phase angle of point (x,y) between -PI and PI
    
    Since:
    
    1.3
  - asin
```
public static <T extends RealFieldElement<T>> T asin(T x)
```
    Compute the arc sine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    arc sine of x
    
    Since:
    
    1.3
  - acos
```
public static <T extends RealFieldElement<T>> T acos(T x)
```
    Compute the arc cosine of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    arc cosine of x
    
    Since:
    
    1.3
  - cbrt
```
public static <T extends RealFieldElement<T>> T cbrt(T x)
```
    Compute the cubic root of a number.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number on which evaluation is done
    
    Returns:
    
    cubic root of x
    
    Since:
    
    1.3
  - abs
```
public static <T extends RealFieldElement<T>> T abs(T x)
```
    Absolute value.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
    
    Since:
    
    1.3
  - scalb
```
public static <T extends RealFieldElement<T>> T scalb(T d,
                                                      int n)
```
    Multiply a double number by a power of 2.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    d - number to multiply
    
    n - power of 2
    
    Returns:
    
    d × 2ⁿ
    
    Since:
    
    1.3
  - floor
```
public static <T extends RealFieldElement<T>> T floor(T x)
```
    Get the largest whole number smaller than x.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number from which floor is requested
    
    Returns:
    
    a double number f such that f is an integer f <= x < f + 1.0
    
    Since:
    
    1.3
  - ceil
```
public static <T extends RealFieldElement<T>> T ceil(T x)
```
    Get the smallest whole number larger than x.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number from which ceil is requested
    
    Returns:
    
    a double number c such that c is an integer c - 1.0 < x <= c
    
    Since:
    
    1.3
  - rint
```
public static <T extends RealFieldElement<T>> T rint(T x)
```
    Get the whole number that is the nearest to x, or the even one if x is exactly half way between two integers.
    
    Type Parameters:
    
    T - the type of the field element
    
    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
    
    Since:
    
    1.3
  - round
```
public static <T extends RealFieldElement<T>> long round(T x)
```
    Get the closest long to x.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - number from which closest long is requested
    
    Returns:
    
    closest long to x
    
    Since:
    
    1.3
  - min
```
public static <T extends RealFieldElement<T>> T min(T a,
                                                    T b)
```
    Compute the minimum of two values
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - first value
    
    b - second value
    
    Returns:
    
    a if a is lesser or equal to b, b otherwise
    
    Since:
    
    1.3
  - max
```
public static <T extends RealFieldElement<T>> T max(T a,
                                                    T b)
```
    Compute the maximum of two values
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    a - first value
    
    b - second value
    
    Returns:
    
    b if a is lesser or equal to b, a otherwise
    
    Since:
    
    1.3
  - hypot
```
public static <T extends RealFieldElement<T>> T hypot(T x,
                                                      T 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.
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²)
    
    Since:
    
    1.3
  - IEEEremainder
```
public static <T extends RealFieldElement<T>> T IEEEremainder(T 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.
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    dividend - the number to be divided
    
    divisor - the number by which to divide
    
    Returns:
    
    the remainder, rounded
    
    Since:
    
    1.3
  - IEEEremainder
```
public static <T extends RealFieldElement<T>> T IEEEremainder(T dividend,
                                                              T 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.
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    dividend - the number to be divided
    
    divisor - the number by which to divide
    
    Returns:
    
    the remainder, rounded
    
    Since:
    
    1.3
  - copySign
```
public static <T extends RealFieldElement<T>> T copySign(T magnitude,
                                                         T sign)
```
    Returns the first argument with the sign of the second argument. A NaN sign argument is treated as positive.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    magnitude - the value to return
    
    sign - the sign for the returned value
    
    Returns:
    
    the magnitude with the same sign as the sign argument
    
    Since:
    
    1.3
  - copySign
```
public static <T extends RealFieldElement<T>> T copySign(T magnitude,
                                                         double sign)
```
    Returns the first argument with the sign of the second argument. A NaN sign argument is treated as positive.
    
    Type Parameters:
    
    T - the type of the field element
    
    Parameters:
    
    magnitude - the value to return
    
    sign - the sign for the returned value
    
    Returns:
    
    the magnitude with the same sign as the sign argument
    
    Since:
    
    1.3
  - 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

Class FastMath

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI

E

Method Detail

sqrt

cosh

sinh

tanh

acosh

asinh

atanh

signum

signum

nextUp

nextUp

nextDown

nextDown

random

exp

expm1

log

log1p

log10

log

pow

pow

pow

sin

cos

sinCos

sinCos

tan

atan

atan2

asin

acos

cbrt

toRadians

toDegrees

abs

abs

abs

abs

ulp

ulp

scalb

scalb

nextAfter

nextAfter

floor

ceil

rint

round

round

min

min

min

min

max

max

max

max

hypot

IEEEremainder

toIntExact

incrementExact

incrementExact

decrementExact

decrementExact

addExact

addExact

subtractExact

subtractExact

multiplyExact

multiplyExact

multiplyExact