MathLib (patrimoine de base SIRIUS 4.13 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.util.MathLib

```
public final class MathLib
extends Object
```
Math library. This static class contains all low-level Math function such as abs(), sin(), cos(), exp(), etc. It simply encapsulate a MathLibrary. By default FastMathWrapper which encapsulate MathLib is used.
The user can define its own Math library used in PATRIUS by implementing MathLibrary and defining it as the Math library to use with method setMathLibrary(MathLibrary)

Be aware that some MathLib of JAFAMA functions may not be included in Mathlib since only all commons functions between FastMath and JAFAMA are listed in MathLib (e.g. FastMath.log(double, double).

Since:

4.2

Author:

Emmanuel Bignon

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 Static Methods Concrete 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`	`divide(double x, double y)` Computes x / y.
`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(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 double`	`log(double x)` Natural logarithm.
`static double`	`log10(double x)` Compute the base 10 logarithm.
`static double`	`log1p(double x)` Computes 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`	`pow(double d, int e)` Raise a double to an int power.
`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 void`	`setMathLibrary(MathLibrary library)` Set Math library.
`static void`	`setMathLibrary(MathLibraryType libraryType)` Set Math library using predefined values.
`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[]`	`sinAndCos(double x)` Computes sine and cosine of an angle together.
`static void`	`sinAndCos(double x, double[] sincos)` Computes sine and cosine of an angle together.
`static double`	`sinh(double x)` Compute the hyperbolic sine of a number.
`static double[]`	`sinhAndCosh(double x)` Computes hyperbolic sine and hyperbolic cosine together.
`static void`	`sinhAndCosh(double x, double[] sinhcosh)` Computes hyperbolic sine and hyperbolic cosine together.
`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
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
  - setMathLibrary
```
public static void setMathLibrary(MathLibrary library)
```
    Set Math library.
    This methods allows user to define its own Math library.
    
    Parameters:
    
    library - library
  - setMathLibrary
```
public static void setMathLibrary(MathLibraryType libraryType)
```
    Set Math library using predefined values.
    
    Parameters:
    
    libraryType - library type
  - sqrt
```
public static double sqrt(double a)
```
    Compute the square root of a number.
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    square root of a
    
    Throws:
    
    ArithmeticException - thrown if a < 0 or a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a < 1 or a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a > 1 or a < -1 or a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a is NaN
  - random
```
public static double random()
```
    Returns a pseudo-random number between 0.0 and 1.0.
    
    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 e^x
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - expm1
```
public static double expm1(double x)
```
    Compute exp(x) - 1
    
    Parameters:
    
    x - number to compute shifted exponential
    
    Returns:
    
    exp(x) - 1
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - log
```
public static double log(double x)
```
    Natural logarithm.
    
    Parameters:
    
    x - a double
    
    Returns:
    
    log(x)
    
    Throws:
    
    ArithmeticException - thrown if x < 0 or x is NaN
  - log1p
```
public static double log1p(double x)
```
    Computes log(1 + x).
    
    Parameters:
    
    x - Number.
    
    Returns:
    
    log(1 + x).
    
    Throws:
    
    ArithmeticException - thrown if x < 0 or x is NaN
  - log10
```
public static double log10(double x)
```
    Compute the base 10 logarithm.
    
    Parameters:
    
    x - a number
    
    Returns:
    
    log10(x)
    
    Throws:
    
    ArithmeticException - thrown if x < 0 or x is NaN
  - pow
```
public static double pow(double x,
                         double y)
```
    Power function. Compute x^y.
    
    Parameters:
    
    x - a double
    
    y - a double
    
    Returns:
    
    double
    
    Throws:
    
    ArithmeticException - thrown if y < 0 and y not an integer or x or y is NaN or x = -1
  - 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
    
    Throws:
    
    ArithmeticException - thrown if d is NaN
    
    Since:
    
    3.1
  - sin
```
public static double sin(double x)
```
    Sine function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    sin(x)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN or Infinity
  - cos
```
public static double cos(double x)
```
    Cosine function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    cos(x)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN or Infinity
  - tan
```
public static double tan(double x)
```
    Tangent function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    tan(x)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN or Infinity
  - atan
```
public static double atan(double x)
```
    Arctangent function
    
    Parameters:
    
    x - a number
    
    Returns:
    
    atan(x)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x or y is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x < -1 or x > 1 or x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x < -1 or x > 1 or x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - abs
```
public static double abs(double x)
```
    Absolute value.
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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)
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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ⁿ
    
    Throws:
    
    ArithmeticException - thrown if d is NaN
  - 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ⁿ
    
    Throws:
    
    ArithmeticException - thrown if f is NaN
  - 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
    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
    
    Throws:
    
    ArithmeticException - thrown if d or direction is NaN
  - 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
    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
    
    Throws:
    
    ArithmeticException - thrown if f or direction is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if x is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a or b is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a or b is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a or b is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if a or b is NaN
  - 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.
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²)
    
    Throws:
    
    ArithmeticException - thrown if x or y is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if input cannot allow to compute remainder
  - 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
    
    Throws:
    
    ArithmeticException - thrown if magnitude is NaN
  - 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
    
    Throws:
    
    ArithmeticException - thrown if magnitude is NaN
  - 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
  - divide
```
public static double divide(double x,
                            double y)
```
    Computes x / y. This method returns an exception if output is NaN or y = 0.
    
    Parameters:
    
    x - numerator
    
    y - denominator
    
    Returns:
    
    x / y
    
    Throws:
    
    ArithmeticException - thrown if x / y = NaN or y = 0
  - sinAndCos
```
public static double[] sinAndCos(double x)
```
    Computes sine and cosine of an angle together.
    
    Parameters:
    
    x - angle in radians
    
    Returns:
    
    [angle sine, angle cosine]
  - sinAndCos
```
public static void sinAndCos(double x,
                             double[] sincos)
```
    Computes sine and cosine of an angle together. Values are returned in the array provided [angle sine, angle cosine]. This array should be of size 2. Warning: array size is not checked for performances reasons.
    
    Parameters:
    
    x - angle in radians
    
    sincos - array of size 2. Array is filled is values: [angle sine, angle cosine]
  - sinhAndCosh
```
public static double[] sinhAndCosh(double x)
```
    Computes hyperbolic sine and hyperbolic cosine together.
    
    Parameters:
    
    x - value
    
    Returns:
    
    [hyperbolic sine, hyperbolic cosine]
  - sinhAndCosh
```
public static void sinhAndCosh(double x,
                               double[] sinhcosh)
```
    Computes hyperbolic sine and hyperbolic cosine together. Values are returned in the array provided [hyperbolic sine, hyperbolic cosine]. This array should be of size 2. Warning: array size is not checked for performances reasons.
    
    Parameters:
    
    x - value
    
    sinhcosh - array of size 2. Array is filled is values: [hyperbolic sine, hyperbolic cosine]

Class MathLib

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI

E

Method Detail

setMathLibrary

setMathLibrary

sqrt

cosh

sinh

tanh

acosh

asinh

atanh

signum

signum

nextUp

nextUp

random

exp

expm1

log

log1p

log10

pow

pow

sin

cos

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

copySign

copySign

getExponent

getExponent

divide

sinAndCos

sinAndCos

sinhAndCosh

sinhAndCosh