MathLibrary (patrimoine de base SIRIUS 4.13 API)

All Known Implementing Classes:

FastestMathLibWrapper, FastMathWrapper, JafamaFastMathWrapper, JafamaStrictFastMathWrapper, MathWrapper, StrictMathWrapper
```
public interface MathLibrary
```
Interface for low-level math libraries.

Since:

4.2

Author:

Emmanuel Bignon

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`double`	`abs(double x)` Absolute value.
`float`	`abs(float x)` Absolute value.
`int`	`abs(int x)` Absolute value.
`long`	`abs(long x)` Absolute value.
`double`	`acos(double x)` Compute the arc cosine of a number.
`double`	`acosh(double a)` Compute the inverse hyperbolic cosine of a number.
`double`	`asin(double x)` Compute the arc sine of a number.
`double`	`asinh(double a)` Compute the inverse hyperbolic sine of a number.
`double`	`atan(double x)` Arctangent function
`double`	`atan2(double y, double x)` Two arguments arctangent function
`double`	`atanh(double a)` Compute the inverse hyperbolic tangent of a number.
`double`	`cbrt(double x)` Compute the cubic root of a number.
`double`	`ceil(double x)` Get the smallest whole number larger than x.
`double`	`copySign(double magnitude, double sign)` Returns the first argument with the sign of the second argument.
`float`	`copySign(float magnitude, float sign)` Returns the first argument with the sign of the second argument.
`double`	`cos(double x)` Cosine function.
`double`	`cosh(double x)` Compute the hyperbolic cosine of a number.
`double`	`exp(double x)` Exponential function.
`double`	`expm1(double x)` Compute exp(x) - 1
`double`	`floor(double x)` Get the largest whole number smaller than x.
`int`	`getExponent(double d)` Return the exponent of a double number, removing the bias.
`int`	`getExponent(float f)` Return the exponent of a float number, removing the bias.
`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.
`double`	`IEEEremainder(double dividend, double divisor)` Computes the remainder as prescribed by the IEEE 754 standard.
`double`	`log(double x)` Natural logarithm.
`double`	`log10(double x)` Compute the base 10 logarithm.
`double`	`log1p(double x)` Computes log(1 + x).
`double`	`max(double a, double b)` Compute the maximum of two values
`float`	`max(float a, float b)` Compute the maximum of two values
`int`	`max(int a, int b)` Compute the maximum of two values
`long`	`max(long a, long b)` Compute the maximum of two values
`double`	`min(double a, double b)` Compute the minimum of two values
`float`	`min(float a, float b)` Compute the minimum of two values
`int`	`min(int a, int b)` Compute the minimum of two values
`long`	`min(long a, long b)` Compute the minimum of two values
`double`	`nextAfter(double d, double direction)` Get the next machine representable number after a number, moving in the direction of another number.
`float`	`nextAfter(float f, double direction)` Get the next machine representable number after a number, moving in the direction of another number.
`double`	`nextUp(double a)` Compute next number towards positive infinity.
`float`	`nextUp(float a)` Compute next number towards positive infinity.
`double`	`pow(double x, double y)` Power function.
`double`	`pow(double d, int e)` Raise a double to an int power.
`double`	`random()` Returns a pseudo-random number between 0.0 and 1.0.
`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.
`long`	`round(double x)` Get the closest long to x.
`int`	`round(float x)` Get the closest int to x.
`double`	`scalb(double d, int n)` Multiply a double number by a power of 2.
`float`	`scalb(float f, int n)` Multiply a float number by a power of 2.
`double`	`signum(double a)` Compute the signum of a number.
`float`	`signum(float a)` Compute the signum of a number.
`double`	`sin(double x)` Sine function.
`double[]`	`sinAndCos(double x)` Computes sine and cosine of an angle together.
`void`	`sinAndCos(double x, double[] sincos)` Computes sine and cosine of an angle together.
`double`	`sinh(double x)` Compute the hyperbolic sine of a number.
`double[]`	`sinhAndCosh(double x)` Computes hyperbolic sine and hyperbolic cosine together.
`void`	`sinhAndCosh(double x, double[] sinhcosh)` Computes hyperbolic sine and hyperbolic cosine together.
`double`	`sqrt(double a)` Compute the square root of a number.
`double`	`tan(double x)` Tangent function.
`double`	`tanh(double x)` Compute the hyperbolic tangent of a number.
`double`	`toDegrees(double x)` Convert radians to degrees, with error of less than 0.5 ULP
`double`	`toRadians(double x)` Convert degrees to radians, with error of less than 0.5 ULP
`double`	`ulp(double x)` Compute least significant bit (Unit in Last Position) for a number.
`float`	`ulp(float x)` Compute least significant bit (Unit in Last Position) for a number.

- Method Detail
  - sqrt
```
double sqrt(double a)
```
    Compute the square root of a number.
    
    Parameters:
    
    a - number on which evaluation is done
    
    Returns:
    
    square root of a
  - cosh
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
double random()
```
    Returns a pseudo-random number between 0.0 and 1.0.
    
    Returns:
    
    a random number between 0.0 and 1.0
  - exp
```
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
  - expm1
```
double expm1(double x)
```
    Compute exp(x) - 1
    
    Parameters:
    
    x - number to compute shifted exponential
    
    Returns:
    
    exp(x) - 1
  - log
```
double log(double x)
```
    Natural logarithm.
    
    Parameters:
    
    x - a double
    
    Returns:
    
    log(x)
  - log1p
```
double log1p(double x)
```
    Computes log(1 + x).
    
    Parameters:
    
    x - Number.
    
    Returns:
    
    log(1 + x).
  - log10
```
double log10(double x)
```
    Compute the base 10 logarithm.
    
    Parameters:
    
    x - a number
    
    Returns:
    
    log10(x)
  - pow
```
double pow(double x,
           double y)
```
    Power function. Compute x^y.
    
    Parameters:
    
    x - a double
    
    y - a double
    
    Returns:
    
    double
  - pow
```
double pow(double d,
           int e)
```
    Raise a double to an int power.
    
    Parameters:
    
    d - Number to raise.
    
    e - Exponent.
    
    Returns:
    
    d^e
    
    Since:
    
    3.1
  - sin
```
double sin(double x)
```
    Sine function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    sin(x)
  - cos
```
double cos(double x)
```
    Cosine function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    cos(x)
  - tan
```
double tan(double x)
```
    Tangent function.
    
    Parameters:
    
    x - Argument.
    
    Returns:
    
    tan(x)
  - atan
```
double atan(double x)
```
    Arctangent function
    
    Parameters:
    
    x - a number
    
    Returns:
    
    atan(x)
  - atan2
```
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
```
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
```
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
```
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
```
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
```
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
```
int abs(int x)
```
    Absolute value.
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
  - abs
```
long abs(long x)
```
    Absolute value.
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
  - abs
```
float abs(float x)
```
    Absolute value.
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
  - abs
```
double abs(double x)
```
    Absolute value.
    
    Parameters:
    
    x - number from which absolute value is requested
    
    Returns:
    
    abs(x)
  - ulp
```
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
```
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
```
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
```
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
```
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
  - nextAfter
```
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
  - floor
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
```
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
  - sinAndCos
```
double[] sinAndCos(double x)
```
    Computes sine and cosine of an angle together.
    
    Parameters:
    
    x - angle in radians
    
    Returns:
    
    [angle sine, angle cosine]
  - sinAndCos
```
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
```
double[] sinhAndCosh(double x)
```
    Computes hyperbolic sine and hyperbolic cosine together.
    
    Parameters:
    
    x - value
    
    Returns:
    
    [hyperbolic sine, hyperbolic cosine]
  - sinhAndCosh
```
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]

Interface MathLibrary

Method Summary

Method Detail

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

sinAndCos

sinAndCos

sinhAndCosh

sinhAndCosh