FXGLMath (fxgl-base 0.5.0 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. Some functions also come from jbox2d.

Author:

Nathan Sweet, Almas Baimagambetov (AlmasB) ([email protected])

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`E`
`static double`	`EPSILON` A "close to zero" double epsilon value for use.
`static double`	`HALF_PI`
`static double`	`PI`
`static double`	`PI2`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`abs(double value)`
`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 double`	`atan2Deg(double y, double 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(double value)`
`static int`	`ceilPositive(double 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 double`	`cos(double radians)`
`static double`	`cosDeg(double degrees)`
`static int`	`floor(double value)`
`static int`	`floorPositive(double value)` Note: this method simply casts the double to int.
`static Random`	`getRandom()`
`static Random`	`getRandom(long seed)`
`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`	`isClose(double a, double b, double tolerance)` Note: prone to floating point errors if the arguments are not doubles.
`static boolean`	`isCloseToZero(double value, double tolerance)` Note: prone to floating point errors if the arguments are not doubles.
`static boolean`	`isPowerOfTwo(int value)`
`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 double`	`lerpAngle(double fromRadians, double toRadians, double progress)` Linearly interpolates between two angles in radians.
`static double`	`lerpAngleDeg(double fromDegrees, double toDegrees, double progress)` Linearly interpolates between two angles in degrees.
`static double`	`log(double base, double value)`
`static double`	`log2(double 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 double`	`max(double a, double b)`
`static double`	`min(double a, double b)`
`static int`	`nextPowerOfTwo(int value)`
`static double`	`noise1D(double t)`
`static double`	`noise2D(double x, double y)` A typical usage would be to pass 2d coordinates multiplied by a frequency (lower frequency -> smoother output) value, like: double noise = noise2D(x * freq, y * freq)
`static double`	`pow(double a, double b)`
`static double`	`random()`
`static double`	`random(double range)`
`static double`	`random(double start, double end)`
`static int`	`random(int range)`
`static int`	`random(int start, int end)`
`static <T> Optional<T>`	`random(List<T> list)`
`static long`	`random(long range)`
`static long`	`random(long start, long end)`
`static <T> Optional<T>`	`random(T[] array)`
`static boolean`	`randomBoolean()`
`static boolean`	`randomBoolean(double chance)`
`static javafx.scene.paint.Color`	`randomColor()`
`static float`	`randomFloat()`
`static javafx.geometry.Point2D`	`randomPoint(javafx.geometry.Rectangle2D bounds)`
`static javafx.geometry.Point2D`	`randomPoint2D()`
`static int`	`randomSign()`
`static double`	`randomTriangular()` This is an optimized version of `randomTriangular(-1, 1, 0)`.
`static double`	`randomTriangular(double max)` This is an optimized version of `randomTriangular(-max, max, 0)`.
`static double`	`randomTriangular(double min, double max)` This method is equivalent of `randomTriangular(min, max, (min + max) * .5f)`.
`static double`	`randomTriangular(double min, double max, double mode)`
`static Vec2`	`randomVec2()`
`static int`	`round(double value)`
`static int`	`roundPositive(double value)`
`static double`	`sin(double radians)`
`static double`	`sinDeg(double degrees)`
`static double`	`sqrt(double x)`
`static double`	`toDegrees(double radians)`
`static double`	`toRadians(double degrees)`

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

- Field Detail
  - EPSILON
```
public static final double EPSILON
```
    A "close to zero" double epsilon value for use.
    
    See Also:
    
    Constant Field Values
  - PI
```
public static final double PI
```
    See Also:
    
    Constant Field Values
  - PI2
```
public static final double PI2
```
    See Also:
    
    Constant Field Values
  - HALF_PI
```
public static final double HALF_PI
```
    See Also:
    
    Constant Field Values
  - E
```
public static final double E
```
    See Also:
    
    Constant Field Values
- Method Detail
  - sin
```
public static double sin(double radians)
```
    Parameters:
    
    radians - angle in radians
    
    Returns:
    
    the sine in radians from a lookup table
  - cos
```
public static double cos(double radians)
```
    Parameters:
    
    radians - angle in radians
    
    Returns:
    
    the cosine in radians from a lookup table
  - sinDeg
```
public static double sinDeg(double degrees)
```
    Parameters:
    
    degrees - angle in degrees
    
    Returns:
    
    the sine in radians from a lookup table
  - cosDeg
```
public static double cosDeg(double degrees)
```
    Parameters:
    
    degrees - angle in degrees
    
    Returns:
    
    the cosine in radians from a lookup table
  - toDegrees
```
public static double toDegrees(double radians)
```
  - toRadians
```
public static double toRadians(double degrees)
```
  - 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
  - atan2Deg
```
public static double atan2Deg(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 degrees, faster but less accurate than Math.atan2
  - getRandom
```
public static Random getRandom()
```
    Returns:
    
    random object used to generate random sequences
  - getRandom
```
public static Random getRandom(long seed)
```
    Returns:
    
    object used to generate random sequences using given seed
  - 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(double 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 double random()
```
    Returns:
    
    random number between 0.0 (inclusive) and 1.0 (exclusive)
  - randomFloat
```
public static float randomFloat()
```
    Returns:
    
    random number between 0.0 (inclusive) and 1.0 (exclusive)
  - random
```
public static double random(double range)
```
    Parameters:
    
    range - end exclusive value
    
    Returns:
    
    a random number between 0 (inclusive) and the specified value (exclusive)
  - random
```
public static double random(double start,
                            double 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 double 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 double randomTriangular(double 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 double randomTriangular(double min,
                                      double 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 double randomTriangular(double min,
                                      double max,
                                      double 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
  - randomPoint
```
public static javafx.geometry.Point2D randomPoint(javafx.geometry.Rectangle2D bounds)
```
    Returns:
    
    random point within given bounds (minX <= x < maxX, minY <= y < maxY)
  - 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> Optional<T> random(T[] array)
```
    Returns:
    
    random element of the given array or Optional.empty() if empty
  - random
```
public static <T> Optional<T> random(List<T> list)
```
    Returns:
    
    random element of the given list or Optional.empty() if empty
  - sqrt
```
public static double sqrt(double 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 double clamp(double value,
                           double min,
                           double max)
```
  - clamp
```
public static float clamp(float value,
                          float min,
                          float 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 double lerpAngle(double fromRadians,
                               double toRadians,
                               double 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 double lerpAngleDeg(double fromDegrees,
                                  double toDegrees,
                                  double 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)
```
  - abs
```
public static double abs(double value)
```
  - min
```
public static double min(double a,
                         double b)
```
  - max
```
public static double max(double a,
                         double b)
```
  - floor
```
public static int floor(double value)
```
    Parameters:
    
    value - from -(2^14) to (double.MAX_VALUE - 2^14)
    
    Returns:
    
    the largest integer less than or equal to the specified double
  - floorPositive
```
public static int floorPositive(double value)
```
    Note: this method simply casts the double to int.
    
    Parameters:
    
    value - a positive value
    
    Returns:
    
    the largest integer less than or equal to the specified double
  - ceil
```
public static int ceil(double value)
```
    Parameters:
    
    value - from -(2^14) to (double.MAX_VALUE - 2^14)
    
    Returns:
    
    the smallest integer greater than or equal to the specified double
  - ceilPositive
```
public static int ceilPositive(double value)
```
    Parameters:
    
    value - a positive double
    
    Returns:
    
    the smallest integer greater than or equal to the specified double
  - round
```
public static int round(double value)
```
    Parameters:
    
    value - from -(2^14) to (double.MAX_VALUE - 2^14)
    
    Returns:
    
    the closest integer to the specified double
  - roundPositive
```
public static int roundPositive(double value)
```
    Parameters:
    
    value - a positive double
    
    Returns:
    
    the closest integer to the specified double
  - isCloseToZero
```
public static boolean isCloseToZero(double value,
                                    double tolerance)
```
    Note: prone to floating point errors if the arguments are not doubles.
    
    Parameters:
    
    value - the value to check
    
    tolerance - represent an upper bound below which the value is considered zero
    
    Returns:
    
    true if the value is close to zero, i.e. true if difference between value and 0 is less than or equal to tolerance
  - isClose
```
public static boolean isClose(double a,
                              double b,
                              double tolerance)
```
    Note: prone to floating point errors if the arguments are not doubles.
    
    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, i.e. true if difference between a and b is less than or equal to tolerance
  - pow
```
public static double pow(double a,
                         double b)
```
    Returns:
    
    a to the power of b
  - log
```
public static double log(double base,
                         double value)
```
    Parameters:
    
    base - the base
    
    value - the value
    
    Returns:
    
    the logarithm of value with given base
  - log2
```
public static double log2(double 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 double noise1D(double t)
```
    Parameters:
    
    t - current time * frequency (lower frequency -> smoother output)
    
    Returns:
    
    perlin noise in 1D quality in [0..1)
  - noise2D
```
public static double noise2D(double x,
                             double y)
```
    A typical usage would be to pass 2d coordinates multiplied by a frequency (lower frequency -> smoother output) value, like: double noise = noise2D(x * freq, y * freq)
    
    Returns:
    
    perlin noise in 2D quality in [0..1)
    
    Implementation Note:
    
    twice slower than noise1D

Class FXGLMath

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EPSILON

PI

PI2

HALF_PI

E

Method Detail

sin

cos

sinDeg

cosDeg

toDegrees

toRadians

atan2

atan2Deg

getRandom

getRandom

random

random

random

random

randomBoolean

randomBoolean

random

randomFloat

random

random

randomSign

randomTriangular

randomTriangular

randomTriangular

randomTriangular

randomPoint

randomVec2

randomPoint2D

randomColor

random

random

sqrt

nextPowerOfTwo

isPowerOfTwo

clamp

clamp

clamp

clamp

clamp

map

lerp

lerp

interpolate

interpolate

lerpAngle

lerpAngleDeg

abs

abs

min

max

floor

floorPositive

ceil

ceilPositive

round

roundPositive

isCloseToZero

isClose

pow

log

log2

bezier

bezier

closedBezierSpline

noise1D

noise2D