MathHelper

Overview | Package | Class | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.NeuroSky.Util
Class MathHelper

    java.lang.Object
      com.NeuroSky.Util.MathHelper

    public class MathHelper

extends java.lang.Object

This class implements a bunch of utility functions to perform various transformation and computational operations. Some of the functions are simply to fill holes in J2ME's implementation of the `Math` class.

Constructor Summary
`MathHelper()`

Method Summary
`static float` | `clamp(float t, float floor, float ceiling)` Limit a value to between `floor` and `ceiling`.
`static Vector2` | `cubicBezier(Vector2 p0, Vector2 p1, Vector2 p2, Vector2 p3, float t)` Generate a point in a cubic Bezier curve defined by two anchor and two control points, and a parameter.
`static int` | `dampColor(int startColor, float dampFactor)` Apply a multiplicative factor to each component in a color represented by an integer (0x00RRGGBB).
`static float` | `exp(float x)` Calculate the value of `e^x` given an input `x`.
`static float` | `lerp(float start, float end, float t)` Linearly interpolate a value between the current value and target value.
`static int` | `lerpColor(int startColor, int endColor, float t)` Linearly interpolate between two colors.
`static float` | `log(float x)` Calculate the natural log of an input `x`, i.e.
`static float` | `normalizeValue(float value)` Perform a custom normalization procedure on a value, involving applying a natural logarithm, then scaling the number to a range between 0 and 1.
`static Vector2` | `rotate(float angle, Vector2 point)` Rotate a point about the origin (0,0) over an angle.
`static float` | `smoothDamp(float current, float target, float[] currentVelocity, int index, float smoothTime, float deltaTime)` Critically damp a value towards a target value.

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

Constructor Detail

### MathHelper

    public MathHelper()

Method Detail

### lerp

    public static float lerp(float start,
                             float end,
                             float t)

  Linearly interpolate a value between the current value and target value. This could be seen as a linear Bezier curve.

  Parameters:
    `start` - the starting value
    `end` - the ending value
    `t` - the parameter
  Returns:
    a value that represents a linearly interpolated value between "start" and "end"

### lerpColor

    public static int lerpColor(int startColor,
                                int endColor,
                                float t)

  Linearly interpolate between two colors.

  Parameters:
    `startColor` - the starting color, defined by 0x00RRGGBB
    `endColor` - the finishing color, defined by 0x00RRGGBB
    `t` - the parameter
  Returns:
    a 0x00RRGGBB value that represents a linearly interpolated value

### clamp

    public static float clamp(float t,
                              float floor,
                              float ceiling)

  Limit a value to between `floor` and `ceiling`. This may be useful for making sure that a number never exceeds a certain range.

  Parameters:
    `t` - the value to be clamped
    `floor` - the minimum value the returned value should take
    `ceiling` - the maximum value the returned value should take
  Returns:
    the clamped value

### dampColor

    public static int dampColor(int startColor,
                                float dampFactor)

  Apply a multiplicative factor to each component in a color represented by an integer (0x00RRGGBB).

  Parameters:
    `startColor` - the initial color, in the form 0x00RRGGBB
    `dampFactor` - the multiplicative factor applied to the color
  Returns:
    the damped color (startColor * dampFactor)

### exp

    public static float exp(float x)

  Calculate the value of `e^x` given an input `x`. This only gives us good precision to about x = +/- 2, since it's calculated using a fairly coarse Power Series approximation.

  Parameters:
    `x` - the value that e is raised to
  Returns:
    the result of the calculation e^x

### log

    public static float log(float x)

  Calculate the natural log of an input `x`, i.e. ln(x). This function gives us reasonably good precision, and is accurate to around 3 significant figures. The precision of this function is limited by the accuracy of a T(4) Taylor Series approximation of the natural logarithm function between 1 and 2.

  Parameters:
    `x` - the value from which the natural log should be calculated
  Returns:
    the natural log of `x`

### smoothDamp

    public static float smoothDamp(float current,
                                   float target,
                                   float[] currentVelocity,
                                   int index,
                                   float smoothTime,
                                   float deltaTime)

  Critically damp a value towards a target value. This method uses the equation for a critically damped system: x(t) = (A + Bt) * e^(-w0 * t), where A = x(0) B = x'(0) + x(0)

  Parameters:
    `current` - the current value
    `target` - the target value
    `currentVelocity` - an array of floats storing the current velocity x'(0)
    `index` - the index into the `currentVelocity` array referencing the desired float element
    `smoothTime` - - the time taken to reach the target value
    `deltaTime` - - the elapsed time since the last call to this method
  Returns:
    a critically damped value

### rotate

    public static Vector2 rotate(float angle,
                                 Vector2 point)

  Rotate a point about the origin (0,0) over an angle.

  Parameters:
    `angle` - the angle (in radians) over which to rotate the point
    `point` - the point to be rotated
  Returns:
    a point representing the rotated original point

### cubicBezier

    public static Vector2 cubicBezier(Vector2 p0,
                                      Vector2 p1,
                                      Vector2 p2,
                                      Vector2 p3,
                                      float t)

  Generate a point in a cubic Bezier curve defined by two anchor and two control points, and a parameter.

  Parameters:
    `p0` - the starting anchor point
    `p1` - the first control point
    `p2` - the second control point
    `p3` - the ending anchor point
    `t` - the parameter for the Bezier curve
  Returns:
    a point along the cubic Bezier curve

### normalizeValue

    public static float normalizeValue(float value)

  Perform a custom normalization procedure on a value, involving applying a natural logarithm, then scaling the number to a range between 0 and 1.

  Parameters:
    `value` - the value to be normalized
  Returns:
    a normalized float between `0` and `1`.

Overview | Package | Class | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD