CesiumMath - Cesium Documentation

# CesiumMath

Math functions.

Source: Core/Math.js, line 20

### Members

#### staticconstantCesiumMath.DEGREES_PER_RADIAN :Number

  The number of degrees in a radian.
  Default Value: `180.0 / Math.PI`
  Source: Core/Math.js, line 400

#### staticconstantCesiumMath.EPSILON1 :Number

  0.1
  Source: Core/Math.js, line 27

#### staticconstantCesiumMath.EPSILON2 :Number

  0.01
  Source: Core/Math.js, line 34

#### staticconstantCesiumMath.EPSILON3 :Number

  0.001
  Source: Core/Math.js, line 41

#### staticconstantCesiumMath.EPSILON4 :Number

  0.0001
  Source: Core/Math.js, line 48

#### staticconstantCesiumMath.EPSILON5 :Number

  0.00001
  Source: Core/Math.js, line 55

#### staticconstantCesiumMath.EPSILON6 :Number

  0.000001
  Source: Core/Math.js, line 62

#### staticconstantCesiumMath.EPSILON7 :Number

  0.0000001
  Source: Core/Math.js, line 69

#### staticconstantCesiumMath.EPSILON8 :Number

  0.00000001
  Source: Core/Math.js, line 76

#### staticconstantCesiumMath.EPSILON9 :Number

  0.000000001
  Source: Core/Math.js, line 83

#### staticconstantCesiumMath.EPSILON10 :Number

  0.0000000001
  Source: Core/Math.js, line 90

#### staticconstantCesiumMath.EPSILON11 :Number

  0.00000000001
  Source: Core/Math.js, line 97

#### staticconstantCesiumMath.EPSILON12 :Number

  0.000000000001
  Source: Core/Math.js, line 104

#### staticconstantCesiumMath.EPSILON13 :Number

  0.0000000000001
  Source: Core/Math.js, line 111

#### staticconstantCesiumMath.EPSILON14 :Number

  0.00000000000001
  Source: Core/Math.js, line 118

#### staticconstantCesiumMath.EPSILON15 :Number

  0.000000000000001
  Source: Core/Math.js, line 125

#### staticconstantCesiumMath.EPSILON16 :Number

  0.0000000000000001
  Source: Core/Math.js, line 132

#### staticconstantCesiumMath.EPSILON17 :Number

  0.00000000000000001
  Source: Core/Math.js, line 139

#### staticconstantCesiumMath.EPSILON18 :Number

  0.000000000000000001
  Source: Core/Math.js, line 146

#### staticconstantCesiumMath.EPSILON19 :Number

  0.0000000000000000001
  Source: Core/Math.js, line 153

#### staticconstantCesiumMath.EPSILON20 :Number

  0.00000000000000000001
  Source: Core/Math.js, line 160

#### staticconstantCesiumMath.GRAVITATIONALPARAMETER :Number

  3.986004418e14
  Source: Core/Math.js, line 167

#### staticconstantCesiumMath.LUNAR_RADIUS :Number

  The mean radius of the moon, according to the "Report of the IAU/IAG Working Group on Cartographic Coordinates and Rotational Elements of the Planets and satellites: 2000", Celestial Mechanics 82: 83-110, 2002.
  Source: Core/Math.js, line 183

#### staticconstantCesiumMath.ONE_OVER_PI :Number

  1/pi
  Source: Core/Math.js, line 326

#### staticconstantCesiumMath.ONE_OVER_TWO_PI :Number

  1/2pi
  Source: Core/Math.js, line 382

#### staticconstantCesiumMath.PI :Number

  pi
  Source: Core/Math.js, line 318

#### staticconstantCesiumMath.PI_OVER_FOUR :Number

  pi/4
  Source: Core/Math.js, line 350

#### staticconstantCesiumMath.PI_OVER_SIX :Number

  pi/6
  Source: Core/Math.js, line 358

#### staticconstantCesiumMath.PI_OVER_THREE :Number

  pi/3
  Source: Core/Math.js, line 342

#### staticconstantCesiumMath.PI_OVER_TWO :Number

  pi/2
  Source: Core/Math.js, line 334

#### staticconstantCesiumMath.RADIANS_PER_ARCSECOND :Number

  The number of radians in an arc second.
  Default Value: ``CesiumMath.RADIANS_PER_DEGREE` / 3600.0`
  Source: Core/Math.js, line 409

#### staticconstantCesiumMath.RADIANS_PER_DEGREE :Number

  The number of radians in a degree.
  Default Value: `Math.PI / 180.0`
  Source: Core/Math.js, line 391

#### staticconstantCesiumMath.SIXTY_FOUR_KILOBYTES :Number

  64 * 1024
  Source: Core/Math.js, line 190

#### staticconstantCesiumMath.SOLAR_RADIUS :Number

  Radius of the sun in meters: 6.955e8
  Source: Core/Math.js, line 174

#### staticconstantCesiumMath.THREE_PI_OVER_TWO :Number

  3pi/2
  Source: Core/Math.js, line 366

#### staticconstantCesiumMath.TWO_PI :Number

  2pi
  Source: Core/Math.js, line 374

### Methods

#### staticCesiumMath.acosClamped(value) → Number

  Computes `Math.acos(value), but first clamps `value` to the range [-1.0, 1.0] so that the function will never return NaN.`

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The value for which to compute acos.

  ##### Returns:

  The acos of the value if the value is in the range [-1.0, 1.0], or the acos of -1.0 or 1.0, whichever is closer, if the value is outside the range.
  Source: Core/Math.js, line 738

#### staticCesiumMath.asinClamped(value) → Number

  Computes `Math.asin(value), but first clamps `value` to the range [-1.0, 1.0] so that the function will never return NaN.`

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The value for which to compute asin.

  ##### Returns:

  The asin of the value if the value is in the range [-1.0, 1.0], or the asin of -1.0 or 1.0, whichever is closer, if the value is outside the range.
  Source: Core/Math.js, line 755

#### staticCesiumMath.chordLength(angle, radius) → Number

  Finds the chord length between two points given the circle's radius and the angle between the points.

  Name | Type | Description
  --- | --- | ---
  `angle` | Number | The angle between the two points.
  `radius` | Number | The radius of the circle.

  ##### Returns:

  The chord length.
  Source: Core/Math.js, line 771

#### staticCesiumMath.clamp(value, min, max) → Number

  Constraint a value to lie between two values.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The value to constrain.
  `min` | Number | The minimum value.
  `max` | Number | The maximum value.

  ##### Returns:

  The value clamped so that min <= value <= max.
  Source: Core/Math.js, line 684

#### staticCesiumMath.convertLongitudeRange(angle) → Number

  Converts a longitude value, in radians, to the range [`-Math.PI`, `Math.PI`).

  Name | Type | Description
  --- | --- | ---
  `angle` | Number | The longitude value, in radians, to convert to the range [`-Math.PI`, `Math.PI`).

  ##### Returns:

  The equivalent longitude value in the range [`-Math.PI`, `Math.PI`).

  ##### Example:

      // Convert 270 degrees to -90 degrees longitude
      var longitude = Cesium.Math.convertLongitudeRange(Cesium.Math.toRadians(270.0));

  Source: Core/Math.js, line 449

#### staticCesiumMath.cosh(value)

  Returns the hyperbolic cosine of a number. The hyperbolic cosine of value is defined to be (ex + e-x)/2.0 where e is Euler's number, approximately 2.71828183.

  Special cases:

  - If the argument is NaN, then the result is NaN.
  - If the argument is infinite, then the result is positive infinity.
  - If the argument is zero, then the result is 1.0.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The number whose hyperbolic cosine is to be returned.

  ##### Returns:

  The hyperbolic cosine of `value`.
  Source: Core/Math.js, line 290

#### staticCesiumMath.equalsEpsilon(left, right, relativeEpsilon, absoluteEpsilon) → Boolean

  Determines if two values are equal using an absolute or relative tolerance test. This is useful to avoid problems due to roundoff error when comparing floating-point values directly. The values are first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed. Use this test if you are unsure of the magnitudes of left and right.

  Name | Type | Default | Description
  --- | --- | --- | ---
  `left` | Number |  | The first value to compare.
  `right` | Number |  | The other value to compare.
  `relativeEpsilon` | Number |  | The maximum inclusive delta between `left` and `right` for the relative tolerance test.
  `absoluteEpsilon` | Number | `relativeEpsilon` | optional The maximum inclusive delta between `left` and `right` for the absolute tolerance test.

  ##### Returns:

  `true` if the values are equal within the epsilon; otherwise, `false`.

  ##### Example:

      var a = Cesium.Math.equalsEpsilon(0.0, 0.01, Cesium.Math.EPSILON2); // true
      var b = Cesium.Math.equalsEpsilon(0.0, 0.1, Cesium.Math.EPSILON2);  // false
      var c = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON7); // true
      var d = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON9); // false

  Source: Core/Math.js, line 540

#### staticCesiumMath.factorial(n) → Number

  Computes the factorial of the provided number.

  Name | Type | Description
  --- | --- | ---
  `n` | Number | The number whose factorial is to be computed.

  ##### Returns:

  The factorial of the provided number or undefined if the number is less than 0.

  ##### Throws:

  - DeveloperError : A number greater than or equal to 0 is required.

  ##### Example:

      //Compute 7!, which is equal to 5040
      var computedFactorial = Cesium.Math.factorial(7);

  ##### See:

  - Factorial on Wikipedia
  Source: Core/Math.js, line 573

#### staticCesiumMath.fromSNorm(value) → Number

  Converts a SNORM value in the range [0, 255] to a scalar in the range [-1.0, 1.0].

  Name | Type | Description
  --- | --- | ---
  `value` | Number | SNORM value in the range [0, 255]

  ##### Returns:

  Scalar in the range [-1.0, 1.0].

  ##### See:

  - CesiumMath.toSNorm
  Source: Core/Math.js, line 239

#### staticCesiumMath.incrementWrap(n, maximumValue, minimumValue) → Number

  Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.

  Name | Type | Default | Description
  --- | --- | --- | ---
  `n` | Number |  | optional The number to be incremented.
  `maximumValue` | Number |  | optional The maximum incremented value before rolling over to the minimum value.
  `minimumValue` | Number | `0.0` | optional The number reset to after the maximum value has been exceeded.

  ##### Returns:

  The incremented number.

  ##### Throws:

  - DeveloperError : Maximum value must be greater than minimum value.

  ##### Example:

      var n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6
      var n = Cesium.Math.incrementWrap(10, 10, 0); // returns 0

  Source: Core/Math.js, line 604

#### staticCesiumMath.isPowerOfTwo(n) → Boolean

  Determines if a positive integer is a power of two.

  Name | Type | Description
  --- | --- | ---
  `n` | Number | The positive integer to test.

  ##### Returns:

  `true` if the number if a power of two; otherwise, `false`.

  ##### Throws:

  - DeveloperError : A number greater than or equal to 0 is required.

  ##### Example:

      var t = Cesium.Math.isPowerOfTwo(16); // true
      var f = Cesium.Math.isPowerOfTwo(20); // false

  Source: Core/Math.js, line 635

#### staticCesiumMath.lerp(p, q, time) → Number

  Computes the linear interpolation of two values.

  Name | Type | Description
  --- | --- | ---
  `p` | Number | The start value to interpolate.
  `q` | Number | The end value to interpolate.
  `time` | Number | The time of interpolation generally in the range `[0.0, 1.0]`.

  ##### Returns:

  The linearly interpolated value.

  ##### Example:

      var n = Cesium.Math.lerp(0.0, 2.0, 0.5); // returns 1.0

  Source: Core/Math.js, line 308

#### staticCesiumMath.mod(m, n) → Number

  The modulo operation that also works for negative dividends.

  Name | Type | Description
  --- | --- | ---
  `m` | Number | The dividend.
  `n` | Number | The divisor.

  ##### Returns:

  The remainder.
  Source: Core/Math.js, line 510

#### staticCesiumMath.negativePiToPi(angle) → Number

  Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.

  Name | Type | Description
  --- | --- | ---
  `angle` | Number | in radians

  ##### Returns:

  The angle in the range [`-CesiumMath.PI`, `CesiumMath.PI`].
  Source: Core/Math.js, line 475

#### staticCesiumMath.nextPowerOfTwo(n) → Number

  Computes the next power-of-two integer greater than or equal to the provided positive integer.

  Name | Type | Description
  --- | --- | ---
  `n` | Number | The positive integer to test.

  ##### Returns:

  The next power-of-two integer.

  ##### Throws:

  - DeveloperError : A number greater than or equal to 0 is required.

  ##### Example:

      var n = Cesium.Math.nextPowerOfTwo(29); // 32
      var m = Cesium.Math.nextPowerOfTwo(32); // 32

  Source: Core/Math.js, line 657

#### staticCesiumMath.nextRandomNumber() → Number

  Generates a random number in the range of [0.0, 1.0) using a Mersenne twister.

  ##### Returns:

  A random number in the range of [0.0, 1.0).

  ##### See:

  - CesiumMath.setRandomNumberSeed
  - Mersenne twister on Wikipedia
  Source: Core/Math.js, line 726

#### staticCesiumMath.setRandomNumberSeed(seed)

  Sets the seed used by the random number generator in `CesiumMath#nextRandomNumber`.

  Name | Type | Description
  --- | --- | ---
  `seed` | Number | An integer used as the seed.

  Source: Core/Math.js, line 707

#### staticCesiumMath.sign(value) → Number

  Returns the sign of the value; 1 if the value is positive, -1 if the value is negative, or 0 if the value is 0.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The value to return the sign of.

  ##### Returns:

  The sign of value.
  Source: Core/Math.js, line 199

#### staticCesiumMath.signNotZero(value) → Number

  Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative. This is similar to `CesiumMath#sign` except that returns 1.0 instead of 0.0 when the input value is 0.0.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The value to return the sign of.

  ##### Returns:

  The sign of value.
  Source: Core/Math.js, line 217

#### staticCesiumMath.sinh(value)

  Returns the hyperbolic sine of a number. The hyperbolic sine of value is defined to be (ex - e-x)/2.0 where e is Euler's number, approximately 2.71828183.

  Special cases:

  - If the argument is NaN, then the result is NaN.
  - If the argument is infinite, then the result is an infinity with the same sign as the argument.
  - If the argument is zero, then the result is a zero with the same sign as the argument.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The number whose hyperbolic sine is to be returned.

  ##### Returns:

  The hyperbolic sine of `value`.
  Source: Core/Math.js, line 264

#### staticCesiumMath.toDegrees(radians) → Number

  Converts radians to degrees.

  Name | Type | Description
  --- | --- | ---
  `radians` | Number | The angle to convert in radians.

  ##### Returns:

  The corresponding angle in degrees.
  Source: Core/Math.js, line 430

#### staticCesiumMath.toRadians(degrees) → Number

  Converts degrees to radians.

  Name | Type | Description
  --- | --- | ---
  `degrees` | Number | The angle to convert in degrees.

  ##### Returns:

  The corresponding angle in radians.
  Source: Core/Math.js, line 416

#### staticCesiumMath.toSNorm(value) → Number

  Converts a scalar value in the range [-1.0, 1.0] to a 8-bit 2's complement number.

  Name | Type | Description
  --- | --- | ---
  `value` | Number | The scalar value in the range [-1.0, 1.0]

  ##### Returns:

  The 8-bit 2's complement number, where 0 maps to -1.0 and 255 maps to 1.0.

  ##### See:

  - CesiumMath.fromSNorm
  Source: Core/Math.js, line 228

#### staticCesiumMath.zeroToTwoPi(angle) → Number

  Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.

  Name | Type | Description
  --- | --- | ---
  `angle` | Number | in radians

  ##### Returns:

  The angle in the range [0, `CesiumMath.TWO_PI`].
  Source: Core/Math.js, line 490