# Class MathUtils

java.lang.Object
com.codename1.gaming.physics.box2d.common.MathUtils

public class MathUtils extends Object
A few math methods that don't fit very well anywhere else.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final float`
  `DEG2RAD`
  Degrees to radians conversion factor
  `static final float`
  `HALF_PI`
  `static final float`
  `INV_PI`
  `static final float`
  `PI`
  `static final float`
  `QUARTER_PI`
  `static final float`
  `RAD2DEG`
  Radians to degrees conversion factor
  `static final float[]`
  `sinLUT`
  `static final float`
  `THREE_HALVES_PI`
  `static final float`
  `TWOPI`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `MathUtils()`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static final float`
  `abs(float x)`
  `static final int`
  `abs(int x)`
  `static final float`
  `atan2(float y, float x)`
  `static final int`
  `ceil(float x)`
  `static final int`
  `ceilPowerOf2(int x)`
  Rounds up the value to the nearest higher power^2 value.
  `static final float`
  `clamp(float a, float low, float high)`
  Returns the closest value to 'a' that is in between 'low' and 'high'
  `static final Vec2`
  `clamp(Vec2 a, Vec2 low, Vec2 high)`
  `static final void`
  `clampToOut(Vec2 a, Vec2 low, Vec2 high, Vec2 dest)`
  `static final float`
  `cos(float x)`
  `static final float`
  `distance(Vec2 v1, Vec2 v2)`
  `static final float`
  `distanceSquared(Vec2 v1, Vec2 v2)`
  `static final float`
  `fastAtan2(float y, float x)`
  `static final float`
  `fastPow(float a, float b)`
  `static final int`
  `floor(float x)`
  `static final boolean`
  `isPowerOfTwo(int x)`
  `static final float`
  `map(float val, float fromMin, float fromMax, float toMin, float toMax)`
  `static final float`
  `max(float a, float b)`
  `static final int`
  `max(int a, int b)`
  `static final float`
  `min(float a, float b)`
  `static final int`
  `min(int a, int b)`
  `static final int`
  `nextPowerOfTwo(int x)`
  Next Largest Power of 2: Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm that recursively "folds" the upper bits into the lower bits.
  `static final float`
  `randomFloat(float argLow, float argHigh)`
  `static final float`
  `randomFloat(Random r, float argLow, float argHigh)`
  `static final float`
  `reduceAngle(float theta)`
  `static final int`
  `round(float x)`
  `static final float`
  `sin(float x)`
  `static final float`
  `sinLUT(float x)`
  `static final float`
  `sqrt(float x)`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### PI

    public static final float PI
    See Also:
      - Constant Field Values

  - ### TWOPI

    public static final float TWOPI
    See Also:
      - Constant Field Values

  - ### INV_PI

    public static final float INV_PI
    See Also:
      - Constant Field Values

  - ### HALF_PI

    public static final float HALF_PI
    See Also:
      - Constant Field Values

  - ### QUARTER_PI

    public static final float QUARTER_PI
    See Also:
      - Constant Field Values

  - ### THREE_HALVES_PI

    public static final float THREE_HALVES_PI
    See Also:
      - Constant Field Values

  - ### DEG2RAD

    public static final float DEG2RAD
    Degrees to radians conversion factor
    See Also:
      - Constant Field Values

  - ### RAD2DEG

    public static final float RAD2DEG
    Radians to degrees conversion factor
    See Also:
      - Constant Field Values

  - ### sinLUT

    public static final float[] sinLUT

- ## Constructor Details

  - ### MathUtils

    public MathUtils()

- ## Method Details

  - ### sin

    public static final float sin(float x)

  - ### sinLUT

    public static final float sinLUT(float x)

  - ### cos

    public static final float cos(float x)

  - ### abs

    public static final float abs(float x)

  - ### abs

    public static final int abs(int x)

  - ### floor

    public static final int floor(float x)

  - ### ceil

    public static final int ceil(float x)

  - ### round

    public static final int round(float x)

  - ### ceilPowerOf2

    public static final int ceilPowerOf2(int x)
    Rounds up the value to the nearest higher power^2 value.
    Parameters:
      `x` -
    Returns:
      power^2 value

  - ### max

    public static final float max(float a, float b)

  - ### max

    public static final int max(int a, int b)

  - ### min

    public static final float min(float a, float b)

  - ### min

    public static final int min(int a, int b)

  - ### map

    public static final float map(float val, float fromMin, float fromMax, float toMin, float toMax)

  - ### clamp

    public static final float clamp(float a, float low, float high)
    Returns the closest value to 'a' that is in between 'low' and 'high'

  - ### clamp

    public static final Vec2 clamp(Vec2 a, Vec2 low, Vec2 high)

  - ### clampToOut

    public static final void clampToOut(Vec2 a, Vec2 low, Vec2 high, Vec2 dest)

  - ### nextPowerOfTwo

    public static final int nextPowerOfTwo(int x)
    Next Largest Power of 2: Given a binary integer value x, the next largest power of 2 can be computed by a SWAR algorithm that recursively "folds" the upper bits into the lower bits. This process yields a bit vector with the same most significant 1 as x, but all 1's below it. Adding 1 to that value yields the next largest power of 2.

  - ### isPowerOfTwo

    public static final boolean isPowerOfTwo(int x)

  - ### atan2

    public static final float atan2(float y, float x)

  - ### fastAtan2

    public static final float fastAtan2(float y, float x)

  - ### reduceAngle

    public static final float reduceAngle(float theta)

  - ### randomFloat

    public static final float randomFloat(float argLow, float argHigh)

  - ### randomFloat

    public static final float randomFloat(Random r, float argLow, float argHigh)

  - ### sqrt

    public static final float sqrt(float x)

  - ### distanceSquared

    public static final float distanceSquared(Vec2 v1, Vec2 v2)

  - ### distance

    public static final float distance(Vec2 v1, Vec2 v2)

  - ### fastPow

    public static final float fastPow(float a, float b)