FastMath

java.lang.Object
- org.math.plot.utils.FastMath

```
public final class FastMath
extends Object
```
Class providing math treatments that: - are meant to be faster than those of java.lang.Math class (depending on JVM or JVM options, they might be slower), - are still somehow accurate and robust (handling of NaN and such), - do not (or not directly) generate objects at run time (no "new"). Other than optimized treatments, a valuable feature of this class is the presence of angles normalization methods, derived from those used in java.lang.Math (for which, sadly, no API is provided, letting everyone with the terrible responsibility to write their own ones). Non-redefined methods of java.lang.Math class are also available, for easy replacement. Use of look-up tables: around 1 Mo total, and initialized on class load. - Methods with same signature than Math ones, are meant to return "good" approximations on all range. - Methods terminating with "Fast" are meant to return "good" approximation on a reduced range only. - Methods terminating with "Quick" are meant to be quick, but do not return a good approximation, and might only work on a reduced range. Properties: - jodk.fastmath.strict (boolean, default is true): If true, non-redefined Math methods which results could vary between Math and StrictMath, delegate to StrictMath, and if false, to Math. Default is true to ensure consistency across various architectures. - jodk.fastmath.usejdk (boolean, default is false): If true, redefined Math methods, as well as their "Fast" or "Quick" terminated counterparts, delegate to StrictMath or Math, depending on jodk.fastmath.strict property. - jodk.fastmath.fastlog (boolean, default is true): If true, using redefined log(double), if false using StrictMath.log(double) or Math.log(double), depending on jodk.fastmath.strict property. Default is true because jodk.fastmath.strict is true by default, and StrictMath.log(double) seems usually slow. - jodk.fastmath.fastsqrt (boolean, default is false): If true, using redefined sqrt(double), if false using StrictMath.sqrt(double) or Math.sqrt(double), depending on jodk.fastmath.strict property. Default is false because StrictMath.sqrt(double) seems to usually delegate to hardware sqrt. Unless jodk.fastmath.strict is false and jodk.fastmath.usejdk is true, these treatments are consistent across various architectures, for constants and look-up tables are computed with StrictMath, or exact Math methods. --- words, words, words --- "0x42BE0000 percents of the folks out there are completely clueless about floating-point." The difference between precision and accuracy: "3.177777777777777 is a precise (16 digits) but inaccurate (only correct up to the second digit) approximation of PI=3.141592653589793(etc.)."

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

class FastMath.DoubleWrapper

class FastMath.IntWrapper

Nested Classes
Modifier and Type	Class and Description
`class`	`FastMath.DoubleWrapper`
`class`	`FastMath.IntWrapper`

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`E`
`static double`	`PI`
`static double`	`PI_SUP` High approximation of PI, which is further from PI than the low approximation Math.PI: PI ~= 3.14159265358979323846...

Method Summary

Methods
Modifier and Type	Method and Description
`static double`	`abs(double a)`
`static float`	`abs(float a)`
`static int`	`abs(int value)`
`static long`	`abs(long a)`
`static double`	`acos(double value)`
`static double`	`acosInRange(double value)` If value is not NaN and is outside [-1,1] range, closest value in this range is used.
`static int`	`addBounded(int a, int b)`
`static long`	`addBounded(long a, long b)`
`static int`	`addExact(int a, int b)`
`static long`	`addExact(long a, long b)`
`static double`	`asin(double value)`
`static double`	`asinInRange(double value)` If value is not NaN and is outside [-1,1] range, closest value in this range is used.
`static double`	`atan(double value)`
`static double`	`atan2(double y, double x)` For special values for which multiple conventions could be adopted, behaves like Math.atan2(double,double).
`static double`	`cbrt(double value)`
`static double`	`ceil(double value)` Supposed to behave like Math.ceil(double), for safe interchangeability.
`static float`	`ceil(float value)`
`static double`	`copySign(double magnitude, double sign)`
`static float`	`copySign(float magnitude, float sign)`
`static double`	`cos(double angle)`
`static double`	`cosh(double value)`
`static double`	`cosQuick(double angle)` Quick cosine, with accuracy of about 1.6e-3 (PI/) for \|angle\| < 6588397.0 (Integer.MAX_VALUE * (2*PI/)), and no accuracy at all for larger values.
`static double`	`exp(double value)`
`static double`	`expm1(double value)` Much more accurate than exp(value)-1, for values close to zero.
`static double`	`expQuick(double value)` Quick exp, with a max relative error of about 3e-2 for \|value\| < 700.0 or so, and no accuracy at all outside this range.
`static double`	`floor(double value)` Supposed to behave like Math.floor(double), for safe interchangeability.
`static float`	`floor(float value)`
`static int`	`getExponent(double value)`
`static int`	`getExponent(float value)`
`static double`	`hypot(double x, double y)` Returns sqrt(x^2+y^2) without intermediate overflow or underflow.
`static double`	`IEEEremainder(double f1, double f2)`
`static boolean`	`isInClockwiseDomain(double startAngRad, double angSpanRad, double angRad)` NB: Since 2Math.PI < 2PI, a span of 2*Math.PI does not mean full angular range.
`static boolean`	`isNaNOrInfinite(double value)`
`static boolean`	`isNaNOrInfinite(float value)`
`static double`	`log(double value)`
`static double`	`log10(double value)`
`static double`	`log1p(double value)` Much more accurate than log(1+value), for values close to zero.
`static int`	`log2(int value)`
`static int`	`log2(long value)`
`static double`	`logQuick(double value)` Quick log, with a max relative error of about 2.8e-4 for values in ]0,+infinity[, and no accuracy at all outside this range.
`static double`	`max(double a, double b)`
`static float`	`max(float a, float b)`
`static int`	`max(int a, int b)`
`static long`	`max(long a, long b)`
`static double`	`min(double a, double b)`
`static float`	`min(float a, float b)`
`static int`	`min(int a, int b)`
`static long`	`min(long a, long b)`
`static int`	`multiplyBounded(int a, int b)`
`static long`	`multiplyBounded(long a, long b)`
`static int`	`multiplyExact(int a, int b)`
`static long`	`multiplyExact(long a, long b)`
`static double`	`nextAfter(double start, double direction)`
`static float`	`nextAfter(float start, float direction)`
`static double`	`nextUp(double d)`
`static float`	`nextUp(float f)`
`static double`	`normalizeMinusHalfPiHalfPi(double angle)`
`static double`	`normalizeMinusHalfPiHalfPiFast(double angle)` Not accurate for large values.
`static double`	`normalizeMinusPiPi(double angle)`
`static double`	`normalizeMinusPiPiFast(double angle)` Not accurate for large values.
`static double`	`normalizeZeroTwoPi(double angle)`
`static double`	`normalizeZeroTwoPiFast(double angle)` Not accurate for large values.
`static double`	`pow(double value, double power)` 1e-13ish accuracy (or better) on whole double range.
`static double`	`pow2(double value)`
`static float`	`pow2(float value)`
`static int`	`pow2(int value)`
`static long`	`pow2(long value)`
`static double`	`pow3(double value)`
`static float`	`pow3(float value)`
`static int`	`pow3(int value)`
`static long`	`pow3(long value)`
`static double`	`powFast(double value, int power)` This treatment is somehow accurate for low values of \|power\|, and for \|power*getExponent(value)\| < 1023 or so (to stay away from double extreme magnitudes (large and small)).
`static double`	`powQuick(double value, double power)` Quick pow, with a max relative error of about 3.5e-2 for \|a^b\| < 1e10, of about 0.17 for \|a^b\| < 1e50, and worse accuracy above.
`static double`	`random()`
`static double`	`remainder(double dividend, double divisor)` Returns dividend - divisor * n, where n is the mathematical integer closest to dividend/divisor.
`static double`	`rint(double a)`
`static long`	`round(double value)` Supposed to behave like Math.round(double), for safe interchangeability.
`static int`	`round(float value)` Supposed to behave like Math.round(float), for safe interchangeability.
`static double`	`scalb(double d, int scaleFactor)`
`static float`	`scalb(float f, int scaleFactor)`
`static double`	`signum(double d)`
`static float`	`signum(float f)`
`static double`	`sin(double angle)`
`static void`	`sinAndCos(double angle, FastMath.DoubleWrapper sine, FastMath.DoubleWrapper cosine)` Computes sine and cosine together, at the cost of...
`static double`	`sinh(double value)`
`static void`	`sinhAndCosh(double value, FastMath.DoubleWrapper hsine, FastMath.DoubleWrapper hcosine)` Computes hyperbolic sine and hyperbolic cosine together, at the cost of...
`static double`	`sinQuick(double angle)` Quick sine, with accuracy of about 1.6e-3 (PI/) for \|angle\| < 6588397.0 (Integer.MAX_VALUE * (2*PI/)), and no accuracy at all for larger values.
`static double`	`sqrt(double value)`
`static int`	`subtractBounded(int a, int b)`
`static long`	`subtractBounded(long a, long b)`
`static int`	`subtractExact(int a, int b)`
`static long`	`subtractExact(long a, long b)`
`static double`	`tan(double angle)`
`static double`	`tanh(double value)`
`static double`	`toDegrees(boolean sign, int degrees, int minutes, double seconds)`
`static double`	`toDegrees(double angrad)` Gives same result as Math.toDegrees for some particular values like Math.PI/2, Math.PI or 2*Math.PI, but is faster (no division).
`static boolean`	`toDMS(double angrad, FastMath.IntWrapper degrees, FastMath.IntWrapper minutes, FastMath.DoubleWrapper seconds)`
`static int`	`toInt(long value)`
`static int`	`toIntExact(long value)`
`static double`	`toRadians(boolean sign, int degrees, int minutes, double seconds)`
`static double`	`toRadians(double angdeg)` Gives same result as Math.toRadians for some particular values like 90.0, 180.0 or 360.0, but is faster (no division).
`static double`	`toRange(double minValue, double maxValue, double value)`
`static float`	`toRange(float minValue, float maxValue, float value)`
`static int`	`toRange(int minValue, int maxValue, int value)`
`static long`	`toRange(long minValue, long maxValue, long value)`
`static double`	`twoPow(int power)` Returns the exact result, provided it's in double range.
`static double`	`ulp(double d)`
`static float`	`ulp(float f)`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - PI_SUP
```
public static final double PI_SUP
```
    High approximation of PI, which is further from PI than the low approximation Math.PI: PI ~= 3.14159265358979323846... Math.PI ~= 3.141592653589793 FastMath.PI_SUP ~= 3.1415926535897936
  - E
```
public static final double E
```
    See Also:
    Constant Field Values
  - PI
```
public static final double PI
```
    See Also:
    Constant Field Values
- Method Detail
  - cos
```
public static double cos(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle cosine.
  - cosQuick
```
public static double cosQuick(double angle)
```
    Quick cosine, with accuracy of about 1.6e-3 (PI/) for |angle| < 6588397.0 (Integer.MAX_VALUE * (2*PI/)), and no accuracy at all for larger values.
    
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle cosine.
  - sin
```
public static double sin(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle sine.
  - sinQuick
```
public static double sinQuick(double angle)
```
    Quick sine, with accuracy of about 1.6e-3 (PI/) for |angle| < 6588397.0 (Integer.MAX_VALUE * (2*PI/)), and no accuracy at all for larger values.
    
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle sine.
  - sinAndCos
```
public static void sinAndCos(double angle,
             FastMath.DoubleWrapper sine,
             FastMath.DoubleWrapper cosine)
```
    Computes sine and cosine together, at the cost of... a dependency of this class with DoubleWrapper.
    
    Parameters:
    angle - Angle in radians.
    sine - Angle sine.
    cosine - Angle cosine.
  - tan
```
public static double tan(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle tangent.
  - acos
```
public static double acos(double value)
```
    Parameters:
    value - Value in [-1,1].
    
    Returns:
    Value arccosine, in radians, in [0,PI].
  - acosInRange
```
public static double acosInRange(double value)
```
    If value is not NaN and is outside [-1,1] range, closest value in this range is used.
    
    Parameters:
    value - Value in [-1,1].
    
    Returns:
    Value arccosine, in radians, in [0,PI].
  - asin
```
public static double asin(double value)
```
    Parameters:
    value - Value in [-1,1].
    
    Returns:
    Value arcsine, in radians, in [-PI/2,PI/2].
  - asinInRange
```
public static double asinInRange(double value)
```
    If value is not NaN and is outside [-1,1] range, closest value in this range is used.
    
    Parameters:
    value - Value in [-1,1].
    
    Returns:
    Value arcsine, in radians, in [-PI/2,PI/2].
  - atan
```
public static double atan(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value arctangent, in radians, in [-PI/2,PI/2].
  - atan2
```
public static double atan2(double y,
           double x)
```
    For special values for which multiple conventions could be adopted, behaves like Math.atan2(double,double).
    
    Parameters:
    y - Coordinate on y axis.
    x - Coordinate on x axis.
    
    Returns:
    Angle from x axis positive side to (x,y) position, in radians, in [-PI,PI]. Angle measure is positive when going from x axis to y axis (positive sides).
  - cosh
```
public static double cosh(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value hyperbolic cosine.
  - sinh
```
public static double sinh(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value hyperbolic sine.
  - sinhAndCosh
```
public static void sinhAndCosh(double value,
               FastMath.DoubleWrapper hsine,
               FastMath.DoubleWrapper hcosine)
```
    Computes hyperbolic sine and hyperbolic cosine together, at the cost of... a dependency of this class with DoubleWrapper.
    
    Parameters:
    value - A double value.
    hsine - Value hyperbolic sine.
    hcosine - Value hyperbolic cosine.
  - tanh
```
public static double tanh(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value hyperbolic tangent.
  - exp
```
public static double exp(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    e^value.
  - expQuick
```
public static double expQuick(double value)
```
    Quick exp, with a max relative error of about 3e-2 for |value| < 700.0 or so, and no accuracy at all outside this range. Derived from a note by Nicol N. Schraudolph, IDSIA, 1998.
    
    Parameters:
    value - A double value.
    
    Returns:
    e^value.
  - expm1
```
public static double expm1(double value)
```
    Much more accurate than exp(value)-1, for values close to zero.
    
    Parameters:
    value - A double value.
    
    Returns:
    e^value-1.
  - log
```
public static double log(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value logarithm (base e).
  - logQuick
```
public static double logQuick(double value)
```
    Quick log, with a max relative error of about 2.8e-4 for values in ]0,+infinity[, and no accuracy at all outside this range.
  - log10
```
public static double log10(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value logarithm (base 10).
  - log1p
```
public static double log1p(double value)
```
    Much more accurate than log(1+value), for values close to zero.
    
    Parameters:
    value - A double value.
    
    Returns:
    Logarithm (base e) of (1+value).
  - log2
```
public static int log2(int value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is <= 0.
    Parameters:
    value - An integer value in [1,Integer.MAX_VALUE].
    
    Returns:
    The integer part of the logarithm, in base 2, of the specified value, i.e. a result in [0,30]
  - log2
```
public static int log2(long value)
```
    Throws:
    
    IllegalArgumentException - if the specified value is <= 0.
    Parameters:
    value - An integer value in [1,Long.MAX_VALUE].
    
    Returns:
    The integer part of the logarithm, in base 2, of the specified value, i.e. a result in [0,62]
  - pow
```
public static double pow(double value,
         double power)
```
    1e-13ish accuracy (or better) on whole double range.
    
    Parameters:
    value - A double value.
    power - A power.
    
    Returns:
    value^power.
  - powQuick
```
public static double powQuick(double value,
              double power)
```
    Quick pow, with a max relative error of about 3.5e-2 for |a^b| < 1e10, of about 0.17 for |a^b| < 1e50, and worse accuracy above.
    
    Parameters:
    value - A double value, in ]0,+infinity[ (strictly positive and finite).
    power - A double value.
    
    Returns:
    value^power.
  - powFast
```
public static double powFast(double value,
             int power)
```
    This treatment is somehow accurate for low values of |power|, and for |power*getExponent(value)| < 1023 or so (to stay away from double extreme magnitudes (large and small)).
    
    Parameters:
    value - A double value.
    power - A power.
    
    Returns:
    value^power.
  - twoPow
```
public static double twoPow(int power)
```
    Returns the exact result, provided it's in double range.
    
    Parameters:
    power - A power.
    
    Returns:
    2^power.
  - pow2
```
public static int pow2(int value)
```
    Parameters:
    value - An int value.
    
    Returns:
    value*value.
  - pow2
```
public static long pow2(long value)
```
    Parameters:
    value - A long value.
    
    Returns:
    value*value.
  - pow2
```
public static float pow2(float value)
```
    Parameters:
    value - A float value.
    
    Returns:
    value*value.
  - pow2
```
public static double pow2(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    value*value.
  - pow3
```
public static int pow3(int value)
```
    Parameters:
    value - An int value.
    
    Returns:
    value*value*value.
  - pow3
```
public static long pow3(long value)
```
    Parameters:
    value - A long value.
    
    Returns:
    value*value*value.
  - pow3
```
public static float pow3(float value)
```
    Parameters:
    value - A float value.
    
    Returns:
    value*value*value.
  - pow3
```
public static double pow3(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    value*value*value.
  - sqrt
```
public static double sqrt(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value square root.
  - cbrt
```
public static double cbrt(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value cubic root.
  - remainder
```
public static double remainder(double dividend,
               double divisor)
```
    Returns dividend - divisor * n, where n is the mathematical integer closest to dividend/divisor. If dividend/divisor is equally close to surrounding integers, we choose n to be the integer of smallest magnitude, which makes this treatment differ from Math.IEEEremainder(double,double), where n is chosen to be the even integer. Note that the choice of n is not done considering the double approximation of dividend/divisor, because it could cause result to be outside [-|divisor|/2,|divisor|/2] range. The practical effect is that if multiple results would be possible, we always choose the result that is the closest to (and has the same sign as) the dividend. Ex. : - for (-3.0,2.0), this method returns -1.0, whereas Math.IEEEremainder returns 1.0. - for (-5.0,2.0), both this method and Math.IEEEremainder return -1.0. If the remainder is zero, its sign is the same as the sign of the first argument. If either argument is NaN, or the first argument is infinite, or the second argument is positive zero or negative zero, then the result is NaN. If the first argument is finite and the second argument is infinite, then the result is the same as the first argument. NB: - Modulo operator (%) returns a value in ]-|divisor|,|divisor|[, which sign is the same as dividend. - As for modulo operator, the sign of the divisor has no effect on the result.
    
    Parameters:
    dividend - Dividend.
    divisor - Divisor.
    
    Returns:
    Remainder of dividend/divisor, i.e. a value in [-|divisor|/2,|divisor|/2].
  - normalizeMinusPiPi
```
public static double normalizeMinusPiPi(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    The same angle, in radians, but in [-Math.PI,Math.PI].
  - normalizeMinusPiPiFast
```
public static double normalizeMinusPiPiFast(double angle)
```
    Not accurate for large values.
    
    Parameters:
    angle - Angle in radians.
    
    Returns:
    The same angle, in radians, but in [-Math.PI,Math.PI].
  - normalizeZeroTwoPi
```
public static double normalizeZeroTwoPi(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    The same angle, in radians, but in [0,2*Math.PI].
  - normalizeZeroTwoPiFast
```
public static double normalizeZeroTwoPiFast(double angle)
```
    Not accurate for large values.
    
    Parameters:
    angle - Angle in radians.
    
    Returns:
    The same angle, in radians, but in [0,2*Math.PI].
  - normalizeMinusHalfPiHalfPi
```
public static double normalizeMinusHalfPiHalfPi(double angle)
```
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle value modulo PI, in radians, in [-Math.PI/2,Math.PI/2].
  - normalizeMinusHalfPiHalfPiFast
```
public static double normalizeMinusHalfPiHalfPiFast(double angle)
```
    Not accurate for large values.
    
    Parameters:
    angle - Angle in radians.
    
    Returns:
    Angle value modulo PI, in radians, in [-Math.PI/2,Math.PI/2].
  - hypot
```
public static double hypot(double x,
           double y)
```
    Returns sqrt(x^2+y^2) without intermediate overflow or underflow.
  - ceil
```
public static float ceil(float value)
```
    Parameters:
    value - A float value.
    
    Returns:
    Ceiling of value.
  - ceil
```
public static double ceil(double value)
```
    Supposed to behave like Math.ceil(double), for safe interchangeability.
    
    Parameters:
    value - A double value.
    
    Returns:
    Ceiling of value.
  - floor
```
public static float floor(float value)
```
    Parameters:
    value - A float value.
    
    Returns:
    Floor of value.
  - floor
```
public static double floor(double value)
```
    Supposed to behave like Math.floor(double), for safe interchangeability.
    
    Parameters:
    value - A double value.
    
    Returns:
    Floor of value.
  - round
```
public static int round(float value)
```
    Supposed to behave like Math.round(float), for safe interchangeability.
    
    Parameters:
    value - A double value.
    
    Returns:
    Value rounded to nearest int.
  - round
```
public static long round(double value)
```
    Supposed to behave like Math.round(double), for safe interchangeability.
    
    Parameters:
    value - A double value.
    
    Returns:
    Value rounded to nearest long.
  - getExponent
```
public static int getExponent(float value)
```
    Parameters:
    value - A float value.
    
    Returns:
    Value unbiased exponent.
  - getExponent
```
public static int getExponent(double value)
```
    Parameters:
    value - A double value.
    
    Returns:
    Value unbiased exponent.
  - toDegrees
```
public static double toDegrees(double angrad)
```
    Gives same result as Math.toDegrees for some particular values like Math.PI/2, Math.PI or 2*Math.PI, but is faster (no division).
    
    Parameters:
    angrad - Angle value in radians.
    
    Returns:
    Angle value in degrees.
  - toRadians
```
public static double toRadians(double angdeg)
```
    Gives same result as Math.toRadians for some particular values like 90.0, 180.0 or 360.0, but is faster (no division).
    
    Parameters:
    angdeg - Angle value in degrees.
    
    Returns:
    Angle value in radians.
  - toRadians
```
public static double toRadians(boolean sign,
               int degrees,
               int minutes,
               double seconds)
```
    Parameters:
    sign - Sign of the angle: true for positive, false for negative.
    degrees - Degrees, in [0,180].
    minutes - Minutes, in [0,59].
    seconds - Seconds, in [0.0,60.0[.
    
    Returns:
    Angle in radians.
  - toDegrees
```
public static double toDegrees(boolean sign,
               int degrees,
               int minutes,
               double seconds)
```
    Parameters:
    sign - Sign of the angle: true for positive, false for negative.
    degrees - Degrees, in [0,180].
    minutes - Minutes, in [0,59].
    seconds - Seconds, in [0.0,60.0[.
    
    Returns:
    Angle in degrees.
  - toDMS
```
public static boolean toDMS(double angrad,
            FastMath.IntWrapper degrees,
            FastMath.IntWrapper minutes,
            FastMath.DoubleWrapper seconds)
```
    Parameters:
    angrad - Angle in radians.
    degrees - (out) Degrees, in [0,180].
    minutes - (out) Minutes, in [0,59].
    seconds - (out) Seconds, in [0.0,60.0[.
    
    Returns:
    True if the resulting angle in [-180deg,180deg] is positive, false if it is negative.
  - abs
```
public static int abs(int value)
```
    Parameters:
    value - An int value.
    
    Returns:
    The absolute value, except if value is Integer.MIN_VALUE, for which it returns Integer.MIN_VALUE.
  - toIntExact
```
public static int toIntExact(long value)
```
    Throws:
    
    ArithmeticException - if the specified value is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    value - A long value.
    
    Returns:
    The specified value as int.
  - toInt
```
public static int toInt(long value)
```
    Parameters:
    value - A long value.
    
    Returns:
    The closest int value in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
  - addExact
```
public static int addExact(int a,
           int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a+b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a+b.
  - addExact
```
public static long addExact(long a,
            long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a+b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a+b.
  - addBounded
```
public static int addBounded(int a,
             int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a+b.
  - addBounded
```
public static long addBounded(long a,
              long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a+b.
  - subtractExact
```
public static int subtractExact(int a,
                int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a-b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a-b.
  - subtractExact
```
public static long subtractExact(long a,
                 long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a-b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a-b.
  - subtractBounded
```
public static int subtractBounded(int a,
                  int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a-b.
  - subtractBounded
```
public static long subtractBounded(long a,
                   long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a-b.
  - multiplyExact
```
public static int multiplyExact(int a,
                int b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a*b is not in [Integer.MIN_VALUE,Integer.MAX_VALUE] range.
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The mathematical result of a*b.
  - multiplyExact
```
public static long multiplyExact(long a,
                 long b)
```
    Throws:
    
    ArithmeticException - if the mathematical result of a*b is not in [Long.MIN_VALUE,Long.MAX_VALUE] range.
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The mathematical result of a*b.
  - multiplyBounded
```
public static int multiplyBounded(int a,
                  int b)
```
    Parameters:
    a - An int value.
    b - An int value.
    
    Returns:
    The int value of [Integer.MIN_VALUE,Integer.MAX_VALUE] range which is the closest to mathematical result of a*b.
  - multiplyBounded
```
public static long multiplyBounded(long a,
                   long b)
```
    Parameters:
    a - A long value.
    b - A long value.
    
    Returns:
    The long value of [Long.MIN_VALUE,Long.MAX_VALUE] range which is the closest to mathematical result of a*b.
  - toRange
```
public static int toRange(int minValue,
          int maxValue,
          int value)
```
    Parameters:
    minValue - An int value.
    maxValue - An int value.
    value - An int value.
    
    Returns:
    minValue if value < minValue, maxValue if value > maxValue, value otherwise.
  - toRange
```
public static long toRange(long minValue,
           long maxValue,
           long value)
```
    Parameters:
    minValue - A long value.
    maxValue - A long value.
    value - A long value.
    
    Returns:
    minValue if value < minValue, maxValue if value > maxValue, value otherwise.
  - toRange
```
public static float toRange(float minValue,
            float maxValue,
            float value)
```
    Parameters:
    minValue - A float value.
    maxValue - A float value.
    value - A float value.
    
    Returns:
    minValue if value < minValue, maxValue if value > maxValue, value otherwise.
  - toRange
```
public static double toRange(double minValue,
             double maxValue,
             double value)
```
    Parameters:
    minValue - A double value.
    maxValue - A double value.
    value - A double value.
    
    Returns:
    minValue if value < minValue, maxValue if value > maxValue, value otherwise.
  - isInClockwiseDomain
```
public static boolean isInClockwiseDomain(double startAngRad,
                          double angSpanRad,
                          double angRad)
```
    NB: Since 2*Math.PI < 2*PI, a span of 2*Math.PI does not mean full angular range. ex.: isInClockwiseDomain(0.0, 2*Math.PI, -1e-20) returns false. ---> For full angular range, use a span > 2*Math.PI, like 2*PI_SUP constant of this class.
    
    Parameters:
    startAngRad - An angle, in radians.
    angSpanRad - An angular span, >= 0.0, in radians.
    angRad - An angle, in radians.
    
    Returns:
    True if angRad is in the clockwise angular domain going from startAngRad, over angSpanRad, extremities included, false otherwise.
  - isNaNOrInfinite
```
public static boolean isNaNOrInfinite(float value)
```
  - isNaNOrInfinite
```
public static boolean isNaNOrInfinite(double value)
```
  - abs
```
public static double abs(double a)
```
  - abs
```
public static float abs(float a)
```
  - abs
```
public static long abs(long a)
```
  - copySign
```
public static double copySign(double magnitude,
              double sign)
```
  - copySign
```
public static float copySign(float magnitude,
             float sign)
```
  - IEEEremainder
```
public static double IEEEremainder(double f1,
                   double f2)
```
  - max
```
public static double max(double a,
         double b)
```
  - max
```
public static float max(float a,
        float b)
```
  - max
```
public static int max(int a,
      int b)
```
  - max
```
public static long max(long a,
       long b)
```
  - min
```
public static double min(double a,
         double b)
```
  - min
```
public static float min(float a,
        float b)
```
  - min
```
public static int min(int a,
      int b)
```
  - min
```
public static long min(long a,
       long b)
```
  - nextAfter
```
public static double nextAfter(double start,
               double direction)
```
  - nextAfter
```
public static float nextAfter(float start,
              float direction)
```
  - nextUp
```
public static double nextUp(double d)
```
  - nextUp
```
public static float nextUp(float f)
```
  - random
```
public static double random()
```
  - rint
```
public static double rint(double a)
```
  - scalb
```
public static double scalb(double d,
           int scaleFactor)
```
  - scalb
```
public static float scalb(float f,
          int scaleFactor)
```
  - signum
```
public static double signum(double d)
```
  - signum
```
public static float signum(float f)
```
  - ulp
```
public static double ulp(double d)
```
  - ulp
```
public static float ulp(float f)
```

Class FastMath

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI_SUP

E

PI

Method Detail

cos

cosQuick

sin

sinQuick

sinAndCos

tan

acos

acosInRange

asin

asinInRange

atan

atan2

cosh

sinh

sinhAndCosh

tanh

exp

expQuick

expm1

log

logQuick

log10

log1p

log2

log2

pow

powQuick

powFast

twoPow

pow2

pow2

pow2

pow2

pow3

pow3

pow3

pow3

sqrt

cbrt

remainder

normalizeMinusPiPi

normalizeMinusPiPiFast

normalizeZeroTwoPi

normalizeZeroTwoPiFast

normalizeMinusHalfPiHalfPi

normalizeMinusHalfPiHalfPiFast

hypot

ceil

ceil

floor

floor

round

round

getExponent

getExponent

toDegrees

toRadians

toRadians

toDegrees

toDMS

abs

toIntExact

toInt

addExact

addExact

addBounded

addBounded

subtractExact

subtractExact

subtractBounded