Math

Math()
Core/Math.js 21

Math functions.

Members

staticconstantCesium.Math.DEGREES_PER_RADIAN : Number
Core/Math.js 427

The number of degrees in a radian.
Default Value: 180.0 / Math.PI

staticconstantCesium.Math.EPSILON1 : Number
Core/Math.js 28

0.1

staticconstantCesium.Math.EPSILON2 : Number
Core/Math.js 35

0.01

staticconstantCesium.Math.EPSILON3 : Number
Core/Math.js 42

0.001

staticconstantCesium.Math.EPSILON4 : Number
Core/Math.js 49

0.0001

staticconstantCesium.Math.EPSILON5 : Number
Core/Math.js 56

0.00001

staticconstantCesium.Math.EPSILON6 : Number
Core/Math.js 63

0.000001

staticconstantCesium.Math.EPSILON7 : Number
Core/Math.js 70

0.0000001

staticconstantCesium.Math.EPSILON8 : Number
Core/Math.js 77

0.00000001

staticconstantCesium.Math.EPSILON9 : Number
Core/Math.js 84

0.000000001

staticconstantCesium.Math.EPSILON10 : Number
Core/Math.js 91

0.0000000001

staticconstantCesium.Math.EPSILON11 : Number
Core/Math.js 98

0.00000000001

staticconstantCesium.Math.EPSILON12 : Number
Core/Math.js 105

0.000000000001

staticconstantCesium.Math.EPSILON13 : Number
Core/Math.js 112

0.0000000000001

staticconstantCesium.Math.EPSILON14 : Number
Core/Math.js 119

0.00000000000001

staticconstantCesium.Math.EPSILON15 : Number
Core/Math.js 126

0.000000000000001

staticconstantCesium.Math.EPSILON16 : Number
Core/Math.js 133

0.0000000000000001

staticconstantCesium.Math.EPSILON17 : Number
Core/Math.js 140

0.00000000000000001

staticconstantCesium.Math.EPSILON18 : Number
Core/Math.js 147

0.000000000000000001

staticconstantCesium.Math.EPSILON19 : Number
Core/Math.js 154

0.0000000000000000001

staticconstantCesium.Math.EPSILON20 : Number
Core/Math.js 161

0.00000000000000000001

staticconstantCesium.Math.EPSILON21 : Number
Core/Math.js 168

0.000000000000000000001

staticconstantCesium.Math.FOUR_GIGABYTES : Number
Core/Math.js 206

4 * 1024 * 1024 * 1024

staticconstantCesium.Math.GRAVITATIONALPARAMETER : Number
Core/Math.js 176

The gravitational parameter of the Earth in meters cubed per second squared as defined by the WGS84 model: 3.986004418e14

staticconstantCesium.Math.LUNAR_RADIUS : Number
Core/Math.js 192

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.

staticconstantCesium.Math.ONE_OVER_PI : Number
Core/Math.js 353

1/pi

staticconstantCesium.Math.ONE_OVER_TWO_PI : Number
Core/Math.js 409

1/2pi

staticconstantCesium.Math.PI : Number
Core/Math.js 345

pi

staticconstantCesium.Math.PI_OVER_FOUR : Number
Core/Math.js 377

pi/4

staticconstantCesium.Math.PI_OVER_SIX : Number
Core/Math.js 385

pi/6

staticconstantCesium.Math.PI_OVER_THREE : Number
Core/Math.js 369

pi/3

staticconstantCesium.Math.PI_OVER_TWO : Number
Core/Math.js 361

pi/2

staticconstantCesium.Math.RADIANS_PER_ARCSECOND : Number
Core/Math.js 436

The number of radians in an arc second.
Default Value: CesiumMath.RADIANS_PER_DEGREE / 3600.0

staticconstantCesium.Math.RADIANS_PER_DEGREE : Number
Core/Math.js 418

The number of radians in a degree.
Default Value: Math.PI / 180.0

staticconstantCesium.Math.SIXTY_FOUR_KILOBYTES : Number
Core/Math.js 199

64 * 1024

staticconstantCesium.Math.SOLAR_RADIUS : Number
Core/Math.js 183

Radius of the sun in meters: 6.955e8

staticconstantCesium.Math.THREE_PI_OVER_TWO : Number
Core/Math.js 393

3pi/2

staticconstantCesium.Math.TWO_PI : Number
Core/Math.js 401

2pi

Methods

staticCesium.Math.acosClamped(value) → Number
Core/Math.js 902

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.

staticCesium.Math.asinClamped(value) → Number
Core/Math.js 919

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.

staticCesium.Math.cbrt(number) → Number
Core/Math.js 974

Finds the cube root of a number. Returns NaN if number is not provided.
Name Type Description
number Number optional The number.
Returns:
The result.

staticCesium.Math.chordLength(angle, radius) → Number
Core/Math.js 935

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.

staticCesium.Math.clamp(value, min, max) → Number
Core/Math.js 837

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.

staticCesium.Math.clampToLatitudeRange(angle) → Number
Core/Math.js 507

Convenience function that clamps a latitude value, in radians, to the range [-Math.PI/2, Math.PI/2). Useful for sanitizing data before use in objects requiring correct range.
Name Type Description
angle Number The latitude value, in radians, to clamp to the range [-Math.PI/2, Math.PI/2).
Returns:
The latitude value clamped to the range [-Math.PI/2, Math.PI/2).
Example:
// Clamp 108 degrees latitude to 90 degrees latitude
var latitude = Cesium.Math.clampToLatitudeRange(Cesium.Math.toRadians(108.0));

staticCesium.Math.convertLongitudeRange(angle) → Number
Core/Math.js 476

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));

staticCesium.Math.cosh(value) → Number
Core/Math.js 320

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.

staticCesium.Math.equalsEpsilon(left, right, relativeEpsilon, absoluteEpsilon) → Boolean
Core/Math.js 588

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

staticCesium.Math.factorial(n) → Number
Core/Math.js 724

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:
Example:
//Compute 7!, which is equal to 5040
var computedFactorial = Cesium.Math.factorial(7);
See:

staticCesium.Math.fastApproximateAtan(x) → Number
Core/Math.js 1009

Computes a fast approximation of Atan for input in the range [-1, 1]. Based on Michal Drobot's approximation from ShaderFastLibs, which in turn is based on "Efficient approximations for the arctangent function," Rajan, S. Sichun Wang Inkol, R. Joyal, A., May 2006. Adapted from ShaderFastLibs under MIT License.
Name Type Description
x Number An input number in the range [-1, 1]
Returns:
An approximation of atan(x)

staticCesium.Math.fastApproximateAtan2(x, y) → Number
Core/Math.js 1026

Computes a fast approximation of Atan2(x, y) for arbitrary input scalars. Range reduction math based on nvidia's cg reference implementation: http://developer.download.nvidia.com/cg/atan2.html
Name Type Description
x Number An input number that isn't zero if y is zero.
y Number An input number that isn't zero if x is zero.
Returns:
An approximation of atan2(x, y)

staticCesium.Math.fromSNorm(value, rangeMaximum) → Number
Core/Math.js 257

Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].
Name Type Default Description
value Number SNORM value in the range [0, rangeMaximum]
rangeMaximum Number 255 optional The maximum value in the SNORM range, 255 by default.
Returns:
Scalar in the range [-1.0, 1.0].
See:
  • CesiumMath.toSNorm

staticCesium.Math.greaterThan(left, right, absoluteEpsilon) → Boolean
Core/Math.js 667

Determines if the left value is greater the right value. If the two values are within absoluteEpsilon of each other, they are considered equal and this function returns false.
Name Type Description
left Number The first number to compare.
right Number The second number to compare.
absoluteEpsilon Number The absolute epsilon to use in comparison.
Returns:
true if left is greater than right by more than absoluteEpsilon. false if left is less or if the two values are nearly equal.

staticCesium.Math.greaterThanOrEquals(left, right, absoluteEpsilon) → Boolean
Core/Math.js 692

Determines if the left value is greater than or equal to the right value. If the two values are within absoluteEpsilon of each other, they are considered equal and this function returns true.
Name Type Description
left Number The first number to compare.
right Number The second number to compare.
absoluteEpsilon Number The absolute epsilon to use in comparison.
Returns:
true if left is greater than right or if the the values are nearly equal.

staticCesium.Math.incrementWrap(n, maximumValue, minimumValue) → Number
Core/Math.js 757

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:
Example:
var n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6
var n = Cesium.Math.incrementWrap(10, 10, 0); // returns 0

staticCesium.Math.isPowerOfTwo(n) → Boolean
Core/Math.js 788

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:
Example:
var t = Cesium.Math.isPowerOfTwo(16); // true
var f = Cesium.Math.isPowerOfTwo(20); // false

staticCesium.Math.lerp(p, q, time) → Number
Core/Math.js 335

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

staticCesium.Math.lessThan(left, right, absoluteEpsilon) → Boolean
Core/Math.js 616

Determines if the left value is less than the right value. If the two values are within absoluteEpsilon of each other, they are considered equal and this function returns false.
Name Type Description
left Number The first number to compare.
right Number The second number to compare.
absoluteEpsilon Number The absolute epsilon to use in comparison.
Returns:
true if left is less than right by more than absoluteEpsilon. false if left is greater or if the two values are nearly equal.

staticCesium.Math.lessThanOrEquals(left, right, absoluteEpsilon) → Boolean
Core/Math.js 641

Determines if the left value is less than or equal to the right value. If the two values are within absoluteEpsilon of each other, they are considered equal and this function returns true.
Name Type Description
left Number The first number to compare.
right Number The second number to compare.
absoluteEpsilon Number The absolute epsilon to use in comparison.
Returns:
true if left is less than right or if the the values are nearly equal.

staticCesium.Math.log2(number) → Number
Core/Math.js 986

Finds the base 2 logarithm of a number.
Name Type Description
number Number The number.
Returns:
The result.

staticCesium.Math.logBase(number, base) → Number
Core/Math.js 954

Finds the logarithm of a number to a base.
Name Type Description
number Number The number.
base Number The base.
Returns:
The result.

staticCesium.Math.mod(m, n) → Number
Core/Math.js 558

The modulo operation that also works for negative dividends.
Name Type Description
m Number The dividend.
n Number The divisor.
Returns:
The remainder.

staticCesium.Math.negativePiToPi(angle) → Number
Core/Math.js 523

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].

staticCesium.Math.nextPowerOfTwo(n) → Number
Core/Math.js 810

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:
Example:
var n = Cesium.Math.nextPowerOfTwo(29); // 32
var m = Cesium.Math.nextPowerOfTwo(32); // 32

staticCesium.Math.nextRandomNumber() → Number
Core/Math.js 879

Generates a random floating point 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:

staticCesium.Math.normalize(value, rangeMinimum, rangeMaximum) → Number
Core/Math.js 269

Converts a scalar value in the range [rangeMinimum, rangeMaximum] to a scalar in the range [0.0, 1.0]
Name Type Description
value Number The scalar value in the range [rangeMinimum, rangeMaximum]
rangeMinimum Number The minimum value in the mapped range.
rangeMaximum Number The maximum value in the mapped range.
Returns:
A scalar value, where rangeMinimum maps to 0.0 and rangeMaximum maps to 1.0.

staticCesium.Math.randomBetween(min, max) → Number
Core/Math.js 890

Generates a random number between two numbers.
Name Type Description
min Number The minimum value.
max Number The maximum value.
Returns:
A random number between the min and max.

staticCesium.Math.setRandomNumberSeed(seed)
Core/Math.js 860

Sets the seed used by the random number generator in CesiumMath#nextRandomNumber.
Name Type Description
seed Number An integer used as the seed.

staticCesium.Math.sign(value) → Number
Core/Math.js 216

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.

staticCesium.Math.signNotZero(value) → Number
Core/Math.js 232

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.

staticCesium.Math.sinh(value) → Number
Core/Math.js 296

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.

staticCesium.Math.toDegrees(radians) → Number
Core/Math.js 457

Converts radians to degrees.
Name Type Description
radians Number The angle to convert in radians.
Returns:
The corresponding angle in degrees.

staticCesium.Math.toRadians(degrees) → Number
Core/Math.js 443

Converts degrees to radians.
Name Type Description
degrees Number The angle to convert in degrees.
Returns:
The corresponding angle in radians.

staticCesium.Math.toSNorm(value, rangeMaximum) → Number
Core/Math.js 244

Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum]
Name Type Default Description
value Number The scalar value in the range [-1.0, 1.0]
rangeMaximum Number 255 optional The maximum value in the mapped range, 255 by default.
Returns:
A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.
See:
  • CesiumMath.fromSNorm

staticCesium.Math.zeroToTwoPi(angle) → Number
Core/Math.js 538

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].