MathBindings (advanced-bindings 0.3.0 API)

java.lang.Object
- eu.lestard.advanced_bindings.api.MathBindings

```
public class MathBindings
extends Object
```
This class contains binding implementations for all methods of Math.

Constructor Summary

Constructors
Constructor and Description

MathBindings()

Constructors
Constructor and Description
`MathBindings()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static DoubleBinding`	`abs(ObservableDoubleValue a)` Binding for `Math.abs(double)`
`static FloatBinding`	`abs(ObservableFloatValue a)` Binding for `Math.abs(float)`
`static IntegerBinding`	`abs(ObservableIntegerValue a)` Binding for `Math.abs(int)`
`static LongBinding`	`abs(ObservableLongValue a)` Binding for `Math.abs(long)`
`static DoubleBinding`	`acos(ObservableDoubleValue a)` Binding for `Math.acos(double)`
`static IntegerBinding`	`addExact(int x, ObservableIntegerValue y)` Binding for `Math.addExact(int, int)`
`static LongBinding`	`addExact(long x, ObservableLongValue y)` Binding for `Math.addExact(long, long)`
`static IntegerBinding`	`addExact(ObservableIntegerValue x, int y)` Binding for `Math.addExact(int, int)`
`static IntegerBinding`	`addExact(ObservableIntegerValue x, ObservableIntegerValue y)` Binding for `Math.addExact(int, int)`
`static LongBinding`	`addExact(ObservableLongValue x, long y)` Binding for `Math.addExact(long, long)`
`static LongBinding`	`addExact(ObservableLongValue x, ObservableLongValue y)` Binding for `Math.addExact(long, long)`
`static DoubleBinding`	`asin(ObservableDoubleValue a)` Binding for `Math.asin(double)`
`static DoubleBinding`	`atan(ObservableDoubleValue a)` Binding for `Math.atan(double)`
`static DoubleBinding`	`atan2(double y, ObservableDoubleValue x)` Binding for `Math.atan2(double, double)`
`static DoubleBinding`	`atan2(ObservableDoubleValue y, double x)` Binding for `Math.atan2(double, double)`
`static DoubleBinding`	`atan2(ObservableDoubleValue y, ObservableDoubleValue x)` Binding for `Math.atan2(double, double)`
`static DoubleBinding`	`cbrt(ObservableDoubleValue a)` Binding for `Math.cbrt(double)`
`static DoubleBinding`	`ceil(ObservableDoubleValue a)` Binding for `Math.ceil(double)`
`static DoubleBinding`	`copySign(double magnitude, ObservableDoubleValue sign)` Binding for `Math.copySign(double, double)`
`static FloatBinding`	`copySign(float magnitude, ObservableFloatValue sign)` Binding for `Math.copySign(float, float)`
`static DoubleBinding`	`copySign(ObservableDoubleValue magnitude, double sign)` Binding for `Math.copySign(double, double)`
`static DoubleBinding`	`copySign(ObservableDoubleValue magnitude, ObservableDoubleValue sign)` Binding for `Math.copySign(double, double)`
`static FloatBinding`	`copySign(ObservableFloatValue magnitude, float sign)` Binding for `Math.copySign(float, float)`
`static FloatBinding`	`copySign(ObservableFloatValue magnitude, ObservableFloatValue sign)` Binding for `Math.copySign(float, float)`
`static DoubleBinding`	`cos(ObservableDoubleValue a)` Binding for `Math.cos(double)`
`static DoubleBinding`	`cosh(ObservableDoubleValue x)` Binding for `Math.cosh(double)`
`static IntegerBinding`	`decrementExact(ObservableIntegerValue a)` Binding for `Math.decrementExact(int)`
`static LongBinding`	`decrementExact(ObservableLongValue a)` Binding for `Math.decrementExact(long)`
`static DoubleBinding`	`exp(ObservableDoubleValue a)` Binding for `Math.exp(double)`
`static DoubleBinding`	`expm1(ObservableDoubleValue x)` Binding for `Math.expm1(double)`
`static DoubleBinding`	`floor(ObservableDoubleValue a)` Binding for `Math.floor(double)`
`static IntegerBinding`	`floorDiv(int x, ObservableIntegerValue y)` Binding for `Math.floorDiv(int, int)`
`static LongBinding`	`floorDiv(long x, ObservableLongValue y)` Binding for `Math.floorDiv(long, long)`
`static IntegerBinding`	`floorDiv(ObservableIntegerValue x, int y)` Binding for `Math.floorDiv(int, int)`
`static IntegerBinding`	`floorDiv(ObservableIntegerValue x, ObservableIntegerValue y)` Binding for `Math.floorDiv(int, int)`
`static LongBinding`	`floorDiv(ObservableLongValue x, long y)` Binding for `Math.floorDiv(long, long)`
`static LongBinding`	`floorDiv(ObservableLongValue x, ObservableLongValue y)` Binding for `Math.floorDiv(long, long)`
`static IntegerBinding`	`floorMod(int x, ObservableIntegerValue y)` Binding for `Math.floorMod(int, int)`
`static LongBinding`	`floorMod(long x, ObservableLongValue y)` Binding for `Math.floorMod(long, long)`
`static IntegerBinding`	`floorMod(ObservableIntegerValue x, int y)` Binding for `Math.floorMod(int, int)`
`static IntegerBinding`	`floorMod(ObservableIntegerValue x, ObservableIntegerValue y)` Binding for `Math.floorMod(int, int)`
`static LongBinding`	`floorMod(ObservableLongValue x, long y)` Binding for `Math.floorMod(long, long)`
`static LongBinding`	`floorMod(ObservableLongValue x, ObservableLongValue y)` Binding for `Math.floorMod(long, long)`
`static IntegerBinding`	`getExponent(ObservableDoubleValue d)` Binding for `Math.getExponent(double)`
`static IntegerBinding`	`getExponent(ObservableFloatValue f)` Binding for `Math.getExponent(float)`
`static DoubleBinding`	`hypot(double x, ObservableDoubleValue y)` Binding for `Math.hypot(double, double)`
`static DoubleBinding`	`hypot(ObservableDoubleValue x, double y)` Binding for `Math.hypot(double, double)`
`static DoubleBinding`	`hypot(ObservableDoubleValue x, ObservableDoubleValue y)` Binding for `Math.hypot(double, double)`
`static DoubleBinding`	`IEEEremainder(double f1, ObservableDoubleValue f2)` Binding for `Math.IEEEremainder(double, double)`
`static DoubleBinding`	`IEEEremainder(ObservableDoubleValue f1, double f2)` Binding for `Math.IEEEremainder(double, double)`
`static DoubleBinding`	`IEEEremainder(ObservableDoubleValue f1, ObservableDoubleValue f2)` Binding for `Math.IEEEremainder(double, double)`
`static IntegerBinding`	`incrementExact(ObservableIntegerValue a)` Binding for `Math.incrementExact(int)`
`static LongBinding`	`incrementExact(ObservableLongValue a)` Binding for `Math.incrementExact(long)`
`static DoubleBinding`	`log(ObservableDoubleValue a)` Binding for `Math.log(double)`
`static DoubleBinding`	`log10(ObservableDoubleValue a)` Binding for `Math.log10(double)`
`static DoubleBinding`	`log1p(ObservableDoubleValue x)` Binding for `Math.log1p(double)`
`static DoubleBinding`	`max(double a, ObservableDoubleValue b)` Binding for `Math.max(double, double)`
`static FloatBinding`	`max(float a, ObservableFloatValue b)` Binding for `Math.max(float, float)`
`static IntegerBinding`	`max(int a, ObservableIntegerValue b)` Binding for `Math.max(int, int)`
`static LongBinding`	`max(long a, ObservableLongValue b)` Binding for `Math.max(long, long)`
`static DoubleBinding`	`max(ObservableDoubleValue a, double b)` Binding for `Math.max(double, double)`
`static DoubleBinding`	`max(ObservableDoubleValue a, ObservableDoubleValue b)` Binding for `Math.max(double, double)`
`static FloatBinding`	`max(ObservableFloatValue a, float b)` Binding for `Math.max(float, float)`
`static FloatBinding`	`max(ObservableFloatValue a, ObservableFloatValue b)` Binding for `Math.max(float, float)`
`static IntegerBinding`	`max(ObservableIntegerValue a, int b)` Binding for `Math.max(int, int)`
`static IntegerBinding`	`max(ObservableIntegerValue a, ObservableIntegerValue b)` Binding for `Math.max(int, int)`
`static LongBinding`	`max(ObservableLongValue a, long b)` Binding for `Math.max(long, long)`
`static LongBinding`	`max(ObservableLongValue a, ObservableLongValue b)` Binding for `Math.max(long, long)`
`static DoubleBinding`	`min(double a, ObservableDoubleValue b)` Binding for `Math.min(double, double)`
`static FloatBinding`	`min(float a, ObservableFloatValue b)` Binding for `Math.min(float, float)`
`static IntegerBinding`	`min(int a, ObservableIntegerValue b)` Binding for `Math.min(int, int)`
`static LongBinding`	`min(long a, ObservableLongValue b)` Binding for `Math.min(long, long)`
`static DoubleBinding`	`min(ObservableDoubleValue a, double b)` Binding for `Math.min(double, double)`
`static DoubleBinding`	`min(ObservableDoubleValue a, ObservableDoubleValue b)` Binding for `Math.min(double, double)`
`static FloatBinding`	`min(ObservableFloatValue a, float b)` Binding for `Math.min(float, float)`
`static FloatBinding`	`min(ObservableFloatValue a, ObservableFloatValue b)` Binding for `Math.min(float, float)`
`static IntegerBinding`	`min(ObservableIntegerValue a, int b)` Binding for `Math.min(int, int)`
`static IntegerBinding`	`min(ObservableIntegerValue a, ObservableIntegerValue b)` Binding for `Math.min(int, int)`
`static LongBinding`	`min(ObservableLongValue a, long b)` Binding for `Math.min(long, long)`
`static LongBinding`	`min(ObservableLongValue a, ObservableLongValue b)` Binding for `Math.min(long, long)`
`static IntegerBinding`	`multiplyExact(int x, ObservableIntegerValue y)` Binding for `Math.multiplyExact(int, int)`
`static LongBinding`	`multiplyExact(long x, ObservableLongValue y)` Binding for `Math.multiplyExact(long, long)`
`static IntegerBinding`	`multiplyExact(ObservableIntegerValue x, int y)` Binding for `Math.multiplyExact(int, int)`
`static IntegerBinding`	`multiplyExact(ObservableIntegerValue x, ObservableIntegerValue y)` Binding for `Math.multiplyExact(int, int)`
`static LongBinding`	`multiplyExact(ObservableLongValue x, long y)` Binding for `Math.multiplyExact(long, long)`
`static LongBinding`	`multiplyExact(ObservableLongValue x, ObservableLongValue y)` Binding for `Math.multiplyExact(long, long)`
`static IntegerBinding`	`negateExact(ObservableIntegerValue a)` Binding for `Math.negateExact(int)`
`static LongBinding`	`negateExact(ObservableLongValue a)` Binding for `Math.negateExact(long)`
`static DoubleBinding`	`nextAfter(double start, ObservableDoubleValue direction)` Binding for `Math.nextAfter(double, double)`
`static FloatBinding`	`nextAfter(float start, ObservableFloatValue direction)` Binding for `Math.nextAfter(float, double)`
`static DoubleBinding`	`nextAfter(ObservableDoubleValue start, double direction)` Binding for `Math.nextAfter(double, double)`
`static DoubleBinding`	`nextAfter(ObservableDoubleValue start, ObservableDoubleValue direction)` Binding for `Math.nextAfter(double, double)`
`static FloatBinding`	`nextAfter(ObservableFloatValue start, float direction)` Binding for `Math.nextAfter(float, double)`
`static FloatBinding`	`nextAfter(ObservableFloatValue start, ObservableFloatValue direction)` Binding for `Math.nextAfter(float, double)`
`static DoubleBinding`	`nextDown(ObservableDoubleValue d)` Binding for `Math.nextDown(double)`
`static FloatBinding`	`nextDown(ObservableFloatValue f)` Binding for `Math.nextDown(float)`
`static DoubleBinding`	`nextUp(ObservableDoubleValue d)` Binding for `Math.nextUp(double)`
`static FloatBinding`	`nextUp(ObservableFloatValue f)` Binding for `Math.nextUp(float)`
`static DoubleBinding`	`pow(double a, ObservableDoubleValue b)` Binding for `Math.pow(double, double)`
`static DoubleBinding`	`pow(ObservableDoubleValue a, double b)` Binding for `Math.pow(double, double)`
`static DoubleBinding`	`pow(ObservableDoubleValue a, ObservableDoubleValue b)` Binding for `Math.pow(double, double)`
`static DoubleBinding`	`rint(ObservableDoubleValue a)` Binding for `Math.rint(double)`
`static LongBinding`	`round(ObservableDoubleValue a)` Binding for `Math.round(double)`
`static IntegerBinding`	`round(ObservableFloatValue a)` Binding for `Math.round(float)`
`static DoubleBinding`	`scalb(double d, ObservableIntegerValue scaleFactor)` Binding for `Math.scalb(double, int)`
`static FloatBinding`	`scalb(float f, ObservableIntegerValue scaleFactor)` Binding for `Math.scalb(float, int)`
`static DoubleBinding`	`scalb(ObservableDoubleValue d, int scaleFactor)` Binding for `Math.scalb(double, int)`
`static DoubleBinding`	`scalb(ObservableDoubleValue d, ObservableIntegerValue scaleFactor)` Binding for `Math.scalb(double, int)`
`static FloatBinding`	`scalb(ObservableFloatValue f, int scaleFactor)` Binding for `Math.scalb(float, int)`
`static FloatBinding`	`scalb(ObservableFloatValue f, ObservableIntegerValue scaleFactor)` Binding for `Math.scalb(float, int)`
`static DoubleBinding`	`signum(ObservableDoubleValue d)` Binding for `Math.signum(double)`
`static FloatBinding`	`signum(ObservableFloatValue f)` Binding for `Math.signum(float)`
`static DoubleBinding`	`sin(ObservableDoubleValue a)` Binding for `Math.sin(double)`
`static DoubleBinding`	`sinh(ObservableDoubleValue x)` Binding for `Math.sinh(double)`
`static DoubleBinding`	`sqrt(ObservableDoubleValue a)` Binding for `Math.sqrt(double)`
`static IntegerBinding`	`subtractExact(int x, ObservableIntegerValue y)` Binding for `Math.subtractExact(int, int)`
`static LongBinding`	`subtractExact(long x, ObservableLongValue y)` Binding for `Math.subtractExact(long, long)`
`static IntegerBinding`	`subtractExact(ObservableIntegerValue x, int y)` Binding for `Math.subtractExact(int, int)`
`static IntegerBinding`	`subtractExact(ObservableIntegerValue x, ObservableIntegerValue y)` Binding for `Math.subtractExact(int, int)`
`static LongBinding`	`subtractExact(ObservableLongValue x, long y)` Binding for `Math.subtractExact(long, long)`
`static LongBinding`	`subtractExact(ObservableLongValue x, ObservableLongValue y)` Binding for `Math.subtractExact(long, long)`
`static DoubleBinding`	`tan(ObservableDoubleValue a)` Binding for `Math.tan(double)`
`static DoubleBinding`	`tanh(ObservableDoubleValue x)` Binding for `Math.tanh(double)`
`static DoubleBinding`	`toDegrees(ObservableDoubleValue angrad)` Binding for `Math.toDegrees(double)`
`static IntegerBinding`	`toIntExact(ObservableLongValue value)` Binding for `Math.toIntExact(long)`
`static DoubleBinding`	`toRadians(ObservableDoubleValue angdeg)` Binding for `Math.toRadians(double)`
`static DoubleBinding`	`ulp(ObservableDoubleValue d)` Binding for `Math.ulp(double)`
`static FloatBinding`	`ulp(ObservableFloatValue f)` Binding for `Math.ulp(float)`

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

- Constructor Detail
  - MathBindings
```
public MathBindings()
```
- Method Detail
  - abs
```
public static IntegerBinding abs(ObservableIntegerValue a)
```
    Binding for Math.abs(int)
    
    Parameters:
    
    a - the argument whose absolute value is to be determined
    
    Returns:
    
    the absolute value of the argument.
  - abs
```
public static DoubleBinding abs(ObservableDoubleValue a)
```
    Binding for Math.abs(double)
    
    Parameters:
    
    a - the argument whose absolute value is to be determined
    
    Returns:
    
    the absolute value of the argument.
  - abs
```
public static LongBinding abs(ObservableLongValue a)
```
    Binding for Math.abs(long)
    
    Parameters:
    
    a - the argument whose absolute value is to be determined as observableValue
    
    Returns:
    
    the absolute value of the argument.
  - abs
```
public static FloatBinding abs(ObservableFloatValue a)
```
    Binding for Math.abs(float)
    
    Parameters:
    
    a - the argument whose absolute value is to be determined as observableValue
    
    Returns:
    
    the absolute value of the argument.
  - addExact
```
public static IntegerBinding addExact(ObservableIntegerValue x,
                                      ObservableIntegerValue y)
```
    Binding for Math.addExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - addExact
```
public static IntegerBinding addExact(int x,
                                      ObservableIntegerValue y)
```
    Binding for Math.addExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - addExact
```
public static IntegerBinding addExact(ObservableIntegerValue x,
                                      int y)
```
    Binding for Math.addExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - addExact
```
public static LongBinding addExact(ObservableLongValue x,
                                   ObservableLongValue y)
```
    Binding for Math.addExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - addExact
```
public static LongBinding addExact(long x,
                                   ObservableLongValue y)
```
    Binding for Math.addExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - addExact
```
public static LongBinding addExact(ObservableLongValue x,
                                   long y)
```
    Binding for Math.addExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - acos
```
public static DoubleBinding acos(ObservableDoubleValue a)
```
    Binding for Math.acos(double)
    
    Parameters:
    
    a - the value whose arc cosine is to be returned.
    
    Returns:
    
    the arc cosine of the argument.
  - asin
```
public static DoubleBinding asin(ObservableDoubleValue a)
```
    Binding for Math.asin(double)
    
    Parameters:
    
    a - the value whose arc sine is to be returned.
    
    Returns:
    
    the arc sine of the argument.
  - atan
```
public static DoubleBinding atan(ObservableDoubleValue a)
```
    Binding for Math.atan(double)
    
    Parameters:
    
    a - the value whose arc tangent is to be returned.
    
    Returns:
    
    the arc tangent of the argument.
  - atan2
```
public static DoubleBinding atan2(ObservableDoubleValue y,
                                  ObservableDoubleValue x)
```
    Binding for Math.atan2(double, double)
    
    Parameters:
    
    y - the ordinate coordinate
    
    x - the abscissa coordinate
    
    Returns:
    
    the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.
  - atan2
```
public static DoubleBinding atan2(double y,
                                  ObservableDoubleValue x)
```
    Binding for Math.atan2(double, double)
    
    Parameters:
    
    y - the ordinate coordinate
    
    x - the abscissa coordinate
    
    Returns:
    
    the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.
  - atan2
```
public static DoubleBinding atan2(ObservableDoubleValue y,
                                  double x)
```
    Binding for Math.atan2(double, double)
    
    Parameters:
    
    y - the ordinate coordinate
    
    x - the abscissa coordinate
    
    Returns:
    
    the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.
  - cbrt
```
public static DoubleBinding cbrt(ObservableDoubleValue a)
```
    Binding for Math.cbrt(double)
    
    Parameters:
    
    a - a value.
    
    Returns:
    
    the cube root of a.
  - ceil
```
public static DoubleBinding ceil(ObservableDoubleValue a)
```
    Binding for Math.ceil(double)
    
    Parameters:
    
    a - a value.
    
    Returns:
    
    the smallest (closest to negative infinity) floating-point value that is greater than or equal to the argument and is equal to a mathematical integer.
  - copySign
```
public static DoubleBinding copySign(ObservableDoubleValue magnitude,
                                     ObservableDoubleValue sign)
```
    Binding for Math.copySign(double, double)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - copySign
```
public static DoubleBinding copySign(double magnitude,
                                     ObservableDoubleValue sign)
```
    Binding for Math.copySign(double, double)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - copySign
```
public static DoubleBinding copySign(ObservableDoubleValue magnitude,
                                     double sign)
```
    Binding for Math.copySign(double, double)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - copySign
```
public static FloatBinding copySign(ObservableFloatValue magnitude,
                                    ObservableFloatValue sign)
```
    Binding for Math.copySign(float, float)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - copySign
```
public static FloatBinding copySign(float magnitude,
                                    ObservableFloatValue sign)
```
    Binding for Math.copySign(float, float)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - copySign
```
public static FloatBinding copySign(ObservableFloatValue magnitude,
                                    float sign)
```
    Binding for Math.copySign(float, float)
    
    Parameters:
    
    magnitude - the parameter providing the magnitude of the result
    
    sign - the parameter providing the sign of the result
    
    Returns:
    
    a value with the magnitude of magnitude and the sign of sign.
  - cos
```
public static DoubleBinding cos(ObservableDoubleValue a)
```
    Binding for Math.cos(double)
    
    Parameters:
    
    a - an angle, in radians.
    
    Returns:
    
    the cosine of the argument.
  - cosh
```
public static DoubleBinding cosh(ObservableDoubleValue x)
```
    Binding for Math.cosh(double)
    
    Parameters:
    
    x - The number whose hyperbolic cosine is to be returned.
    
    Returns:
    
    The hyperbolic cosine of x.
  - decrementExact
```
public static IntegerBinding decrementExact(ObservableIntegerValue a)
```
    Binding for Math.decrementExact(int)
    
    Parameters:
    
    a - the value to decrement
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - decrementExact
```
public static LongBinding decrementExact(ObservableLongValue a)
```
    Binding for Math.decrementExact(long)
    
    Parameters:
    
    a - the value to decrement
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - exp
```
public static DoubleBinding exp(ObservableDoubleValue a)
```
    Binding for Math.exp(double)
    
    Parameters:
    
    a - the exponent to raise e to.
    
    Returns:
    
    the value e^a, where e is the base of the natural logarithms.
  - expm1
```
public static DoubleBinding expm1(ObservableDoubleValue x)
```
    Binding for Math.expm1(double)
    
    Parameters:
    
    x - the exponent to raise e to in the computation of e^x -1.
    
    Returns:
    
    the value e^x - 1.
  - floor
```
public static DoubleBinding floor(ObservableDoubleValue a)
```
    Binding for Math.floor(double)
    
    Parameters:
    
    a - a value.
    
    Returns:
    
    the largest (closest to positive infinity) floating-point value that less than or equal to the argument and is equal to a mathematical integer.
  - floorDiv
```
public static IntegerBinding floorDiv(ObservableIntegerValue x,
                                      ObservableIntegerValue y)
```
    Binding for Math.floorDiv(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorDiv
```
public static IntegerBinding floorDiv(int x,
                                      ObservableIntegerValue y)
```
    Binding for Math.floorDiv(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorDiv
```
public static IntegerBinding floorDiv(ObservableIntegerValue x,
                                      int y)
```
    Binding for Math.floorDiv(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorDiv
```
public static LongBinding floorDiv(ObservableLongValue x,
                                   ObservableLongValue y)
```
    Binding for Math.floorDiv(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorDiv
```
public static LongBinding floorDiv(long x,
                                   ObservableLongValue y)
```
    Binding for Math.floorDiv(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorDiv
```
public static LongBinding floorDiv(ObservableLongValue x,
                                   long y)
```
    Binding for Math.floorDiv(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static IntegerBinding floorMod(ObservableIntegerValue x,
                                      ObservableIntegerValue y)
```
    Binding for Math.floorMod(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static IntegerBinding floorMod(int x,
                                      ObservableIntegerValue y)
```
    Binding for Math.floorMod(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static IntegerBinding floorMod(ObservableIntegerValue x,
                                      int y)
```
    Binding for Math.floorMod(int, int)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static LongBinding floorMod(ObservableLongValue x,
                                   ObservableLongValue y)
```
    Binding for Math.floorMod(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static LongBinding floorMod(long x,
                                   ObservableLongValue y)
```
    Binding for Math.floorMod(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - floorMod
```
public static LongBinding floorMod(ObservableLongValue x,
                                   long y)
```
    Binding for Math.floorMod(long, long)
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
  - getExponent
```
public static IntegerBinding getExponent(ObservableDoubleValue d)
```
    Binding for Math.getExponent(double)
    
    Parameters:
    
    d - a double value
    
    Returns:
    
    the unbiased exponent of the argument
  - getExponent
```
public static IntegerBinding getExponent(ObservableFloatValue f)
```
    Binding for Math.getExponent(float)
    
    Parameters:
    
    f - a float value
    
    Returns:
    
    the unbiased exponent of the argument
  - hypot
```
public static DoubleBinding hypot(ObservableDoubleValue x,
                                  ObservableDoubleValue y)
```
    Binding for Math.hypot(double, double)
    
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²) without intermediate overflow or underflow
  - hypot
```
public static DoubleBinding hypot(double x,
                                  ObservableDoubleValue y)
```
    Binding for Math.hypot(double, double)
    
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²) without intermediate overflow or underflow
  - hypot
```
public static DoubleBinding hypot(ObservableDoubleValue x,
                                  double y)
```
    Binding for Math.hypot(double, double)
    
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²) without intermediate overflow or underflow
  - IEEEremainder
```
public static DoubleBinding IEEEremainder(ObservableDoubleValue f1,
                                          ObservableDoubleValue f2)
```
    Binding for Math.IEEEremainder(double, double)
    
    Parameters:
    
    f1 - the dividend.
    
    f2 - the divisor.
    
    Returns:
    
    the remainder when f1 is divided by f2.
  - IEEEremainder
```
public static DoubleBinding IEEEremainder(double f1,
                                          ObservableDoubleValue f2)
```
    Binding for Math.IEEEremainder(double, double)
    
    Parameters:
    
    f1 - the dividend.
    
    f2 - the divisor.
    
    Returns:
    
    the remainder when f1 is divided by f2.
  - IEEEremainder
```
public static DoubleBinding IEEEremainder(ObservableDoubleValue f1,
                                          double f2)
```
    Binding for Math.IEEEremainder(double, double)
    
    Parameters:
    
    f1 - the dividend.
    
    f2 - the divisor.
    
    Returns:
    
    the remainder when f1 is divided by f2.
  - incrementExact
```
public static IntegerBinding incrementExact(ObservableIntegerValue a)
```
    Binding for Math.incrementExact(int)
    
    Parameters:
    
    a - the value to increment
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - incrementExact
```
public static LongBinding incrementExact(ObservableLongValue a)
```
    Binding for Math.incrementExact(long)
    
    Parameters:
    
    a - the value to increment
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - log
```
public static DoubleBinding log(ObservableDoubleValue a)
```
    Binding for Math.log(double)
    
    Parameters:
    
    a - a value
    
    Returns:
    
    the value ln a, the natural logarithm of a.
  - log10
```
public static DoubleBinding log10(ObservableDoubleValue a)
```
    Binding for Math.log10(double)
    
    Parameters:
    
    a - a value
    
    Returns:
    
    the base 10 logarithm of a.
  - log1p
```
public static DoubleBinding log1p(ObservableDoubleValue x)
```
    Binding for Math.log1p(double)
    
    Parameters:
    
    x - a value
    
    Returns:
    
    the value ln(x + 1), the natural log of x + 1
  - max
```
public static DoubleBinding max(ObservableDoubleValue a,
                                ObservableDoubleValue b)
```
    Binding for Math.max(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static DoubleBinding max(double a,
                                ObservableDoubleValue b)
```
    Binding for Math.max(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static DoubleBinding max(ObservableDoubleValue a,
                                double b)
```
    Binding for Math.max(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static FloatBinding max(ObservableFloatValue a,
                               ObservableFloatValue b)
```
    Binding for Math.max(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static FloatBinding max(float a,
                               ObservableFloatValue b)
```
    Binding for Math.max(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static FloatBinding max(ObservableFloatValue a,
                               float b)
```
    Binding for Math.max(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static IntegerBinding max(ObservableIntegerValue a,
                                 ObservableIntegerValue b)
```
    Binding for Math.max(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static IntegerBinding max(int a,
                                 ObservableIntegerValue b)
```
    Binding for Math.max(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static IntegerBinding max(ObservableIntegerValue a,
                                 int b)
```
    Binding for Math.max(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static LongBinding max(ObservableLongValue a,
                              ObservableLongValue b)
```
    Binding for Math.max(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static LongBinding max(long a,
                              ObservableLongValue b)
```
    Binding for Math.max(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - max
```
public static LongBinding max(ObservableLongValue a,
                              long b)
```
    Binding for Math.max(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the larger of a and b.
  - min
```
public static DoubleBinding min(ObservableDoubleValue a,
                                ObservableDoubleValue b)
```
    Binding for Math.min(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static DoubleBinding min(double a,
                                ObservableDoubleValue b)
```
    Binding for Math.min(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static DoubleBinding min(ObservableDoubleValue a,
                                double b)
```
    Binding for Math.min(double, double)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static FloatBinding min(ObservableFloatValue a,
                               ObservableFloatValue b)
```
    Binding for Math.min(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static FloatBinding min(float a,
                               ObservableFloatValue b)
```
    Binding for Math.min(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static FloatBinding min(ObservableFloatValue a,
                               float b)
```
    Binding for Math.min(float, float)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static IntegerBinding min(ObservableIntegerValue a,
                                 ObservableIntegerValue b)
```
    Binding for Math.min(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static IntegerBinding min(int a,
                                 ObservableIntegerValue b)
```
    Binding for Math.min(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static IntegerBinding min(ObservableIntegerValue a,
                                 int b)
```
    Binding for Math.min(int, int)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static LongBinding min(ObservableLongValue a,
                              ObservableLongValue b)
```
    Binding for Math.min(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static LongBinding min(long a,
                              ObservableLongValue b)
```
    Binding for Math.min(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - min
```
public static LongBinding min(ObservableLongValue a,
                              long b)
```
    Binding for Math.min(long, long)
    
    Parameters:
    
    a - an argument.
    
    b - another argument.
    
    Returns:
    
    the smaller of a and b.
  - multiplyExact
```
public static IntegerBinding multiplyExact(ObservableIntegerValue x,
                                           ObservableIntegerValue y)
```
    Binding for Math.multiplyExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - multiplyExact
```
public static IntegerBinding multiplyExact(int x,
                                           ObservableIntegerValue y)
```
    Binding for Math.multiplyExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - multiplyExact
```
public static IntegerBinding multiplyExact(ObservableIntegerValue x,
                                           int y)
```
    Binding for Math.multiplyExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - multiplyExact
```
public static LongBinding multiplyExact(ObservableLongValue x,
                                        ObservableLongValue y)
```
    Binding for Math.multiplyExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - multiplyExact
```
public static LongBinding multiplyExact(long x,
                                        ObservableLongValue y)
```
    Binding for Math.multiplyExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - multiplyExact
```
public static LongBinding multiplyExact(ObservableLongValue x,
                                        long y)
```
    Binding for Math.multiplyExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - negateExact
```
public static IntegerBinding negateExact(ObservableIntegerValue a)
```
    Binding for Math.negateExact(int)
    
    Parameters:
    
    a - the value to negate
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - negateExact
```
public static LongBinding negateExact(ObservableLongValue a)
```
    Binding for Math.negateExact(long)
    
    Parameters:
    
    a - the value to negate
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - nextAfter
```
public static DoubleBinding nextAfter(ObservableDoubleValue start,
                                      ObservableDoubleValue direction)
```
    Binding for Math.nextAfter(double, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextAfter
```
public static DoubleBinding nextAfter(double start,
                                      ObservableDoubleValue direction)
```
    Binding for Math.nextAfter(double, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextAfter
```
public static DoubleBinding nextAfter(ObservableDoubleValue start,
                                      double direction)
```
    Binding for Math.nextAfter(double, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextAfter
```
public static FloatBinding nextAfter(ObservableFloatValue start,
                                     ObservableFloatValue direction)
```
    Binding for Math.nextAfter(float, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextAfter
```
public static FloatBinding nextAfter(float start,
                                     ObservableFloatValue direction)
```
    Binding for Math.nextAfter(float, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextAfter
```
public static FloatBinding nextAfter(ObservableFloatValue start,
                                     float direction)
```
    Binding for Math.nextAfter(float, double)
    
    Parameters:
    
    start - starting floating-point value
    
    direction - value indicating which of start’s neighbors or start should be returned
    
    Returns:
    
    The floating-point number adjacent to start in the direction of direction.
  - nextDown
```
public static DoubleBinding nextDown(ObservableDoubleValue d)
```
    Binding for Math.nextDown(double)
    
    Parameters:
    
    d - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to negative infinity.
  - nextDown
```
public static FloatBinding nextDown(ObservableFloatValue f)
```
    Binding for Math.nextDown(float)
    
    Parameters:
    
    f - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to negative infinity.
  - nextUp
```
public static DoubleBinding nextUp(ObservableDoubleValue d)
```
    Binding for Math.nextUp(double)
    
    Parameters:
    
    d - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to positive infinity.
  - nextUp
```
public static FloatBinding nextUp(ObservableFloatValue f)
```
    Binding for Math.nextUp(float)
    
    Parameters:
    
    f - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to positive infinity.
  - pow
```
public static DoubleBinding pow(ObservableDoubleValue a,
                                ObservableDoubleValue b)
```
    Binding for Math.pow(double, double)
    
    Parameters:
    
    a - the base.
    
    b - the exponent.
    
    Returns:
    
    the value a^b.
  - pow
```
public static DoubleBinding pow(double a,
                                ObservableDoubleValue b)
```
    Binding for Math.pow(double, double)
    
    Parameters:
    
    a - the base.
    
    b - the exponent.
    
    Returns:
    
    the value a^b.
  - pow
```
public static DoubleBinding pow(ObservableDoubleValue a,
                                double b)
```
    Binding for Math.pow(double, double)
    
    Parameters:
    
    a - the base.
    
    b - the exponent.
    
    Returns:
    
    the value a^b.
  - rint
```
public static DoubleBinding rint(ObservableDoubleValue a)
```
    Binding for Math.rint(double)
    
    Parameters:
    
    a - a double value.
    
    Returns:
    
    the closest floating-point value to a that is equal to a mathematical integer.
  - round
```
public static LongBinding round(ObservableDoubleValue a)
```
    Binding for Math.round(double)
    
    Parameters:
    
    a - a floating-point value to be rounded to a long.
    
    Returns:
    
    the value of the argument rounded to the nearest long value.
  - round
```
public static IntegerBinding round(ObservableFloatValue a)
```
    Binding for Math.round(float)
    
    Parameters:
    
    a - a floating-point value to be rounded to an integer.
    
    Returns:
    
    the value of the argument rounded to the nearest int value.
  - scalb
```
public static DoubleBinding scalb(ObservableDoubleValue d,
                                  ObservableIntegerValue scaleFactor)
```
    Binding for Math.scalb(double, int)
    
    Parameters:
    
    d - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale d
    
    Returns:
    
    d × 2^scaleFactor
  - scalb
```
public static DoubleBinding scalb(double d,
                                  ObservableIntegerValue scaleFactor)
```
    Binding for Math.scalb(double, int)
    
    Parameters:
    
    d - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale d
    
    Returns:
    
    d × 2^scaleFactor
  - scalb
```
public static DoubleBinding scalb(ObservableDoubleValue d,
                                  int scaleFactor)
```
    Binding for Math.scalb(double, int)
    
    Parameters:
    
    d - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale d
    
    Returns:
    
    d × 2^scaleFactor
  - scalb
```
public static FloatBinding scalb(ObservableFloatValue f,
                                 ObservableIntegerValue scaleFactor)
```
    Binding for Math.scalb(float, int)
    
    Parameters:
    
    f - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale f
    
    Returns:
    
    f × 2^scaleFactor
  - scalb
```
public static FloatBinding scalb(float f,
                                 ObservableIntegerValue scaleFactor)
```
    Binding for Math.scalb(float, int)
    
    Parameters:
    
    f - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale f
    
    Returns:
    
    f × 2^scaleFactor
  - scalb
```
public static FloatBinding scalb(ObservableFloatValue f,
                                 int scaleFactor)
```
    Binding for Math.scalb(float, int)
    
    Parameters:
    
    f - number to be scaled by a power of two.
    
    scaleFactor - power of 2 used to scale f
    
    Returns:
    
    f × 2^scaleFactor
  - signum
```
public static DoubleBinding signum(ObservableDoubleValue d)
```
    Binding for Math.signum(double)
    
    Parameters:
    
    d - the floating-point value whose signum is to be returned
    
    Returns:
    
    the signum function of the argument
  - signum
```
public static FloatBinding signum(ObservableFloatValue f)
```
    Binding for Math.signum(float)
    
    Parameters:
    
    f - the floating-point value whose signum is to be returned
    
    Returns:
    
    the signum function of the argument
  - sin
```
public static DoubleBinding sin(ObservableDoubleValue a)
```
    Binding for Math.sin(double)
    
    Parameters:
    
    a - an angle, in radians.
    
    Returns:
    
    the sine of the argument.
  - sinh
```
public static DoubleBinding sinh(ObservableDoubleValue x)
```
    Binding for Math.sinh(double)
    
    Parameters:
    
    x - The number whose hyperbolic sine is to be returned.
    
    Returns:
    
    The hyperbolic sine of x.
  - sqrt
```
public static DoubleBinding sqrt(ObservableDoubleValue a)
```
    Binding for Math.sqrt(double)
    
    Parameters:
    
    a - a value.
    
    Returns:
    
    the positive square root of a. If the argument is NaN or less than zero, the result is NaN.
  - subtractExact
```
public static IntegerBinding subtractExact(ObservableIntegerValue x,
                                           ObservableIntegerValue y)
```
    Binding for Math.subtractExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - subtractExact
```
public static IntegerBinding subtractExact(int x,
                                           ObservableIntegerValue y)
```
    Binding for Math.subtractExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - subtractExact
```
public static IntegerBinding subtractExact(ObservableIntegerValue x,
                                           int y)
```
    Binding for Math.subtractExact(int, int)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
  - subtractExact
```
public static LongBinding subtractExact(ObservableLongValue x,
                                        ObservableLongValue y)
```
    Binding for Math.subtractExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - subtractExact
```
public static LongBinding subtractExact(long x,
                                        ObservableLongValue y)
```
    Binding for Math.subtractExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - subtractExact
```
public static LongBinding subtractExact(ObservableLongValue x,
                                        long y)
```
    Binding for Math.subtractExact(long, long)
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
  - tan
```
public static DoubleBinding tan(ObservableDoubleValue a)
```
    Binding for Math.tan(double)
    
    Parameters:
    
    a - an angle, in radians.
    
    Returns:
    
    the tangent of the argument.
  - tanh
```
public static DoubleBinding tanh(ObservableDoubleValue x)
```
    Binding for Math.tanh(double)
    
    Parameters:
    
    x - The number whose hyperbolic tangent is to be returned.
    
    Returns:
    
    The hyperbolic tangent of x.
  - toDegrees
```
public static DoubleBinding toDegrees(ObservableDoubleValue angrad)
```
    Binding for Math.toDegrees(double)
    
    Parameters:
    
    angrad - an angle, in radians
    
    Returns:
    
    the measurement of the angle angrad in degrees.
  - toIntExact
```
public static IntegerBinding toIntExact(ObservableLongValue value)
```
    Binding for Math.toIntExact(long)
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as an int
    
    Throws:
    
    ArithmeticException - if the argument overflows an int
  - toRadians
```
public static DoubleBinding toRadians(ObservableDoubleValue angdeg)
```
    Binding for Math.toRadians(double)
    
    Parameters:
    
    angdeg - an angle, in degrees
    
    Returns:
    
    the measurement of the angle angdeg in radians.
  - ulp
```
public static DoubleBinding ulp(ObservableDoubleValue d)
```
    Binding for Math.ulp(double)
    
    Parameters:
    
    d - the floating-point value whose ulp is to be returned
    
    Returns:
    
    the size of an ulp of the argument
  - ulp
```
public static FloatBinding ulp(ObservableFloatValue f)
```
    Binding for Math.ulp(float)
    
    Parameters:
    
    f - the floating-point value whose ulp is to be returned
    
    Returns:
    
    the size of an ulp of the argument

Class MathBindings

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

MathBindings

Method Detail

abs

abs

abs

abs

addExact

addExact

addExact

addExact

addExact

addExact

acos

asin

atan

atan2

atan2

atan2

cbrt

ceil

copySign

copySign

copySign

copySign

copySign

copySign

cos

cosh

decrementExact

decrementExact

exp

expm1

floor

floorDiv

floorDiv

floorDiv

floorDiv

floorDiv

floorDiv

floorMod

floorMod

floorMod

floorMod

floorMod

floorMod

getExponent

getExponent

hypot

hypot

hypot

IEEEremainder

IEEEremainder

IEEEremainder

incrementExact

incrementExact

log

log10

log1p

max

max

max

max

max

max

max

max

max

max

max

max

min

min

min

min

min