Package jme3utilities.math

Class MyMath

java.lang.Object

jme3utilities.math.MyMath

public final class MyMath
extends Object

Mathematical utility methods.

Field Summary

Fields

Modifier and Type	Field	Description
static final double	halfPi	Pi/2
static final Logger	logger	message logger for this class
static final float	phi	golden ratio = 1.618...
static final float	root2	square root of 2
static final float	rootHalf	square root of 1/2

Method Summary

Modifier and Type	Method	Description
static double	area(com.jme3.math.Triangle triangle)	Return the area of the specified triangle.
static boolean	areWithinTolerance(float a, float b, float relativeTolerance)	Test whether 2 float values are within the specified relative tolerance of one another.
static double	circle(double abscissa)	Return the circle function sqrt(1 - x^2) for a double-precision value.
static float	circle(float abscissa)	Return the circle function sqrt(1 - x^2) for a single-precision value.
static double	clamp(double dValue, double maxMagnitude)	Clamp the magnitude of a double-precision value.
static double	clamp(double dValue, double min, double max)	Clamp a double-precision value between 2 limits.
static float	clamp(float fValue, float maxMagnitude)	Clamp the magnitude of a single-precision value.
static int	clamp(int iValue, int min, int max)	Clamp an integer value between 2 limits.
static com.jme3.math.Transform	combine(com.jme3.math.Transform child, com.jme3.math.Transform parent, com.jme3.math.Transform storeResult)	Combine the specified transforms.
static float	cube(float fValue)	Cube the specified single-precision value.
static float	cubeRoot(float fValue)	Extract the cube root of a single-precision value.
static double	discriminant(double a, double b, double c)	Return the discriminant (b^2 - 4*a*c) of a quadratic equation in standard form (a*x^2 + b*x + c) == 0.
static float	easeInQuartic(float time, float start, float end, float duration)	Quartic easing function for animation: slow at the start, fast at the end.
static float	easeOutQuartic(float time, float start, float end, float duration)	Quartic easing function for animation: fast at the start, slow at the end.
static float	fade(float t)	Fade polynomial for Perlin noise.
static double	fourthRoot(double dValue)	Extract the 4th root of a double-precision value.
static com.jme3.math.Matrix3f	fromAngles(float xAngle, float yAngle, float zAngle, com.jme3.math.Matrix3f storeResult)	Sets a rotation matrix from the specified Tait-Bryan angles, applying the rotations in x-z-y extrinsic order or y-z'-x" intrinsic order.
static float	hypotenuse(float... fValues)	Return the root sum of squares of some single-precision values.
static double	hypotenuseDouble(double... dValues)	Return the root sum of squares of some double-precision values.
static boolean	isBetween(double a, double b, double c)	Test whether b is between a and c.
static boolean	isBetween(float a, float b, float c)	Test whether b is between a and c.
static boolean	isBetween(int a, int b, int c)	Test whether b is between a and c.
static boolean	isIdentity(com.jme3.math.Transform transform)	Test the specified transform for exact identity.
static boolean	isOdd(int iValue)	Test whether an integer value is odd.
static float	lerp(float t, float y0, float y1)	Interpolate linearly between (or extrapolate linearly from) 2 single-precision values.
static float	lerp3(float t1, float t2, float y0, float y1, float y2)	Interpolate linearly between (or extrapolate linearly from) 3 single-precision values.
static int	log2(int iValue)	Calculate the floor of the base-2 logarithm of the input value.
static float	max(float... fValues)	Find the maximum of some single-precision values.
static double	maxDouble(double... dValues)	Find the maximum of some double-precision values.
static int	maxInt(int... iValues)	Find the maximum of some int values.
static double	mid(double a, double b, double c)	Find the median of 3 double-precision values.
static float	mid(float a, float b, float c)	Find the median of 3 single-precision values.
static float	min(float... fValues)	Find the minimum of some single-precision values.
static double	minDouble(double... dValues)	Find the minimum of some double-precision values.
static double	modulo(double dValue, double modulus)	Return the least non-negative value congruent with the input value with respect to the specified modulus.
static float	modulo(float fValue, float modulus)	Return the least non-negative value congruent with the input value with respect to the specified modulus.
static int	modulo(int iValue, int modulus)	Return the least non-negative value congruent with the input value with respect to the specified modulus.
static com.jme3.math.Transform	slerp(float t, com.jme3.math.Transform t0, com.jme3.math.Transform t1, com.jme3.math.Transform storeResult)	Interpolate between 2 transforms using spherical linear (Slerp) interpolation.
static double	sqr(double dValue)	Square the specified double-precision value.
static float	standardize(float fValue)	Standardize a single-precision value in preparation for hashing.
static float	standardizeAngle(float angle)	Standardize a rotation angle to the range [-Pi, Pi).
static double	sumOfSquares(float... fValues)	Return the sum of squares of some single-precision values.
static float	toDegrees(float radians)	Convert an angle from radians to degrees.
static float	toRadians(float degrees)	Convert an angle from degrees to radians.
static com.jme3.math.Vector3f	transform(com.jme3.math.Transform transform, com.jme3.math.Vector3f input, com.jme3.math.Vector3f storeResult)	Apply the specified transform to a Vector3f.
static com.jme3.math.Triangle	transformInverse(com.jme3.math.Transform transform, com.jme3.math.Triangle input, com.jme3.math.Triangle storeResult)	Apply the inverse of the specified transform to each vertex of a Triangle.
static com.jme3.math.Vector3f	transformInverse(com.jme3.math.Transform transform, com.jme3.math.Vector3f input, com.jme3.math.Vector3f storeResult)	Apply the inverse of the specified transform to a Vector3f.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

halfPi

public static final double halfPi

Pi/2

See Also:

• FastMath.HALF_PI
• Constant Field Values

phi

public static final float phi

golden ratio = 1.618...

root2

public static final float root2

square root of 2

rootHalf

public static final float rootHalf

square root of 1/2

logger

public static final Logger logger

message logger for this class

Method Details

area

public static double area(com.jme3.math.Triangle triangle)

Return the area of the specified triangle.

Parameters:

triangle - (not null, unaffected)

Returns:

the area (≥0)

areWithinTolerance

public static boolean areWithinTolerance(float a,
 float b,
 float relativeTolerance)

Test whether 2 float values are within the specified relative tolerance of one another.

Parameters:

a - the first input value

b - the 2nd input value

relativeTolerance - the relative tolerance (≥0, 0.02 → 2 percent)

Returns:

true if a and b differ by less than relativeTolerance * max(abs(a), abs(b)), otherwise false

circle

public static double circle(double abscissa)

Return the circle function sqrt(1 - x^2) for a double-precision value.

Parameters:

abscissa - input (≤1, ≥-1)

Returns:

positive ordinate of the unit circle at the abscissa (≤1, ≥0)

circle

public static float circle(float abscissa)

Return the circle function sqrt(1 - x^2) for a single-precision value. Double-precision arithmetic is used to reduce the risk of overflow.

Parameters:

abscissa - input (≤1, ≥-1)

Returns:

positive ordinate of the unit circle at the abscissa (≤1, ≥0)

clamp

public static float clamp(float fValue,
 float maxMagnitude)

Clamp the magnitude of a single-precision value.

Parameters:

fValue - input value to be clamped

maxMagnitude - limit of the clamp (≥0)

Returns:

value between -maxMagnitude and +maxMagnitude inclusive which is closest to fValue

See Also:

• FastMath.clamp(float,float,float)

clamp

public static double clamp(double dValue,
 double maxMagnitude)

Clamp the magnitude of a double-precision value.

Parameters:

dValue - input value to be clamped

maxMagnitude - limit of the clamp (≥0)

Returns:

value between -maxMagnitude and +maxMagnitude inclusive which is closest to fValue

See Also:

• FastMath.clamp(float,float,float)

clamp

public static double clamp(double dValue,
 double min,
 double max)

Clamp a double-precision value between 2 limits.

Parameters:

dValue - input value to be clamped

min - lower limit of the clamp

max - upper limit of the clamp

Returns:

the value between min and max inclusive that is closest to fValue

See Also:

• FastMath.clamp(float,float,float)

clamp

public static int clamp(int iValue,
 int min,
 int max)

Clamp an integer value between 2 limits.

Parameters:

iValue - input value to be clamped

min - the lower limit

max - the upper limit

Returns:

the value between min and max inclusive that is closest to iValue

combine

public static com.jme3.math.Transform combine(com.jme3.math.Transform child,
 com.jme3.math.Transform parent,
 com.jme3.math.Transform storeResult)

Combine the specified transforms.

It is safe for any or all of child, parent, and storeResult to be the same object.

Unlike Transform.combineWithParent(com.jme3.math.Transform), this method works on transforms containing non-normalized quaternions.

Parameters:

child - the transform applied first (not null, unaffected unless it's storeResult)

parent - the transform applied last (not null, unaffected unless it's storeResult)

storeResult - (modified if not null)

Returns:

a Transform equivalent to child followed by parent (either storeResult or a new instance)

cube

public static float cube(float fValue)

Cube the specified single-precision value. Logs a warning in case of overflow.

Parameters:

fValue - input value to be cubed

Returns:

fValue raised to the third power

See Also:

• cubeRoot(float)
• FastMath.sqr(float)

cubeRoot

public static float cubeRoot(float fValue)

Extract the cube root of a single-precision value. Unlike FastMath.pow(float,float), this method works on negative values.

Parameters:

fValue - input cube to be extracted (may be negative)

Returns:

cube root of fValue

See Also:

• cube(float)
• FastMath.pow(float,float)
• Math.cbrt(double)

discriminant

public static double discriminant(double a,
 double b,
 double c)

Return the discriminant (b^2 - 4*a*c) of a quadratic equation in standard form (a*x^2 + b*x + c) == 0.

Parameters:

a - the coefficient of the square term

b - the coefficient of the linear term

c - the constant term

Returns:

the discriminant

easeInQuartic

public static float easeInQuartic(float time,
 float start,
 float end,
 float duration)

Quartic easing function for animation: slow at the start, fast at the end.

Parameters:

time - the elapsed time since the start of the animation (≥0, ≤duration)

start - the starting value

end - the ending value

duration - the duration of the animation (>0)

Returns:

the current value

easeOutQuartic

public static float easeOutQuartic(float time,
 float start,
 float end,
 float duration)

Quartic easing function for animation: fast at the start, slow at the end.

Parameters:

time - the elapsed time since the start of the animation (≥0, ≤duration)

start - the starting value

end - the ending value

duration - the duration of the animation (>0)

Returns:

the current value

fade

public static float fade(float t)

Fade polynomial for Perlin noise. Double-precision arithmetic is used to reduce rounding error.

Parameters:

t - input value (≤1, ≥0)

Returns:

6*t^5 - 15*t^4 + 10*t^3 (≤1, ≥0)

fourthRoot

public static double fourthRoot(double dValue)

Extract the 4th root of a double-precision value. This method is faster than Math.pow(d, 0.25).

Parameters:

dValue - input 4th power to be extracted (≥0)

Returns:

the positive 4th root of dValue (≥0)

See Also:

• Math.cbrt(double)

fromAngles

public static com.jme3.math.Matrix3f fromAngles(float xAngle,
 float yAngle,
 float zAngle,
 com.jme3.math.Matrix3f storeResult)

Sets a rotation matrix from the specified Tait-Bryan angles, applying the rotations in x-z-y extrinsic order or y-z'-x" intrinsic order.

Parameters:

xAngle - the X angle (in radians)

yAngle - the Y angle (in radians)

zAngle - the Z angle (in radians)

storeResult - storage for the result (modified if not null)

Returns:

a rotation matrix (either storeResult or a new instance)

hypotenuse

public static float hypotenuse(float... fValues)

Return the root sum of squares of some single-precision values. Double-precision arithmetic is used to reduce the risk of overflow.

Parameters:

fValues - the input values

Returns:

the positive square root of the sum of squares (≥0)

hypotenuseDouble

public static double hypotenuseDouble(double... dValues)

Return the root sum of squares of some double-precision values.

Parameters:

dValues - the input values

Returns:

the positive square root of the sum of squares (≥0)

isBetween

public static boolean isBetween(float a,
 float b,
 float c)

Test whether b is between a and c.

Parameters:

a - the first input value

b - the 2nd input value

c - the 3rd input value

Returns:

true if b is between a and c (inclusive), otherwise false

isBetween

public static boolean isBetween(int a,
 int b,
 int c)

Test whether b is between a and c.

Parameters:

a - the first input value

b - the 2nd input value

c - the 3rd input value

Returns:

true if b is between a and c (inclusive), otherwise false

isBetween

public static boolean isBetween(double a,
 double b,
 double c)

Test whether b is between a and c.

Parameters:

a - the first input value

b - the 2nd input value

c - the 3rd input value

Returns:

true if b is between a and c (inclusive), otherwise false

isIdentity

public static boolean isIdentity(com.jme3.math.Transform transform)

Test the specified transform for exact identity.

Parameters:

transform - which transform to test (not null, unaffected)

Returns:

true if exact identity, otherwise false

isOdd

public static boolean isOdd(int iValue)

Test whether an integer value is odd.

Parameters:

iValue - the value to be tested

Returns:

true if x is odd, false if it's even

lerp

public static float lerp(float t,
 float y0,
 float y1)

Interpolate linearly between (or extrapolate linearly from) 2 single-precision values.

Unlike FastMath.interpolateLinear(float, float, float), no rounding error is introduced when y0==y1.

Parameters:

t - the weight given to y1

y0 - the function value at t=0

y1 - the function value at t=1

Returns:

the interpolated function value

lerp3

public static float lerp3(float t1,
 float t2,
 float y0,
 float y1,
 float y2)

Interpolate linearly between (or extrapolate linearly from) 3 single-precision values.

Parameters:

t1 - the weight given to y1

t2 - the weight given to y2

y0 - the function value at t1=0, t2=0

y1 - the function value at t1=1, t2=0

y2 - the function value at t1=0, t2=1

Returns:

the interpolated function value

log2

public static int log2(int iValue)

Calculate the floor of the base-2 logarithm of the input value.

Parameters:

iValue - the input value (≥1)

Returns:

the largest integer N≤30 for which (1 << N) <= iValue (≥0, ≤30)

max

public static float max(float... fValues)

Find the maximum of some single-precision values.

Parameters:

fValues - the input values

Returns:

the most positive value

See Also:

• Math.max(float, float)

maxDouble

public static double maxDouble(double... dValues)

Find the maximum of some double-precision values.

Parameters:

dValues - the input values

Returns:

the most positive value

See Also:

• Math.max(double, double)

maxInt

public static int maxInt(int... iValues)

Find the maximum of some int values.

Parameters:

iValues - the input values

Returns:

the most positive value

See Also:

• Collections.max(java.util.Collection)
• Math.max(int, int)

mid

public static float mid(float a,
 float b,
 float c)

Find the median of 3 single-precision values.

Parameters:

a - the first input value

b - the 2nd input value

c - the 3rd input value

Returns:

the median of the 3 values

mid

public static double mid(double a,
 double b,
 double c)

Find the median of 3 double-precision values.

Parameters:

a - the first input value

b - the 2nd input value

c - the 3rd input value

Returns:

the median of the 3 values

min

public static float min(float... fValues)

Find the minimum of some single-precision values.

Parameters:

fValues - the input values

Returns:

the most negative value

See Also:

• Math.min(float, float)

minDouble

public static double minDouble(double... dValues)

Find the minimum of some double-precision values.

Parameters:

dValues - the input values

Returns:

the most negative value

See Also:

• Math.min(double, double)

modulo

public static int modulo(int iValue,
 int modulus)

Return the least non-negative value congruent with the input value with respect to the specified modulus.

This differs from remainder for negative input values. For instance, modulo(-1, 4) == 3, while -1 % 4 == -1.

Parameters:

iValue - the input value

modulus - (>0)

Returns:

iValue MOD modulus (<modulus, ≥0)

modulo

public static float modulo(float fValue,
 float modulus)

Return the least non-negative value congruent with the input value with respect to the specified modulus.

This differs from remainder for negative input values. For instance, modulo(-1f, 4f) == 3f, while -1f % 4f == -1f.

Parameters:

fValue - the input value

modulus - (>0)

Returns:

fValue MOD modulus (<modulus, ≥0)

modulo

public static double modulo(double dValue,
 double modulus)

Return the least non-negative value congruent with the input value with respect to the specified modulus.

This differs from remainder for negative input values. For instance, modulo(-1, 4) == 3, while -1 % 4 == -1.

Parameters:

dValue - the input value

modulus - (>0)

Returns:

dValue MOD modulus (<modulus, ≥0)

slerp

public static com.jme3.math.Transform slerp(float t,
 com.jme3.math.Transform t0,
 com.jme3.math.Transform t1,
 com.jme3.math.Transform storeResult)

Interpolate between 2 transforms using spherical linear (Slerp) interpolation.

This method is slower (but more accurate) than Transform.interpolateTransforms(com.jme3.math.Transform, com.jme3.math.Transform, float) and doesn't trash t1. The caller is responsible for flipping quaternion signs when it's appropriate to do so.

Parameters:

t - the weight given to t1 (≥0, ≤1)

t0 - the function value at t=0 (not null, unaffected unless it's storeResult)

t1 - the function value at t=1 (not null, unaffected unless it's storeResult)

storeResult - storage for the result (modified if not null, may be t0 or t1)

Returns:

the interpolated transform (either storeResult or a new instance)

sqr

public static double sqr(double dValue)

Square the specified double-precision value. Logs a warning in case of overflow.

Parameters:

dValue - input value to be squared

Returns:

dValue squared (≥0)

See Also:

• FastMath.sqr(float)
• Math.sqrt(double)

standardize

public static float standardize(float fValue)

Standardize a single-precision value in preparation for hashing.

Parameters:

fValue - input value

Returns:

an equivalent value that's not -0

standardizeAngle

public static float standardizeAngle(float angle)

Standardize a rotation angle to the range [-Pi, Pi).

Parameters:

angle - the input angle (in radians)

Returns:

the standardized angle (in radians, <Pi, ≥-Pi)

sumOfSquares

public static double sumOfSquares(float... fValues)

Return the sum of squares of some single-precision values. Double-precision arithmetic is used to reduce the risk of overflow.

Parameters:

fValues - the input values

Returns:

the sum of squares (≥0)

toDegrees

public static float toDegrees(float radians)

Convert an angle from radians to degrees.

Parameters:

radians - input angle

Returns:

equivalent in degrees

See Also:

• Math.toDegrees(double)

toRadians

public static float toRadians(float degrees)

Convert an angle from degrees to radians.

Parameters:

degrees - input angle

Returns:

equivalent in radians

See Also:

• Math.toRadians(double)

transform

public static com.jme3.math.Vector3f transform(com.jme3.math.Transform transform,
 com.jme3.math.Vector3f input,
 com.jme3.math.Vector3f storeResult)

Apply the specified transform to a Vector3f.

It is safe for input and storeResult to be the same object.

Unlike Transform.transformVector(com.jme3.math.Vector3f, com.jme3.math.Vector3f), this method works on transforms containing non-normalized quaternions.

Parameters:

transform - the transform to apply (not null, unaffected unless storeResult is its translation or scaling component)

input - the input vector (not null, unaffected unless it's storeResult)

storeResult - storage for the result (modified if not null)

Returns:

the transformed vector (either storeResult or a new instance)

transformInverse

public static com.jme3.math.Triangle transformInverse(com.jme3.math.Transform transform,
 com.jme3.math.Triangle input,
 com.jme3.math.Triangle storeResult)

Apply the inverse of the specified transform to each vertex of a Triangle.

It is safe for input and storeResult to be the same object.

Parameters:

transform - the transform to apply (not null, unaffected)

input - the input triangle (not null, unaffected unless it's storeResult)

storeResult - storage for the result (modified if not null)

Returns:

the transformed triangle (either storeResult or a new instance)

transformInverse

public static com.jme3.math.Vector3f transformInverse(com.jme3.math.Transform transform,
 com.jme3.math.Vector3f input,
 com.jme3.math.Vector3f storeResult)

Apply the inverse of the specified transform to a Vector3f.

It is safe for input and storeResult to be the same object.

Unlike Transform.transformInverseVector(com.jme3.math.Vector3f, com.jme3.math.Vector3f), this method works on transforms containing non-normalized quaternions.

Parameters:

transform - the transform to un-apply (not null, unaffected unless storeResult is its translation or scaling component)

input - the input vector (not null, unaffected unless it's storeResult)

storeResult - storage for the result (modified if not null)

Returns:

the transformed vector (either storeResult or a new instance)