FXGLMath (fxgl 0.3.7 API)

java.lang.Object
- com.almasb.fxgl.core.math.FXGLMath

```
public final class FXGLMath
extends Object
```
Utility and fast math functions. Thanks to Riven on JavaGaming.org for the basis of sin/cos/floor/ceil.

Author:

Nathan Sweet, Almas Baimagambetov (AlmasB) (almaslvl@gmail.com)

Field Summary

Fields
Modifier and Type	Field and Description
`static float`	`degRad`
`static float`	`degreesToRadians` multiply by this to convert from degrees to radians
`static float`	`E`
`static float`	`EPSILON` A "close to zero" float epsilon value for use.
`static float`	`FLOAT_ROUNDING_ERROR`
`static float`	`nanoToSec`
`static float`	`PI`
`static float`	`PI2`
`static float`	`radDeg`
`static float`	`radiansToDegrees` multiply by this to convert from radians to degrees

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static float`	`abs(float value)`
`static double`	`atan2(double y, double x)` Average error of 0.00231 radians (0.1323 degrees), largest error of 0.00488 radians (0.2796 degrees).
`static float`	`atan2(float y, float x)` Average error of 0.00231 radians (0.1323 degrees), largest error of 0.00488 radians (0.2796 degrees).
`static javafx.geometry.Point2D`	`bezier(javafx.geometry.Point2D p1, javafx.geometry.Point2D p2, javafx.geometry.Point2D p3, double t)`
`static javafx.geometry.Point2D`	`bezier(javafx.geometry.Point2D p1, javafx.geometry.Point2D p2, javafx.geometry.Point2D p3, javafx.geometry.Point2D p4, double t)`
`static int`	`ceil(float value)`
`static int`	`ceilPositive(float value)`
`static double`	`clamp(double value, double min, double max)`
`static float`	`clamp(float value, float min, float max)`
`static int`	`clamp(int value, int min, int max)`
`static long`	`clamp(long value, long min, long max)`
`static short`	`clamp(short value, short min, short max)`
`static BezierSpline`	`closedBezierSpline(Vec2[] points)`
`static float`	`cos(float radians)`
`static float`	`cosDeg(float degrees)`
`static int`	`floor(float value)`
`static int`	`floorPositive(float value)` Note: this method simply casts the float to int.
`static Random`	`getRandom()`
`static double`	`interpolate(double fromValue, double toValue, double progress, javafx.animation.Interpolator interpolator)`
`static javafx.geometry.Point2D`	`interpolate(javafx.geometry.Point2D fromValue, javafx.geometry.Point2D toValue, double progress, javafx.animation.Interpolator interpolator)`
`static boolean`	`isEqual(float a, float b)`
`static boolean`	`isEqual(float a, float b, float tolerance)`
`static boolean`	`isPowerOfTwo(int value)`
`static boolean`	`isZero(float value)`
`static boolean`	`isZero(float value, float tolerance)`
`static double`	`lerp(double fromValue, double toValue, double progress)`
`static javafx.geometry.Point2D`	`lerp(double fromX, double fromY, double toX, double toY, double progress)`
`static float`	`lerpAngle(float fromRadians, float toRadians, float progress)` Linearly interpolates between two angles in radians.
`static float`	`lerpAngleDeg(float fromDegrees, float toDegrees, float progress)` Linearly interpolates between two angles in degrees.
`static float`	`log(float base, float value)`
`static float`	`log2(float value)`
`static double`	`map(double value, double currentRangeStart, double currentRangeStop, double targetRangeStart, double targetRangeStop)` Map value of a given range to a target range.
`static int`	`nextPowerOfTwo(int value)`
`static float`	`noise1D(double t)`
`static float`	`random()`
`static float`	`random(float range)`
`static float`	`random(float start, float end)`
`static int`	`random(int range)`
`static int`	`random(int start, int end)`
`static <T> T`	`random(List<T> list)`
`static long`	`random(long range)`
`static long`	`random(long start, long end)`
`static <T> T`	`random(T[] array)`
`static boolean`	`randomBoolean()`
`static boolean`	`randomBoolean(float chance)`
`static javafx.scene.paint.Color`	`randomColor()`
`static javafx.geometry.Point2D`	`randomPoint2D()`
`static int`	`randomSign()`
`static float`	`randomTriangular()` This is an optimized version of `randomTriangular(-1, 1, 0)`.
`static float`	`randomTriangular(float max)` This is an optimized version of `randomTriangular(-max, max, 0)`.
`static float`	`randomTriangular(float min, float max)` This method is equivalent of `randomTriangular(min, max, (min + max) * .5f)`.
`static float`	`randomTriangular(float min, float max, float mode)`
`static Vec2`	`randomVec2()`
`static int`	`round(float value)`
`static int`	`roundPositive(float value)`
`static float`	`sin(float radians)`
`static float`	`sinDeg(float degrees)`
`static float`	`sqrt(float x)`

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

- Field Detail
  - nanoToSec
```
public static final float nanoToSec
```
    See Also:
    
    Constant Field Values
  - EPSILON
```
public static final float EPSILON
```
    A "close to zero" float epsilon value for use.
    
    See Also:
    
    Constant Field Values
  - FLOAT_ROUNDING_ERROR
```
public static final float FLOAT_ROUNDING_ERROR
```
    See Also:
    
    Constant Field Values
  - PI
```
public static final float PI
```
    See Also:
    
    Constant Field Values
  - PI2
```
public static final float PI2
```
    See Also:
    
    Constant Field Values
  - E
```
public static final float E
```
    See Also:
    
    Constant Field Values
  - radiansToDegrees
```
public static final float radiansToDegrees
```
    multiply by this to convert from radians to degrees
    
    See Also:
    
    Constant Field Values
  - radDeg
```
public static final float radDeg
```
    See Also:
    
    Constant Field Values
  - degreesToRadians
```
public static final float degreesToRadians
```
    multiply by this to convert from degrees to radians
    
    See Also:
    
    Constant Field Values
  - degRad
```
public static final float degRad
```
    See Also:
    
    Constant Field Values
- Method Detail
  - sin
```
public static float sin(float radians)
```
    Parameters:
    
    radians - angle in radians
    
    Returns:
    
    the sine in radians from a lookup table
  - cos
```
public static float cos(float radians)
```
    Parameters:
    
    radians - angle in radians
    
    Returns:
    
    the cosine in radians from a lookup table
  - sinDeg
```
public static float sinDeg(float degrees)
```
    Parameters:
    
    degrees - angle in degrees
    
    Returns:
    
    the sine in radians from a lookup table
  - cosDeg
```
public static float cosDeg(float degrees)
```
    Parameters:
    
    degrees - angle in degrees
    
    Returns:
    
    the cosine in radians from a lookup table
  - atan2
```
public static float atan2(float y,
                          float x)
```
    Average error of 0.00231 radians (0.1323 degrees), largest error of 0.00488 radians (0.2796 degrees).
    
    Parameters:
    
    y - y component
    
    x - x component
    
    Returns:
    
    atan2 in radians, faster but less accurate than Math.atan2.
  - atan2
```
public static double atan2(double y,
                           double x)
```
    Average error of 0.00231 radians (0.1323 degrees), largest error of 0.00488 radians (0.2796 degrees).
    
    Parameters:
    
    y - y component
    
    x - x component
    
    Returns:
    
    atan2 in radians, faster but less accurate than Math.atan2.
  - getRandom
```
public static Random getRandom()
```
    Returns:
    
    random object used to generate random sequences
  - random
```
public static int random(int range)
```
    Parameters:
    
    range - the end inclusive value
    
    Returns:
    
    a random number between 0 (inclusive) and the specified value (inclusive)
  - random
```
public static int random(int start,
                         int end)
```
    Parameters:
    
    start - start value
    
    end - end value
    
    Returns:
    
    a random number between start (inclusive) and end (inclusive)
  - random
```
public static long random(long range)
```
    Parameters:
    
    range - the end inclusive value
    
    Returns:
    
    a random number between 0 (inclusive) and the specified value (inclusive)
  - random
```
public static long random(long start,
                          long end)
```
    Parameters:
    
    start - start value
    
    end - end value
    
    Returns:
    
    a random number between start (inclusive) and end (inclusive)
  - randomBoolean
```
public static boolean randomBoolean()
```
    Returns:
    
    random boolean value
  - randomBoolean
```
public static boolean randomBoolean(float chance)
```
    Parameters:
    
    chance - chance to check
    
    Returns:
    
    true if a random value between 0 and 1 is less than the specified value
  - random
```
public static float random()
```
    Returns:
    
    random number between 0.0 (inclusive) and 1.0 (exclusive)
  - random
```
public static float random(float range)
```
    Parameters:
    
    range - end exclusive value
    
    Returns:
    
    a random number between 0 (inclusive) and the specified value (exclusive)
  - random
```
public static float random(float start,
                           float end)
```
    Parameters:
    
    start - start inclusive value
    
    end - end exclusive value
    
    Returns:
    
    a random number between start (inclusive) and end (exclusive)
  - randomSign
```
public static int randomSign()
```
    Returns:
    
    random sign, either -1 or 1
  - randomTriangular
```
public static float randomTriangular()
```
    This is an optimized version of randomTriangular(-1, 1, 0).
    
    Returns:
    
    a triangularly distributed random number between -1.0 (exclusive) and 1.0 (exclusive), where values around zero are more likely
  - randomTriangular
```
public static float randomTriangular(float max)
```
    This is an optimized version of randomTriangular(-max, max, 0).
    
    Parameters:
    
    max - the upper limit
    
    Returns:
    
    a triangularly distributed random number between -max (exclusive) and max (exclusive), where values around zero are more likely
  - randomTriangular
```
public static float randomTriangular(float min,
                                     float max)
```
    This method is equivalent of randomTriangular(min, max, (min + max) * .5f).
    
    Parameters:
    
    min - the lower limit
    
    max - the upper limit
    
    Returns:
    
    a triangularly distributed random number between min (inclusive) and max (exclusive), where the mode argument defaults to the midpoint between the bounds, giving a symmetric distribution
  - randomTriangular
```
public static float randomTriangular(float min,
                                     float max,
                                     float mode)
```
    Parameters:
    
    min - the lower limit
    
    max - the upper limit
    
    mode - the point around which the values are more likely
    
    Returns:
    
    a triangularly distributed random number between min (inclusive) and max (exclusive), where values around mode are more likely
  - randomVec2
```
public static Vec2 randomVec2()
```
    Returns:
    
    new random vector of unit length as Vec2
  - randomPoint2D
```
public static javafx.geometry.Point2D randomPoint2D()
```
    Returns:
    
    new random vector of unit length as Point2D
  - randomColor
```
public static javafx.scene.paint.Color randomColor()
```
  - random
```
public static <T> T random(T[] array)
```
    Returns:
    
    random element of the given array
  - random
```
public static <T> T random(List<T> list)
```
    Returns:
    
    random element of the given list
  - sqrt
```
public static float sqrt(float x)
```
  - nextPowerOfTwo
```
public static int nextPowerOfTwo(int value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    the next power of two, or the specified value if the value is already a power of two
  - isPowerOfTwo
```
public static boolean isPowerOfTwo(int value)
```
    Parameters:
    
    value - the value to check
    
    Returns:
    
    true if the value is a power of two
  - clamp
```
public static short clamp(short value,
                          short min,
                          short max)
```
  - clamp
```
public static int clamp(int value,
                        int min,
                        int max)
```
  - clamp
```
public static long clamp(long value,
                         long min,
                         long max)
```
  - clamp
```
public static float clamp(float value,
                          float min,
                          float max)
```
  - clamp
```
public static double clamp(double value,
                           double min,
                           double max)
```
  - map
```
public static double map(double value,
                         double currentRangeStart,
                         double currentRangeStop,
                         double targetRangeStart,
                         double targetRangeStop)
```
    Map value of a given range to a target range.
    
    Parameters:
    
    value - the value to map
    
    Returns:
    
    mapped value
  - lerp
```
public static double lerp(double fromValue,
                          double toValue,
                          double progress)
```
    Parameters:
    
    fromValue - start value
    
    toValue - end value
    
    progress - the interpolation progress [0..1]
    
    Returns:
    
    linearly interpolated value between fromValue to toValue based on progress position
  - lerp
```
public static javafx.geometry.Point2D lerp(double fromX,
                                           double fromY,
                                           double toX,
                                           double toY,
                                           double progress)
```
  - interpolate
```
public static double interpolate(double fromValue,
                                 double toValue,
                                 double progress,
                                 javafx.animation.Interpolator interpolator)
```
  - interpolate
```
public static javafx.geometry.Point2D interpolate(javafx.geometry.Point2D fromValue,
                                                  javafx.geometry.Point2D toValue,
                                                  double progress,
                                                  javafx.animation.Interpolator interpolator)
```
  - lerpAngle
```
public static float lerpAngle(float fromRadians,
                              float toRadians,
                              float progress)
```
    Linearly interpolates between two angles in radians. Takes into account that angles wrap at two pi and always takes the direction with the smallest delta angle.
    
    Parameters:
    
    fromRadians - start angle in radians
    
    toRadians - target angle in radians
    
    progress - interpolation value in the range [0, 1]
    
    Returns:
    
    the interpolated angle in the range [0, PI2[
  - lerpAngleDeg
```
public static float lerpAngleDeg(float fromDegrees,
                                 float toDegrees,
                                 float progress)
```
    Linearly interpolates between two angles in degrees. Takes into account that angles wrap at 360 degrees and always takes the direction with the smallest delta angle.
    
    Parameters:
    
    fromDegrees - start angle in degrees
    
    toDegrees - target angle in degrees
    
    progress - interpolation value in the range [0, 1]
    
    Returns:
    
    the interpolated angle in the range [0, 360[
  - abs
```
public static float abs(float value)
```
  - floor
```
public static int floor(float value)
```
    Parameters:
    
    value - from -(2^14) to (Float.MAX_VALUE - 2^14)
    
    Returns:
    
    the largest integer less than or equal to the specified float
  - floorPositive
```
public static int floorPositive(float value)
```
    Note: this method simply casts the float to int.
    
    Parameters:
    
    value - a positive value
    
    Returns:
    
    the largest integer less than or equal to the specified float
  - ceil
```
public static int ceil(float value)
```
    Parameters:
    
    value - from -(2^14) to (Float.MAX_VALUE - 2^14)
    
    Returns:
    
    the smallest integer greater than or equal to the specified float
  - ceilPositive
```
public static int ceilPositive(float value)
```
    Parameters:
    
    value - a positive float
    
    Returns:
    
    the smallest integer greater than or equal to the specified float
  - round
```
public static int round(float value)
```
    Parameters:
    
    value - from -(2^14) to (Float.MAX_VALUE - 2^14)
    
    Returns:
    
    the closest integer to the specified float
  - roundPositive
```
public static int roundPositive(float value)
```
    Parameters:
    
    value - a positive float
    
    Returns:
    
    the closest integer to the specified float
  - isZero
```
public static boolean isZero(float value)
```
    Parameters:
    
    value - the value to check
    
    Returns:
    
    true if the value is zero (using the default tolerance as upper bound)
  - isZero
```
public static boolean isZero(float value,
                             float tolerance)
```
    Parameters:
    
    value - the value to check
    
    tolerance - represent an upper bound below which the value is considered zero
    
    Returns:
    
    true if the value is zero
  - isEqual
```
public static boolean isEqual(float a,
                              float b)
```
    Parameters:
    
    a - the first value
    
    b - the second value
    
    Returns:
    
    true if a is nearly equal to b (using the default error tolerance)
  - isEqual
```
public static boolean isEqual(float a,
                              float b,
                              float tolerance)
```
    Parameters:
    
    a - the first value
    
    b - the second value
    
    tolerance - represent an upper bound below which the two values are considered equal
    
    Returns:
    
    true if a is nearly equal to b
  - log
```
public static float log(float base,
                        float value)
```
    Parameters:
    
    base - the base
    
    value - the value
    
    Returns:
    
    the logarithm of value with given base
  - log2
```
public static float log2(float value)
```
    Parameters:
    
    value - the value
    
    Returns:
    
    the logarithm of value with base 2
  - bezier
```
public static javafx.geometry.Point2D bezier(javafx.geometry.Point2D p1,
                                             javafx.geometry.Point2D p2,
                                             javafx.geometry.Point2D p3,
                                             double t)
```
  - bezier
```
public static javafx.geometry.Point2D bezier(javafx.geometry.Point2D p1,
                                             javafx.geometry.Point2D p2,
                                             javafx.geometry.Point2D p3,
                                             javafx.geometry.Point2D p4,
                                             double t)
```
  - closedBezierSpline
```
public static BezierSpline closedBezierSpline(Vec2[] points)
```
    Parameters:
    
    points - the spline passes through these points
    
    Returns:
    
    a closed bezier spline
  - noise1D
```
public static float noise1D(double t)
```
    Parameters:
    
    t - current time * frequency (lower frequency -> smoother output)
    
    Returns:
    
    perlin noise in 1D quality in [0..1)

Class FXGLMath

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

nanoToSec

EPSILON

FLOAT_ROUNDING_ERROR

PI

PI2

E

radiansToDegrees

radDeg

degreesToRadians

degRad

Method Detail

sin

cos

sinDeg

cosDeg

atan2

atan2

getRandom

random

random

random

random

randomBoolean

randomBoolean

random

random

random

randomSign

randomTriangular

randomTriangular

randomTriangular

randomTriangular

randomVec2

randomPoint2D

randomColor

random

random

sqrt

nextPowerOfTwo

isPowerOfTwo

clamp

clamp

clamp

clamp

clamp

map

lerp

lerp

interpolate

interpolate

lerpAngle

lerpAngleDeg

abs

floor

floorPositive

ceil

ceilPositive

round

roundPositive

isZero

isZero

isEqual

isEqual

log

log2

bezier

bezier

closedBezierSpline

noise1D