cesium 0.13.0

data/app/assets/javascripts/Core/KeyboardEventModifier.js

@@ -0,0 +1,38 @@
+/*global define*/
+define(['./Enumeration'], function(Enumeration) {
+    "use strict";
+
+    /**
+     * This enumerated type is for representing keyboard modifiers. These are keys
+     * that are held down in addition to other event types.
+     *
+     * @exports KeyboardEventModifier
+     */
+    var KeyboardEventModifier = {
+        /**
+         * Represents the shift key being held down.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        SHIFT : new Enumeration(0, 'SHIFT'),
+
+        /**
+         * Represents the control key being held down.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        CTRL : new Enumeration(1, 'CTRL'),
+
+        /**
+         * Represents the alt key being held down.
+         *
+         * @constant
+         * @type {Enumeration}
+         */
+        ALT : new Enumeration(2, 'ALT')
+    };
+
+    return KeyboardEventModifier;
+});

data/app/assets/javascripts/Core/LagrangePolynomialApproximation.js

@@ -0,0 +1,96 @@
+/*global define*/
+define(function() {
+    "use strict";
+
+    /**
+     * Functions for performing Lagrange interpolation.
+     * @exports LagrangePolynomialApproximation
+     *
+     * @see LinearApproximation
+     * @see HermitePolynomialApproximation
+     */
+    var LagrangePolynomialApproximation = {
+        type : 'Lagrange'
+    };
+
+    /**
+     * Given the desired degree, returns the number of data points required for interpolation.
+     *
+     * @memberof LagrangePolynomialApproximation
+     *
+     * @param degree The desired degree of interpolation.
+     *
+     * @returns The number of required data points needed for the desired degree of interpolation.
+     */
+    LagrangePolynomialApproximation.getRequiredDataPoints = function(degree) {
+        return Math.max(degree + 1.0, 2);
+    };
+
+    /**
+     * <p>
+     * Interpolates values using the supplied interpolation algorithm.  The appropriate subset of input
+     * values to use for the interpolation is determined automatically from an interpolation given
+     * degree.
+     * </p>
+     * <p>
+     * The xTable array can contain any number of elements, and the appropriate subset will be
+     * selected according to the degree of interpolation requested.  For example, if degree is 5,
+     * the 6 elements surrounding x will be used for interpolation.  When using
+     * {@link LinearApproximation} the degree should be 1 since it always deals with only 2 elements
+     * surrounding x. The yTable array should contain a number of elements equal to:
+     * <code>xTable.length * yStride</code>.  If insufficient elements are provided
+     * to perform the requested degree of interpolation, the highest possible degree of interpolation
+     * will be performed.
+     * </p>
+     *
+     * @param {Number} x The independent variable for which the dependent variables will be interpolated.
+     *
+     * @param {Array} xTable The array of independent variables to use to interpolate.  The values
+     * in this array must be in increasing order and the same value must not occur twice in the array.
+     *
+     * @param {Array} yTable The array of dependent variables to use to interpolate.  For a set of three
+     * dependent values (p,q,w) and their derivatives (dp, dq, dw) at time 1 and time 2 this should be
+     * as follows: {p1, q1, w1, dp1, dq1, dw1, p2, q2, w2, dp2, dq2, dw2}.
+     *
+     * @param {Number} yStride The number of dependent variable values in yTable corresponding to
+     * each independent variable value in xTable.
+     *
+     * @returns An array of interpolated values.  The array contains at least yStride elements, each
+     * of which is an interpolated dependent variable value.
+     *
+     * @see LinearApproximation
+     * @see HermitePolynomialApproximation
+     *
+     * @memberof LagrangePolynomialApproximation
+     *
+     */
+    LagrangePolynomialApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride) {
+        var i;
+        var j;
+        var length = xTable.length;
+        var result = new Array(yStride);
+
+        for (i = 0; i < yStride; i++) {
+            result[i] = 0;
+        }
+
+        for (i = 0; i < length; i++) {
+            var coefficient = 1;
+
+            for (j = 0; j < length; j++) {
+                if (j !== i) {
+                    var diffX = xTable[i] - xTable[j];
+                    coefficient *= (x - xTable[j]) / diffX;
+                }
+            }
+
+            for (j = 0; j < yStride; j++) {
+                result[j] += coefficient * yTable[i * yStride + j];
+            }
+        }
+
+        return result;
+    };
+
+    return LagrangePolynomialApproximation;
+});

data/app/assets/javascripts/Core/LeapSecond.js

@@ -0,0 +1,158 @@
+/*global define*/
+define([
+        './DeveloperError'
+    ], function(
+        DeveloperError) {
+    "use strict";
+
+    /**
+     * Describes a single leap second, which is constructed from a {@link JulianDate} and a
+     * numerical offset representing the number of seconds TAI is ahead of the UTC time standard.
+     *
+     * @alias LeapSecond
+     * @constructor
+     *
+     * @param {JulianDate} date A Julian date representing the time of the leap second.
+     * @param {Number} offset The cumulative number of seconds, that TAI is ahead of UTC at provided date.
+     *
+     * @exception {DeveloperError} <code>date</code> is required.
+     * @exception {DeveloperError} <code>offset</code> is required.
+     *
+     * @see JulianDate
+     * @see TimeStandard
+     *
+     * @example
+     * // Example 1. Construct a LeapSecond using a JulianDate
+     * var date = new Date('January 1, 1990 00:00:00 UTC');
+     * var leapSecond = new LeapSecond(JulianDate.fromDate(date), 25.0);
+     * var offset = leapSecond.offset;    // 25.0
+     *
+     * //////////////////////////////////////////////////////////////////
+     *
+     * // Example 2. Construct a LeapSecond using a date string
+     * var date = 'January 1, 1990 00:00:00 UTC';
+     * var leapSecond = new LeapSecond(date, 25.0);
+     */
+    var LeapSecond = function(date, offset) {
+        if (typeof date === 'undefined') {
+            throw new DeveloperError('date is required.');
+        }
+
+        if (offset === null || isNaN(offset)) {
+            throw new DeveloperError('offset is required and must be a number.');
+        }
+
+        /**
+         * The Julian date at which this leap second occurs.
+         *
+         * @type {JulianDate}
+         */
+        this.julianDate = date;
+
+        /**
+         * The cumulative number of seconds between the UTC and TAI time standards at the time
+         * of this leap second.
+         *
+         * @type {Number}
+         */
+        this.offset = offset;
+    };
+
+    /**
+     * Sets the list of leap seconds used throughout Cesium.
+     *
+     * @memberof LeapSecond
+     *
+     * @param {Array} leapSeconds An array of {@link LeapSecond} objects.
+     * @exception {DeveloperErrpr} leapSeconds is required and must be an array.
+     *
+     * @see LeapSecond.setLeapSeconds
+     *
+     * @example
+     * LeapSecond.setLeapSeconds([
+     *                            new LeapSecond(new JulianDate(2453736, 43233.0, TimeStandard.TAI), 33), // January 1, 2006 00:00:00 UTC
+     *                            new LeapSecond(new JulianDate(2454832, 43234.0, TimeStandard.TAI), 34), // January 1, 2009 00:00:00 UTC
+     *                            new LeapSecond(new JulianDate(2456109, 43235.0, TimeStandard.TAI), 35)  // July 1, 2012 00:00:00 UTC
+     *                           ]);
+     */
+    LeapSecond.setLeapSeconds = function(leapSeconds) {
+        if (!Array.isArray(leapSeconds)) {
+            throw new DeveloperError("leapSeconds is required and must be an array.");
+        }
+        LeapSecond._leapSeconds = leapSeconds;
+        LeapSecond._leapSeconds.sort(LeapSecond.compareLeapSecondDate);
+    };
+
+    /**
+     * Returns a copy of the array of leap seconds used throughout Cesium. By default, this is the
+     * official list of leap seconds that was available when Cesium was released.
+     *
+     * @memberof LeapSecond
+     *
+     * @return {Array} A list of {@link LeapSecond} objects.
+     *
+     * @see LeapSecond.setLeapSeconds
+     */
+    LeapSecond.getLeapSeconds = function() {
+        return LeapSecond._leapSeconds;
+    };
+
+    /**
+     * Checks whether two leap seconds are equivalent to each other.
+     *
+     * @memberof LeapSecond
+     *
+     * @param {LeapSecond} other The leap second to compare against.
+     *
+     * @return {Boolean} <code>true</code> if the leap seconds are equal; otherwise, <code>false</code>.
+     *
+     * @example
+     * var date = new Date('January 1, 1990 00:00:00 UTC');
+     * var leapSecond1 = new LeapSecond(JulianDate.fromDate(date), 25.0);
+     * var leapSecond2 = new LeapSecond(JulianDate.fromDate(date), 25.0);
+     * leapSecond1.equals(leapSecond2);     // true
+     */
+    LeapSecond.prototype.equals = function(other) {
+        return this.julianDate.equals(other.julianDate) && (this.offset === other.offset);
+    };
+
+    /**
+     * Given two leap seconds, determines which comes before the other by comparing
+     * their respective Julian dates.
+     *
+     * @memberof LeapSecond
+     *
+     * @param {LeapSecond} leapSecond1 The first leap second to be compared.
+     * @param {LeapSecond} leapSecond2 The second leap second to be compared.
+     *
+     * @return {Number} A negative value if the first leap second is earlier than the second,
+     *                  a positive value if the first leap second is later than the second, or
+     *                  zero if the two leap seconds are equal (ignoring their offsets).
+     *
+     * @see JulianDate#lessThan
+     * @see JulianDate#isAfter
+     *
+     * @example
+     * var date = new Date('January 1, 2006 00:00:00 UTC');
+     * var leapSecond1 = new LeapSecond(JulianDate.fromDate(date), 33.0);
+     * var leapSecond2 = new LeapSecond(JulianDate.fromDate(date), 34.0);
+     * LeapSecond.compareLeapSecondDate(leapSecond1, leapSecond2);    // returns 0
+     */
+    LeapSecond.compareLeapSecondDate = function(leapSecond1, leapSecond2) {
+        var julianDayNum1 = leapSecond1.julianDate.getJulianDayNumber();
+        var julianDayNum2 = leapSecond2.julianDate.getJulianDayNumber();
+        if (julianDayNum1 !== julianDayNum2) {
+            return julianDayNum1 < julianDayNum2 ? -1 : 1;
+        }
+        var secondsOfDay1 = leapSecond1.julianDate.getSecondsOfDay();
+        var secondsOfDay2 = leapSecond2.julianDate.getSecondsOfDay();
+        if (secondsOfDay1 !== secondsOfDay2) {
+            return secondsOfDay1 < secondsOfDay2 ? -1 : 1;
+        }
+        return 0;
+    };
+
+    LeapSecond._leapSeconds = [];
+
+    return LeapSecond;
+});

data/app/assets/javascripts/Core/LinearApproximation.js

@@ -0,0 +1,98 @@
+/*global define*/
+define([
+        './DeveloperError'
+       ],function(
+         DeveloperError) {
+    "use strict";
+
+
+    /**
+     * Functions for performing linear interpolation.
+     * @exports LinearApproximation
+     *
+     * @see LagrangePolynomialApproximation
+     * @see HermitePolynomialApproximation
+     */
+    var LinearApproximation = {
+        type : 'Linear'
+    };
+
+    /**
+     * Given the desired degree, returns the number of data points required for interpolation.
+     *
+     * @memberof LinearApproximation
+     *
+     * @param degree The desired degree of interpolation.
+     *
+     * @exception {DeveloperError} Linear interpolation can only generate a first degree polynomial.
+     *
+     * @returns The number of required data points needed for the desired degree of interpolation.
+     */
+    LinearApproximation.getRequiredDataPoints = function(degree) {
+        if (degree !== 1) {
+            throw new DeveloperError('Linear interpolation can only generate a first degree polynomial.');
+        }
+        return 2;
+    };
+
+    /**
+     * <p>
+     * Interpolates values using the supplied interpolation algorithm.  The appropriate subset of input
+     * values to use for the interpolation is determined automatically from an interpolation given
+     * degree.
+     * </p>
+     * <p>
+     * The xTable array can contain any number of elements, and the appropriate subset will be
+     * selected according to the degree of interpolation requested.  For example, if degree is 5,
+     * the 6 elements surrounding x will be used for interpolation.  When using
+     * {@link LinearApproximation} the degree should be 1 since it always deals with only 2 elements
+     * surrounding x. The yTable array should contain a number of elements equal to:
+     * <code>xTable.length * yStride</code>.  If insufficient elements are provided
+     * to perform the requested degree of interpolation, the highest possible degree of interpolation
+     * will be performed.
+     * </p>
+     *
+     * @param {Number} x The independent variable for which the dependent variables will be interpolated.
+     *
+     * @param {Array} xTable The array of independent variables to use to interpolate.  The values
+     * in this array must be in increasing order and the same value must not occur twice in the array.
+     *
+     * @param {Array} yTable The array of dependent variables to use to interpolate.  For a set of three
+     * dependent values (p,q,w) and their derivatives (dp, dq, dw) at time 1 and time 2 this should be
+     * as follows: {p1, q1, w1, dp1, dq1, dw1, p2, q2, w2, dp2, dq2, dw2}.
+     *
+     * @param {Number} yStride The number of dependent variable values in yTable corresponding to
+     * each independent variable value in xTable.
+     *
+     * @returns An array of interpolated values.  The array contains at least yStride elements, each
+     * of which is an interpolated dependent variable value.
+     *
+     * @see LagrangePolynomialApproximation
+     * @see HermitePolynomialApproximation
+     *
+     *
+     * @memberof LinearApproximation
+     */
+    LinearApproximation.interpolateOrderZero = function(x, xTable, yTable, yStride) {
+        if (xTable.length !== 2) {
+            throw new DeveloperError('The xTable provided to the linear interpolator must have exactly two elements.');
+        } else if (yStride <= 0) {
+            throw new DeveloperError('There must be at least 1 dependent variable for each independent variable.');
+        }
+
+        var result = new Array(yStride), x0 = xTable[0], x1 = xTable[1], i, y0, y1;
+
+        for (i = 0; i < yStride; i++) {
+            //calculates the interpolated values
+
+            y0 = yTable[i];
+            y1 = yTable[i + yStride];
+
+            result[i] = (((y1 - y0) * x) + (x1 * y0) - (x0 * y1)) / (x1 - x0);
+        }
+
+        return result;
+    };
+
+    return LinearApproximation;
+});

data/app/assets/javascripts/Core/Math.js

@@ -0,0 +1,532 @@
+/*global define*/
+define([
+        './defaultValue',
+        './DeveloperError'
+       ], function(
+         defaultValue,
+         DeveloperError) {
+    "use strict";
+
+    /**
+     * Math functions.
+     * @exports CesiumMath
+     */
+    var CesiumMath = {};
+
+    /**
+     * 0.1
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON1 = 0.1;
+
+    /**
+     * 0.01
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON2 = 0.01;
+
+    /**
+     * 0.001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON3 = 0.001;
+
+    /**
+     * 0.0001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON4 = 0.0001;
+
+    /**
+     * 0.00001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON5 = 0.00001;
+
+    /**
+     * 0.000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON6 = 0.000001;
+
+    /**
+     * 0.0000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON7 = 0.0000001;
+
+    /**
+     * 0.00000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON8 = 0.00000001;
+
+    /**
+     * 0.000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON9 = 0.000000001;
+
+    /**
+     * 0.0000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON10 = 0.0000000001;
+
+    /**
+     * 0.00000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON11 = 0.00000000001;
+
+    /**
+     * 0.000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON12 = 0.000000000001;
+
+    /**
+     * 0.0000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON13 = 0.0000000000001;
+
+    /**
+     * 0.00000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON14 = 0.00000000000001;
+
+    /**
+     * 0.000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON15 = 0.000000000000001;
+
+    /**
+     * 0.0000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON16 = 0.0000000000000001;
+
+    /**
+     * 0.00000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON17 = 0.00000000000000001;
+
+    /**
+     * 0.000000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON18 = 0.000000000000000001;
+
+    /**
+     * 0.0000000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON19 = 0.0000000000000000001;
+
+    /**
+     * 0.00000000000000000001
+     * @constant
+     * @type Number
+     */
+    CesiumMath.EPSILON20 = 0.00000000000000000001;
+
+    /**
+     * 3.986004418e14
+     * @constant
+     * @type Number
+     */
+    CesiumMath.GRAVITATIONALPARAMETER = 3.986004418e14;
+
+    /**
+     * 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.
+     *
+     * @param {Number} value The value to return the sign of.
+     *
+     * @return {Number} The sign of value.
+     */
+    CesiumMath.sign = function(value) {
+        if (value > 0) {
+            return 1;
+        }
+        if (value < 0) {
+            return -1;
+        }
+
+        return 0;
+    };
+
+    /**
+     * Returns the hyperbolic sine of a {@code Number}.
+     * The hyperbolic sine of <em>value</em> is defined to be
+     * (<em>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></em>)/2.0
+     * where <i>e</i> is Euler's number, approximately 2.71828183.
+     *
+     * <p>Special cases:
+     *   <ul>
+     *     <li>If the argument is NaN, then the result is NaN.</li>
+     *
+     *     <li>If the argument is infinite, then the result is an infinity
+     *     with the same sign as the argument.</li>
+     *
+     *     <li>If the argument is zero, then the result is a zero with the
+     *     same sign as the argument.</li>
+     *   </ul>
+     *</p>
+     *
+     * @param value The number whose hyperbolic sine is to be returned.
+     *
+     * @return The hyperbolic sine of {@code value}.
+     *
+     */
+    CesiumMath.sinh = function(value) {
+        var part1 = Math.pow(Math.E, value);
+        var part2 = Math.pow(Math.E, -1.0 * value);
+
+        return (part1 - part2) * 0.5;
+    };
+
+    /**
+     * Returns the hyperbolic cosine of a {@code Number}.
+     * The hyperbolic cosine of <strong>value</strong> is defined to be
+     * (<em>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></em>)/2.0
+     * where <i>e</i> is Euler's number, approximately 2.71828183.
+     *
+     * <p>Special cases:
+     *   <ul>
+     *     <li>If the argument is NaN, then the result is NaN.</li>
+     *
+     *     <li>If the argument is infinite, then the result is positive infinity.</li>
+     *
+     *     <li>If the argument is zero, then the result is {@code 1.0}.</li>
+     *   </ul>
+     *</p>
+     *
+     * @param value The number whose hyperbolic cosine is to be returned.
+     *
+     * @return The hyperbolic cosine of {@code value}.
+     */
+    CesiumMath.cosh = function(value) {
+        var part1 = Math.pow(Math.E, value);
+        var part2 = Math.pow(Math.E, -1.0 * value);
+
+        return (part1 + part2) * 0.5;
+    };
+
+    /**
+     * DOC_TBA
+     */
+    CesiumMath.lerp = function(p, q, time) {
+        return ((1.0 - time) * p) + (time * q);
+    };
+
+    /**
+     * 1/pi
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_pi
+     */
+    CesiumMath.PI = Math.PI;
+
+    /**
+     * 1/pi
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_oneOverPi
+     */
+    CesiumMath.ONE_OVER_PI = 1.0 / Math.PI;
+
+    /**
+     * pi/2
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_piOverTwo
+     */
+    CesiumMath.PI_OVER_TWO = Math.PI * 0.5;
+
+    /**
+     * pi/3
+     * <br /><br />
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_piOverThree
+     */
+    CesiumMath.PI_OVER_THREE = Math.PI / 3.0;
+
+    /**
+     * pi/4
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_piOverFour
+     */
+    CesiumMath.PI_OVER_FOUR = Math.PI / 4.0;
+
+    /**
+     * pi/6
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_piOverSix
+     */
+    CesiumMath.PI_OVER_SIX = Math.PI / 6.0;
+
+    /**
+     * 3pi/2
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_threePiOver2
+     */
+    CesiumMath.THREE_PI_OVER_TWO = (3.0 * Math.PI) * 0.5;
+
+    /**
+     * 2pi
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_twoPi
+     */
+    CesiumMath.TWO_PI = 2.0 * Math.PI;
+
+    /**
+     * 1/2pi
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_oneOverTwoPi
+     */
+    CesiumMath.ONE_OVER_TWO_PI = 1.0 / (2.0 * Math.PI);
+
+    /**
+     * The number of radians in a degree.
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_radiansPerDegree
+     */
+    CesiumMath.RADIANS_PER_DEGREE = Math.PI / 180.0;
+
+    /**
+     * The number of degrees in a radian.
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_degreesPerRadian
+     */
+    CesiumMath.DEGREES_PER_RADIAN = 180.0 / Math.PI;
+
+    /**
+     * The number of radians in an arc second.
+     *
+     * @constant
+     * @type {Number}
+     * @see czm_radiansPerArcSecond
+     */
+    CesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600.0;
+
+    /**
+     * Converts degrees to radians.
+     * @param {Number} degrees The angle to convert in degrees.
+     * @return {Number} The corresponding angle in radians.
+     */
+    CesiumMath.toRadians = function(degrees) {
+        return degrees * CesiumMath.RADIANS_PER_DEGREE;
+    };
+
+    /**
+     * Converts radians to degrees.
+     * @param {Number} radians The angle to convert in radians.
+     * @return {Number} The corresponding angle in degrees.
+     */
+    CesiumMath.toDegrees = function(radians) {
+        return radians * CesiumMath.DEGREES_PER_RADIAN;
+    };
+
+    /**
+     * Converts a longitude value, in radians, to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
+     *
+     * @param {Number} angle The longitude value, in radians, to convert to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
+     *
+     * @return {Number} The equivalent longitude value in the range [<code>-Math.PI</code>, <code>Math.PI</code>).
+     *
+     * @example
+     * // Convert 270 degrees to -90 degrees longitude
+     * var longitude = CesiumMath.convertLongitudeRange(CesiumMath.toRadians(270.0));
+     */
+    CesiumMath.convertLongitudeRange = function(angle) {
+        var twoPi = CesiumMath.TWO_PI;
+
+        var simplified = angle - Math.floor(angle / twoPi) * twoPi;
+
+        if (simplified < -Math.PI) {
+            return simplified + twoPi;
+        }
+        if (simplified >= Math.PI) {
+            return simplified - twoPi;
+        }
+
+        return simplified;
+    };
+
+    /**
+     * Alters the value of input x such that <code>-CesiumMath.PI</code> <= x <= <code>CesiumMath.PI</code>
+     * @param {Number} angle in radians
+     * @return {Number} The angle in the range ()<code>-CesiumMath.PI</code>, <code>CesiumMath.PI</code>).
+     */
+    CesiumMath.negativePiToPi = function(x) {
+        var epsilon10 = CesiumMath.EPSILON10;
+        var pi = CesiumMath.PI;
+        var two_pi = CesiumMath.TWO_PI;
+        while (x < -(pi + epsilon10)) {
+            x += two_pi;
+        }
+        if (x < -pi) {
+            return -pi;
+        }
+        while (x > pi + epsilon10) {
+            x -= two_pi;
+        }
+        return x > pi ? pi : x;
+    };
+
+    /**
+     * DOC_TBA
+     */
+    CesiumMath.equalsEpsilon = function(left, right, epsilon) {
+        epsilon = epsilon || 0.0;
+        return Math.abs(left - right) <= epsilon;
+    };
+
+    var factorials = [1];
+
+    /**
+     * Computes the factorial of the provided number.
+     *
+     * @memberof CesiumMath
+     *
+     * @param {Number} n The number whose factorial is to be computed.
+     *
+     * @return {Number} The factorial of the provided number or undefined if the number is less than 0.
+     *
+     * @see <a href='http://en.wikipedia.org/wiki/Factorial'>Factorial on Wikipedia</a>.
+     *
+     * @example
+     * //Compute 7!, which is equal to 5040
+     * var computedFactorial = CesiumMath.factorial(7);
+     *
+     * @exception {DeveloperError} A number greater than or equal to 0 is required.
+     */
+    CesiumMath.factorial = function(n) {
+        if (typeof n !== 'number' || n < 0) {
+            throw new DeveloperError('A number greater than or equal to 0 is required.');
+        }
+
+        var length = factorials.length;
+        if (n >= length) {
+            var sum = factorials[length - 1];
+            for ( var i = length; i <= n; i++) {
+                factorials.push(sum * i);
+            }
+        }
+        return factorials[n];
+    };
+
+    /**
+     * Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.
+     *
+     * @memberof CesiumMath
+     *
+     * @param {Number} [n] The number to be incremented.
+     * @param {Number} [maximumValue] The maximum incremented value before rolling over to the minimum value.
+     * @param {Number} [minimumValue=0.0] The number reset to after the maximum value has been exceeded.
+     *
+     * @return {Number} The incremented number.
+     *
+     * @example
+     * var n = CesiumMath.incrementWrap(5, 10, 0); // returns 6
+     * var n = CesiumMath.incrementWrap(10, 10, 0); // returns 0
+     *
+     * @exception {DeveloperError} Maximum value must be greater than minimum value.
+     */
+    CesiumMath.incrementWrap = function(n, maximumValue, minimumValue) {
+        minimumValue = defaultValue(minimumValue, 0.0);
+
+        if (maximumValue <= minimumValue) {
+            throw new DeveloperError('Maximum value must be greater than minimum value.');
+        }
+
+        ++n;
+        if (n > maximumValue) {
+            n = minimumValue;
+        }
+        return n;
+    };
+
+    /**
+     * Determines if a positive integer is a power of two.
+     *
+     * @memberof CesiumMath
+     *
+     * @param {Number} n The positive integer to test.
+     *
+     * @return {Boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.
+     *
+     * @example
+     * var t = CesiumMath.isPowerOfTwo(16); // true
+     * var f = CesiumMath.isPowerOfTwo(20); // false
+     *
+     * @exception {DeveloperError} A number greater than or equal to 0 is required.
+     */
+    CesiumMath.isPowerOfTwo = function(n) {
+        if (typeof n !== 'number' || n < 0) {
+            throw new DeveloperError('A number greater than or equal to 0 is required.');
+        }
+
+        var m = n | 0;
+        return (m !== 0) && ((m & (m - 1)) === 0);
+    };
+
+    /**
+     * Constraint a value to lie between two values.
+     *
+     * @memberof CesiumMath
+     *
+     * @param {Number} value The value to constrain.
+     * @param {Number} min The minimum value.
+     * @param {Number} max The maximum value.
+     * @returns The value clamped so that min <= value <= max.
+     */
+    CesiumMath.clamp = function(value, min, max) {
+        return value < min ? min : value > max ? max : value;
+    };
+
+    return CesiumMath;
+});