{"version":3,"file":"Math-1124a290.js","sources":["../../../../Source/ThirdParty/mersenne-twister.js","../../../../Source/Core/Math.js"],"sourcesContent":["/*\n  I've wrapped Makoto Matsumoto and Takuji Nishimura's code in a namespace\n  so it's better encapsulated. Now you can have multiple random number generators\n  and they won't stomp all over eachother's state.\n\n  If you want to use this as a substitute for Math.random(), use the random()\n  method like so:\n\n  var m = new MersenneTwister();\n  var randomNumber = m.random();\n\n  You can also call the other genrand_{foo}() methods on the instance.\n\n  If you want to use a specific seed in order to get a repeatable random\n  sequence, pass an integer into the constructor:\n\n  var m = new MersenneTwister(123);\n\n  and that will always produce the same random sequence.\n\n  Sean McCullough (banksean@gmail.com)\n*/\n\n/*\n   A C-program for MT19937, with initialization improved 2002/1/26.\n   Coded by Takuji Nishimura and Makoto Matsumoto.\n\n   Before using, initialize the state by using init_genrand(seed)\n   or init_by_array(init_key, key_length).\n*/\n/**\n@license\nmersenne-twister.js - https://gist.github.com/banksean/300494\n\n   Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,\n   All rights reserved.\n\n   Redistribution and use in source and binary forms, with or without\n   modification, are permitted provided that the following conditions\n   are met:\n\n     1. Redistributions of source code must retain the above copyright\n        notice, this list of conditions and the following disclaimer.\n\n     2. Redistributions in binary form must reproduce the above copyright\n        notice, this list of conditions and the following disclaimer in the\n        documentation and/or other materials provided with the distribution.\n\n     3. The names of its contributors may not be used to endorse or promote\n        products derived from this software without specific prior written\n        permission.\n\n   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n   \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR\n   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR\n   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\n   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,\n   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR\n   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF\n   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING\n   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS\n   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n*/\n/*\n   Any feedback is very welcome.\n   http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html\n   email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)\n*/\n\nfunction MersenneTwister(seed) {\n  if (seed == undefined) {\n    seed = new Date().getTime();\n  }\n  /* Period parameters */\n  this.N = 624;\n  this.M = 397;\n  this.MATRIX_A = 0x9908b0df;   /* constant vector a */\n  this.UPPER_MASK = 0x80000000; /* most significant w-r bits */\n  this.LOWER_MASK = 0x7fffffff; /* least significant r bits */\n\n  this.mt = new Array(this.N); /* the array for the state vector */\n  this.mti=this.N+1; /* mti==N+1 means mt[N] is not initialized */\n\n  this.init_genrand(seed);\n}\n\n/* initializes mt[N] with a seed */\nMersenneTwister.prototype.init_genrand = function(s) {\n  this.mt[0] = s >>> 0;\n  for (this.mti=1; this.mti<this.N; this.mti++) {\n      var s = this.mt[this.mti-1] ^ (this.mt[this.mti-1] >>> 30);\n   this.mt[this.mti] = (((((s & 0xffff0000) >>> 16) * 1812433253) << 16) + (s & 0x0000ffff) * 1812433253)\n  + this.mti;\n      /* See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier. */\n      /* In the previous versions, MSBs of the seed affect   */\n      /* only MSBs of the array mt[].                        */\n      /* 2002/01/09 modified by Makoto Matsumoto             */\n      this.mt[this.mti] >>>= 0;\n      /* for >32 bit machines */\n  }\n}\n\n/* initialize by an array with array-length */\n/* init_key is the array for initializing keys */\n/* key_length is its length */\n/* slight change for C++, 2004/2/26 */\n//MersenneTwister.prototype.init_by_array = function(init_key, key_length) {\n//  var i, j, k;\n//  this.init_genrand(19650218);\n//  i=1; j=0;\n//  k = (this.N>key_length ? this.N : key_length);\n//  for (; k; k--) {\n//    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30)\n//    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1664525) << 16) + ((s & 0x0000ffff) * 1664525)))\n//      + init_key[j] + j; /* non linear */\n//    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */\n//    i++; j++;\n//    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }\n//    if (j>=key_length) j=0;\n//  }\n//  for (k=this.N-1; k; k--) {\n//    var s = this.mt[i-1] ^ (this.mt[i-1] >>> 30);\n//    this.mt[i] = (this.mt[i] ^ (((((s & 0xffff0000) >>> 16) * 1566083941) << 16) + (s & 0x0000ffff) * 1566083941))\n//      - i; /* non linear */\n//    this.mt[i] >>>= 0; /* for WORDSIZE > 32 machines */\n//    i++;\n//    if (i>=this.N) { this.mt[0] = this.mt[this.N-1]; i=1; }\n//  }\n//\n//  this.mt[0] = 0x80000000; /* MSB is 1; assuring non-zero initial array */\n//}\n\n/* generates a random number on [0,0xffffffff]-interval */\nMersenneTwister.prototype.genrand_int32 = function() {\n  var y;\n  var mag01 = new Array(0x0, this.MATRIX_A);\n  /* mag01[x] = x * MATRIX_A  for x=0,1 */\n\n  if (this.mti >= this.N) { /* generate N words at one time */\n    var kk;\n\n    if (this.mti == this.N+1)   /* if init_genrand() has not been called, */\n      this.init_genrand(5489); /* a default initial seed is used */\n\n    for (kk=0;kk<this.N-this.M;kk++) {\n      y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);\n      this.mt[kk] = this.mt[kk+this.M] ^ (y >>> 1) ^ mag01[y & 0x1];\n    }\n    for (;kk<this.N-1;kk++) {\n      y = (this.mt[kk]&this.UPPER_MASK)|(this.mt[kk+1]&this.LOWER_MASK);\n      this.mt[kk] = this.mt[kk+(this.M-this.N)] ^ (y >>> 1) ^ mag01[y & 0x1];\n    }\n    y = (this.mt[this.N-1]&this.UPPER_MASK)|(this.mt[0]&this.LOWER_MASK);\n    this.mt[this.N-1] = this.mt[this.M-1] ^ (y >>> 1) ^ mag01[y & 0x1];\n\n    this.mti = 0;\n  }\n\n  y = this.mt[this.mti++];\n\n  /* Tempering */\n  y ^= (y >>> 11);\n  y ^= (y << 7) & 0x9d2c5680;\n  y ^= (y << 15) & 0xefc60000;\n  y ^= (y >>> 18);\n\n  return y >>> 0;\n}\n\n/* generates a random number on [0,0x7fffffff]-interval */\n//MersenneTwister.prototype.genrand_int31 = function() {\n//  return (this.genrand_int32()>>>1);\n//}\n\n/* generates a random number on [0,1]-real-interval */\n//MersenneTwister.prototype.genrand_real1 = function() {\n//  return this.genrand_int32()*(1.0/4294967295.0);\n//  /* divided by 2^32-1 */\n//}\n\n/* generates a random number on [0,1)-real-interval */\nMersenneTwister.prototype.random = function() {\n  return this.genrand_int32()*(1.0/4294967296.0);\n  /* divided by 2^32 */\n}\n\n/* generates a random number on (0,1)-real-interval */\n//MersenneTwister.prototype.genrand_real3 = function() {\n//  return (this.genrand_int32() + 0.5)*(1.0/4294967296.0);\n//  /* divided by 2^32 */\n//}\n\n/* generates a random number on [0,1) with 53-bit resolution*/\n//MersenneTwister.prototype.genrand_res53 = function() {\n//  var a=this.genrand_int32()>>>5, b=this.genrand_int32()>>>6;\n//  return(a*67108864.0+b)*(1.0/9007199254740992.0);\n//}\n\n/* These real versions are due to Isaku Wada, 2002/01/09 added */\n\nexport default MersenneTwister;\n","import MersenneTwister from \"../ThirdParty/mersenne-twister.js\";\nimport Check from \"./Check.js\";\nimport defaultValue from \"./defaultValue.js\";\nimport defined from \"./defined.js\";\nimport DeveloperError from \"./DeveloperError.js\";\n\n/**\n * Math functions.\n *\n * @exports CesiumMath\n * @alias Math\n */\nvar CesiumMath = {};\n\n/**\n * 0.1\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON1 = 0.1;\n\n/**\n * 0.01\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON2 = 0.01;\n\n/**\n * 0.001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON3 = 0.001;\n\n/**\n * 0.0001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON4 = 0.0001;\n\n/**\n * 0.00001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON5 = 0.00001;\n\n/**\n * 0.000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON6 = 0.000001;\n\n/**\n * 0.0000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON7 = 0.0000001;\n\n/**\n * 0.00000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON8 = 0.00000001;\n\n/**\n * 0.000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON9 = 0.000000001;\n\n/**\n * 0.0000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON10 = 0.0000000001;\n\n/**\n * 0.00000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON11 = 0.00000000001;\n\n/**\n * 0.000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON12 = 0.000000000001;\n\n/**\n * 0.0000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON13 = 0.0000000000001;\n\n/**\n * 0.00000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON14 = 0.00000000000001;\n\n/**\n * 0.000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON15 = 0.000000000000001;\n\n/**\n * 0.0000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON16 = 0.0000000000000001;\n\n/**\n * 0.00000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON17 = 0.00000000000000001;\n\n/**\n * 0.000000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON18 = 0.000000000000000001;\n\n/**\n * 0.0000000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON19 = 0.0000000000000000001;\n\n/**\n * 0.00000000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON20 = 0.00000000000000000001;\n\n/**\n * 0.000000000000000000001\n * @type {Number}\n * @constant\n */\nCesiumMath.EPSILON21 = 0.000000000000000000001;\n\n/**\n * The gravitational parameter of the Earth in meters cubed\n * per second squared as defined by the WGS84 model: 3.986004418e14\n * @type {Number}\n * @constant\n */\nCesiumMath.GRAVITATIONALPARAMETER = 3.986004418e14;\n\n/**\n * Radius of the sun in meters: 6.955e8\n * @type {Number}\n * @constant\n */\nCesiumMath.SOLAR_RADIUS = 6.955e8;\n\n/**\n * The mean radius of the moon, according to the \"Report of the IAU/IAG Working Group on\n * Cartographic Coordinates and Rotational Elements of the Planets and satellites: 2000\",\n * Celestial Mechanics 82: 83-110, 2002.\n * @type {Number}\n * @constant\n */\nCesiumMath.LUNAR_RADIUS = 1737400.0;\n\n/**\n * 64 * 1024\n * @type {Number}\n * @constant\n */\nCesiumMath.SIXTY_FOUR_KILOBYTES = 64 * 1024;\n\n/**\n * 4 * 1024 * 1024 * 1024\n * @type {Number}\n * @constant\n */\nCesiumMath.FOUR_GIGABYTES = 4 * 1024 * 1024 * 1024;\n\n/**\n * Returns the sign of the value; 1 if the value is positive, -1 if the value is\n * negative, or 0 if the value is 0.\n *\n * @function\n * @param {Number} value The value to return the sign of.\n * @returns {Number} The sign of value.\n */\nCesiumMath.sign = defaultValue(Math.sign, function sign(value) {\n  value = +value; // coerce to number\n  if (value === 0 || value !== value) {\n    // zero or NaN\n    return value;\n  }\n  return value > 0 ? 1 : -1;\n});\n\n/**\n * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.\n * This is similar to {@link CesiumMath#sign} except that returns 1.0 instead of\n * 0.0 when the input value is 0.0.\n * @param {Number} value The value to return the sign of.\n * @returns {Number} The sign of value.\n */\nCesiumMath.signNotZero = function (value) {\n  return value < 0.0 ? -1.0 : 1.0;\n};\n\n/**\n * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum]\n * @param {Number} value The scalar value in the range [-1.0, 1.0]\n * @param {Number} [rangeMaximum=255] The maximum value in the mapped range, 255 by default.\n * @returns {Number} A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.\n *\n * @see CesiumMath.fromSNorm\n */\nCesiumMath.toSNorm = function (value, rangeMaximum) {\n  rangeMaximum = defaultValue(rangeMaximum, 255);\n  return Math.round(\n    (CesiumMath.clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum\n  );\n};\n\n/**\n * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].\n * @param {Number} value SNORM value in the range [0, rangeMaximum]\n * @param {Number} [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.\n * @returns {Number} Scalar in the range [-1.0, 1.0].\n *\n * @see CesiumMath.toSNorm\n */\nCesiumMath.fromSNorm = function (value, rangeMaximum) {\n  rangeMaximum = defaultValue(rangeMaximum, 255);\n  return (\n    (CesiumMath.clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0\n  );\n};\n\n/**\n * Converts a scalar value in the range [rangeMinimum, rangeMaximum] to a scalar in the range [0.0, 1.0]\n * @param {Number} value The scalar value in the range [rangeMinimum, rangeMaximum]\n * @param {Number} rangeMinimum The minimum value in the mapped range.\n * @param {Number} rangeMaximum The maximum value in the mapped range.\n * @returns {Number} A scalar value, where rangeMinimum maps to 0.0 and rangeMaximum maps to 1.0.\n */\nCesiumMath.normalize = function (value, rangeMinimum, rangeMaximum) {\n  rangeMaximum = Math.max(rangeMaximum - rangeMinimum, 0.0);\n  return rangeMaximum === 0.0\n    ? 0.0\n    : CesiumMath.clamp((value - rangeMinimum) / rangeMaximum, 0.0, 1.0);\n};\n\n/**\n * Returns the hyperbolic sine of a number.\n * The hyperbolic sine of <em>value</em> is defined to be\n * (<em>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></em>)/2.0\n * where <i>e</i> is Euler's number, approximately 2.71828183.\n *\n * <p>Special cases:\n *   <ul>\n *     <li>If the argument is NaN, then the result is NaN.</li>\n *\n *     <li>If the argument is infinite, then the result is an infinity\n *     with the same sign as the argument.</li>\n *\n *     <li>If the argument is zero, then the result is a zero with the\n *     same sign as the argument.</li>\n *   </ul>\n *</p>\n *\n * @function\n * @param {Number} value The number whose hyperbolic sine is to be returned.\n * @returns {Number} The hyperbolic sine of <code>value</code>.\n */\nCesiumMath.sinh = defaultValue(Math.sinh, function sinh(value) {\n  return (Math.exp(value) - Math.exp(-value)) / 2.0;\n});\n\n/**\n * Returns the hyperbolic cosine of a number.\n * The hyperbolic cosine of <strong>value</strong> is defined to be\n * (<em>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></em>)/2.0\n * where <i>e</i> is Euler's number, approximately 2.71828183.\n *\n * <p>Special cases:\n *   <ul>\n *     <li>If the argument is NaN, then the result is NaN.</li>\n *\n *     <li>If the argument is infinite, then the result is positive infinity.</li>\n *\n *     <li>If the argument is zero, then the result is 1.0.</li>\n *   </ul>\n *</p>\n *\n * @function\n * @param {Number} value The number whose hyperbolic cosine is to be returned.\n * @returns {Number} The hyperbolic cosine of <code>value</code>.\n */\nCesiumMath.cosh = defaultValue(Math.cosh, function cosh(value) {\n  return (Math.exp(value) + Math.exp(-value)) / 2.0;\n});\n\n/**\n * Computes the linear interpolation of two values.\n *\n * @param {Number} p The start value to interpolate.\n * @param {Number} q The end value to interpolate.\n * @param {Number} time The time of interpolation generally in the range <code>[0.0, 1.0]</code>.\n * @returns {Number} The linearly interpolated value.\n *\n * @example\n * var n = Cesium.Math.lerp(0.0, 2.0, 0.5); // returns 1.0\n */\nCesiumMath.lerp = function (p, q, time) {\n  return (1.0 - time) * p + time * q;\n};\n\n/**\n * pi\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.PI = Math.PI;\n\n/**\n * 1/pi\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.ONE_OVER_PI = 1.0 / Math.PI;\n\n/**\n * pi/2\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.PI_OVER_TWO = Math.PI / 2.0;\n\n/**\n * pi/3\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.PI_OVER_THREE = Math.PI / 3.0;\n\n/**\n * pi/4\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.PI_OVER_FOUR = Math.PI / 4.0;\n\n/**\n * pi/6\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.PI_OVER_SIX = Math.PI / 6.0;\n\n/**\n * 3pi/2\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.THREE_PI_OVER_TWO = (3.0 * Math.PI) / 2.0;\n\n/**\n * 2pi\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.TWO_PI = 2.0 * Math.PI;\n\n/**\n * 1/2pi\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.ONE_OVER_TWO_PI = 1.0 / (2.0 * Math.PI);\n\n/**\n * The number of radians in a degree.\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.RADIANS_PER_DEGREE = Math.PI / 180.0;\n\n/**\n * The number of degrees in a radian.\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.DEGREES_PER_RADIAN = 180.0 / Math.PI;\n\n/**\n * The number of radians in an arc second.\n *\n * @type {Number}\n * @constant\n */\nCesiumMath.RADIANS_PER_ARCSECOND = CesiumMath.RADIANS_PER_DEGREE / 3600.0;\n\n/**\n * Converts degrees to radians.\n * @param {Number} degrees The angle to convert in degrees.\n * @returns {Number} The corresponding angle in radians.\n */\nCesiumMath.toRadians = function (degrees) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(degrees)) {\n    throw new DeveloperError(\"degrees is required.\");\n  }\n  //>>includeEnd('debug');\n  return degrees * CesiumMath.RADIANS_PER_DEGREE;\n};\n\n/**\n * Converts radians to degrees.\n * @param {Number} radians The angle to convert in radians.\n * @returns {Number} The corresponding angle in degrees.\n */\nCesiumMath.toDegrees = function (radians) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(radians)) {\n    throw new DeveloperError(\"radians is required.\");\n  }\n  //>>includeEnd('debug');\n  return radians * CesiumMath.DEGREES_PER_RADIAN;\n};\n\n/**\n * Converts a longitude value, in radians, to the range [<code>-Math.PI</code>, <code>Math.PI</code>).\n *\n * @param {Number} angle The longitude value, in radians, to convert to the range [<code>-Math.PI</code>, <code>Math.PI</code>).\n * @returns {Number} The equivalent longitude value in the range [<code>-Math.PI</code>, <code>Math.PI</code>).\n *\n * @example\n * // Convert 270 degrees to -90 degrees longitude\n * var longitude = Cesium.Math.convertLongitudeRange(Cesium.Math.toRadians(270.0));\n */\nCesiumMath.convertLongitudeRange = function (angle) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(angle)) {\n    throw new DeveloperError(\"angle is required.\");\n  }\n  //>>includeEnd('debug');\n  var twoPi = CesiumMath.TWO_PI;\n\n  var simplified = angle - Math.floor(angle / twoPi) * twoPi;\n\n  if (simplified < -Math.PI) {\n    return simplified + twoPi;\n  }\n  if (simplified >= Math.PI) {\n    return simplified - twoPi;\n  }\n\n  return simplified;\n};\n\n/**\n * Convenience function that clamps a latitude value, in radians, to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).\n * Useful for sanitizing data before use in objects requiring correct range.\n *\n * @param {Number} angle The latitude value, in radians, to clamp to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).\n * @returns {Number} The latitude value clamped to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).\n *\n * @example\n * // Clamp 108 degrees latitude to 90 degrees latitude\n * var latitude = Cesium.Math.clampToLatitudeRange(Cesium.Math.toRadians(108.0));\n */\nCesiumMath.clampToLatitudeRange = function (angle) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(angle)) {\n    throw new DeveloperError(\"angle is required.\");\n  }\n  //>>includeEnd('debug');\n\n  return CesiumMath.clamp(\n    angle,\n    -1 * CesiumMath.PI_OVER_TWO,\n    CesiumMath.PI_OVER_TWO\n  );\n};\n\n/**\n * Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.\n *\n * @param {Number} angle in radians\n * @returns {Number} The angle in the range [<code>-CesiumMath.PI</code>, <code>CesiumMath.PI</code>].\n */\nCesiumMath.negativePiToPi = function (angle) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(angle)) {\n    throw new DeveloperError(\"angle is required.\");\n  }\n  //>>includeEnd('debug');\n  return CesiumMath.zeroToTwoPi(angle + CesiumMath.PI) - CesiumMath.PI;\n};\n\n/**\n * Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.\n *\n * @param {Number} angle in radians\n * @returns {Number} The angle in the range [0, <code>CesiumMath.TWO_PI</code>].\n */\nCesiumMath.zeroToTwoPi = function (angle) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(angle)) {\n    throw new DeveloperError(\"angle is required.\");\n  }\n  //>>includeEnd('debug');\n  var mod = CesiumMath.mod(angle, CesiumMath.TWO_PI);\n  if (\n    Math.abs(mod) < CesiumMath.EPSILON14 &&\n    Math.abs(angle) > CesiumMath.EPSILON14\n  ) {\n    return CesiumMath.TWO_PI;\n  }\n  return mod;\n};\n\n/**\n * The modulo operation that also works for negative dividends.\n *\n * @param {Number} m The dividend.\n * @param {Number} n The divisor.\n * @returns {Number} The remainder.\n */\nCesiumMath.mod = function (m, n) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(m)) {\n    throw new DeveloperError(\"m is required.\");\n  }\n  if (!defined(n)) {\n    throw new DeveloperError(\"n is required.\");\n  }\n  //>>includeEnd('debug');\n  return ((m % n) + n) % n;\n};\n\n/**\n * Determines if two values are equal using an absolute or relative tolerance test. This is useful\n * to avoid problems due to roundoff error when comparing floating-point values directly. The values are\n * first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed.\n * Use this test if you are unsure of the magnitudes of left and right.\n *\n * @param {Number} left The first value to compare.\n * @param {Number} right The other value to compare.\n * @param {Number} [relativeEpsilon=0] The maximum inclusive delta between <code>left</code> and <code>right</code> for the relative tolerance test.\n * @param {Number} [absoluteEpsilon=relativeEpsilon] The maximum inclusive delta between <code>left</code> and <code>right</code> for the absolute tolerance test.\n * @returns {Boolean} <code>true</code> if the values are equal within the epsilon; otherwise, <code>false</code>.\n *\n * @example\n * var a = Cesium.Math.equalsEpsilon(0.0, 0.01, Cesium.Math.EPSILON2); // true\n * var b = Cesium.Math.equalsEpsilon(0.0, 0.1, Cesium.Math.EPSILON2);  // false\n * var c = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON7); // true\n * var d = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON9); // false\n */\nCesiumMath.equalsEpsilon = function (\n  left,\n  right,\n  relativeEpsilon,\n  absoluteEpsilon\n) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(left)) {\n    throw new DeveloperError(\"left is required.\");\n  }\n  if (!defined(right)) {\n    throw new DeveloperError(\"right is required.\");\n  }\n  //>>includeEnd('debug');\n\n  relativeEpsilon = defaultValue(relativeEpsilon, 0.0);\n  absoluteEpsilon = defaultValue(absoluteEpsilon, relativeEpsilon);\n  var absDiff = Math.abs(left - right);\n  return (\n    absDiff <= absoluteEpsilon ||\n    absDiff <= relativeEpsilon * Math.max(Math.abs(left), Math.abs(right))\n  );\n};\n\n/**\n * Determines if the left value is less than the right value. If the two values are within\n * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns false.\n *\n * @param {Number} left The first number to compare.\n * @param {Number} right The second number to compare.\n * @param {Number} absoluteEpsilon The absolute epsilon to use in comparison.\n * @returns {Boolean} <code>true</code> if <code>left</code> is less than <code>right</code> by more than\n *          <code>absoluteEpsilon<code>. <code>false</code> if <code>left</code> is greater or if the two\n *          values are nearly equal.\n */\nCesiumMath.lessThan = function (left, right, absoluteEpsilon) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(left)) {\n    throw new DeveloperError(\"first is required.\");\n  }\n  if (!defined(right)) {\n    throw new DeveloperError(\"second is required.\");\n  }\n  if (!defined(absoluteEpsilon)) {\n    throw new DeveloperError(\"relativeEpsilon is required.\");\n  }\n  //>>includeEnd('debug');\n  return left - right < -absoluteEpsilon;\n};\n\n/**\n * Determines if the left value is less than or equal to the right value. If the two values are within\n * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns true.\n *\n * @param {Number} left The first number to compare.\n * @param {Number} right The second number to compare.\n * @param {Number} absoluteEpsilon The absolute epsilon to use in comparison.\n * @returns {Boolean} <code>true</code> if <code>left</code> is less than <code>right</code> or if the\n *          the values are nearly equal.\n */\nCesiumMath.lessThanOrEquals = function (left, right, absoluteEpsilon) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(left)) {\n    throw new DeveloperError(\"first is required.\");\n  }\n  if (!defined(right)) {\n    throw new DeveloperError(\"second is required.\");\n  }\n  if (!defined(absoluteEpsilon)) {\n    throw new DeveloperError(\"relativeEpsilon is required.\");\n  }\n  //>>includeEnd('debug');\n  return left - right < absoluteEpsilon;\n};\n\n/**\n * Determines if the left value is greater the right value. If the two values are within\n * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns false.\n *\n * @param {Number} left The first number to compare.\n * @param {Number} right The second number to compare.\n * @param {Number} absoluteEpsilon The absolute epsilon to use in comparison.\n * @returns {Boolean} <code>true</code> if <code>left</code> is greater than <code>right</code> by more than\n *          <code>absoluteEpsilon<code>. <code>false</code> if <code>left</code> is less or if the two\n *          values are nearly equal.\n */\nCesiumMath.greaterThan = function (left, right, absoluteEpsilon) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(left)) {\n    throw new DeveloperError(\"first is required.\");\n  }\n  if (!defined(right)) {\n    throw new DeveloperError(\"second is required.\");\n  }\n  if (!defined(absoluteEpsilon)) {\n    throw new DeveloperError(\"relativeEpsilon is required.\");\n  }\n  //>>includeEnd('debug');\n  return left - right > absoluteEpsilon;\n};\n\n/**\n * Determines if the left value is greater than or equal to the right value. If the two values are within\n * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns true.\n *\n * @param {Number} left The first number to compare.\n * @param {Number} right The second number to compare.\n * @param {Number} absoluteEpsilon The absolute epsilon to use in comparison.\n * @returns {Boolean} <code>true</code> if <code>left</code> is greater than <code>right</code> or if the\n *          the values are nearly equal.\n */\nCesiumMath.greaterThanOrEquals = function (left, right, absoluteEpsilon) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(left)) {\n    throw new DeveloperError(\"first is required.\");\n  }\n  if (!defined(right)) {\n    throw new DeveloperError(\"second is required.\");\n  }\n  if (!defined(absoluteEpsilon)) {\n    throw new DeveloperError(\"relativeEpsilon is required.\");\n  }\n  //>>includeEnd('debug');\n  return left - right > -absoluteEpsilon;\n};\n\nvar factorials = [1];\n\n/**\n * Computes the factorial of the provided number.\n *\n * @param {Number} n The number whose factorial is to be computed.\n * @returns {Number} The factorial of the provided number or undefined if the number is less than 0.\n *\n * @exception {DeveloperError} A number greater than or equal to 0 is required.\n *\n *\n * @example\n * //Compute 7!, which is equal to 5040\n * var computedFactorial = Cesium.Math.factorial(7);\n *\n * @see {@link http://en.wikipedia.org/wiki/Factorial|Factorial on Wikipedia}\n */\nCesiumMath.factorial = function (n) {\n  //>>includeStart('debug', pragmas.debug);\n  if (typeof n !== \"number\" || n < 0) {\n    throw new DeveloperError(\n      \"A number greater than or equal to 0 is required.\"\n    );\n  }\n  //>>includeEnd('debug');\n\n  var length = factorials.length;\n  if (n >= length) {\n    var sum = factorials[length - 1];\n    for (var i = length; i <= n; i++) {\n      var next = sum * i;\n      factorials.push(next);\n      sum = next;\n    }\n  }\n  return factorials[n];\n};\n\n/**\n * Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.\n *\n * @param {Number} [n] The number to be incremented.\n * @param {Number} [maximumValue] The maximum incremented value before rolling over to the minimum value.\n * @param {Number} [minimumValue=0.0] The number reset to after the maximum value has been exceeded.\n * @returns {Number} The incremented number.\n *\n * @exception {DeveloperError} Maximum value must be greater than minimum value.\n *\n * @example\n * var n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6\n * var n = Cesium.Math.incrementWrap(10, 10, 0); // returns 0\n */\nCesiumMath.incrementWrap = function (n, maximumValue, minimumValue) {\n  minimumValue = defaultValue(minimumValue, 0.0);\n\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(n)) {\n    throw new DeveloperError(\"n is required.\");\n  }\n  if (maximumValue <= minimumValue) {\n    throw new DeveloperError(\"maximumValue must be greater than minimumValue.\");\n  }\n  //>>includeEnd('debug');\n\n  ++n;\n  if (n > maximumValue) {\n    n = minimumValue;\n  }\n  return n;\n};\n\n/**\n * Determines if a positive integer is a power of two.\n *\n * @param {Number} n The positive integer to test.\n * @returns {Boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.\n *\n * @exception {DeveloperError} A number greater than or equal to 0 is required.\n *\n * @example\n * var t = Cesium.Math.isPowerOfTwo(16); // true\n * var f = Cesium.Math.isPowerOfTwo(20); // false\n */\nCesiumMath.isPowerOfTwo = function (n) {\n  //>>includeStart('debug', pragmas.debug);\n  if (typeof n !== \"number\" || n < 0) {\n    throw new DeveloperError(\n      \"A number greater than or equal to 0 is required.\"\n    );\n  }\n  //>>includeEnd('debug');\n\n  return n !== 0 && (n & (n - 1)) === 0;\n};\n\n/**\n * Computes the next power-of-two integer greater than or equal to the provided positive integer.\n *\n * @param {Number} n The positive integer to test.\n * @returns {Number} The next power-of-two integer.\n *\n * @exception {DeveloperError} A number greater than or equal to 0 is required.\n *\n * @example\n * var n = Cesium.Math.nextPowerOfTwo(29); // 32\n * var m = Cesium.Math.nextPowerOfTwo(32); // 32\n */\nCesiumMath.nextPowerOfTwo = function (n) {\n  //>>includeStart('debug', pragmas.debug);\n  if (typeof n !== \"number\" || n < 0) {\n    throw new DeveloperError(\n      \"A number greater than or equal to 0 is required.\"\n    );\n  }\n  //>>includeEnd('debug');\n\n  // From http://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2\n  --n;\n  n |= n >> 1;\n  n |= n >> 2;\n  n |= n >> 4;\n  n |= n >> 8;\n  n |= n >> 16;\n  ++n;\n\n  return n;\n};\n\n/**\n * Constraint a value to lie between two values.\n *\n * @param {Number} value The value to constrain.\n * @param {Number} min The minimum value.\n * @param {Number} max The maximum value.\n * @returns {Number} The value clamped so that min <= value <= max.\n */\nCesiumMath.clamp = function (value, min, max) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(value)) {\n    throw new DeveloperError(\"value is required\");\n  }\n  if (!defined(min)) {\n    throw new DeveloperError(\"min is required.\");\n  }\n  if (!defined(max)) {\n    throw new DeveloperError(\"max is required.\");\n  }\n  //>>includeEnd('debug');\n  return value < min ? min : value > max ? max : value;\n};\n\nvar randomNumberGenerator = new MersenneTwister();\n\n/**\n * Sets the seed used by the random number generator\n * in {@link CesiumMath#nextRandomNumber}.\n *\n * @param {Number} seed An integer used as the seed.\n */\nCesiumMath.setRandomNumberSeed = function (seed) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(seed)) {\n    throw new DeveloperError(\"seed is required.\");\n  }\n  //>>includeEnd('debug');\n\n  randomNumberGenerator = new MersenneTwister(seed);\n};\n\n/**\n * Generates a random floating point number in the range of [0.0, 1.0)\n * using a Mersenne twister.\n *\n * @returns {Number} A random number in the range of [0.0, 1.0).\n *\n * @see CesiumMath.setRandomNumberSeed\n * @see {@link http://en.wikipedia.org/wiki/Mersenne_twister|Mersenne twister on Wikipedia}\n */\nCesiumMath.nextRandomNumber = function () {\n  return randomNumberGenerator.random();\n};\n\n/**\n * Generates a random number between two numbers.\n *\n * @param {Number} min The minimum value.\n * @param {Number} max The maximum value.\n * @returns {Number} A random number between the min and max.\n */\nCesiumMath.randomBetween = function (min, max) {\n  return CesiumMath.nextRandomNumber() * (max - min) + min;\n};\n\n/**\n * Computes <code>Math.acos(value)</code>, but first clamps <code>value</code> to the range [-1.0, 1.0]\n * so that the function will never return NaN.\n *\n * @param {Number} value The value for which to compute acos.\n * @returns {Number} 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,\n *          whichever is closer, if the value is outside the range.\n */\nCesiumMath.acosClamped = function (value) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(value)) {\n    throw new DeveloperError(\"value is required.\");\n  }\n  //>>includeEnd('debug');\n  return Math.acos(CesiumMath.clamp(value, -1.0, 1.0));\n};\n\n/**\n * Computes <code>Math.asin(value)</code>, but first clamps <code>value</code> to the range [-1.0, 1.0]\n * so that the function will never return NaN.\n *\n * @param {Number} value The value for which to compute asin.\n * @returns {Number} 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,\n *          whichever is closer, if the value is outside the range.\n */\nCesiumMath.asinClamped = function (value) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(value)) {\n    throw new DeveloperError(\"value is required.\");\n  }\n  //>>includeEnd('debug');\n  return Math.asin(CesiumMath.clamp(value, -1.0, 1.0));\n};\n\n/**\n * Finds the chord length between two points given the circle's radius and the angle between the points.\n *\n * @param {Number} angle The angle between the two points.\n * @param {Number} radius The radius of the circle.\n * @returns {Number} The chord length.\n */\nCesiumMath.chordLength = function (angle, radius) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(angle)) {\n    throw new DeveloperError(\"angle is required.\");\n  }\n  if (!defined(radius)) {\n    throw new DeveloperError(\"radius is required.\");\n  }\n  //>>includeEnd('debug');\n  return 2.0 * radius * Math.sin(angle * 0.5);\n};\n\n/**\n * Finds the logarithm of a number to a base.\n *\n * @param {Number} number The number.\n * @param {Number} base The base.\n * @returns {Number} The result.\n */\nCesiumMath.logBase = function (number, base) {\n  //>>includeStart('debug', pragmas.debug);\n  if (!defined(number)) {\n    throw new DeveloperError(\"number is required.\");\n  }\n  if (!defined(base)) {\n    throw new DeveloperError(\"base is required.\");\n  }\n  //>>includeEnd('debug');\n  return Math.log(number) / Math.log(base);\n};\n\n/**\n * Finds the cube root of a number.\n * Returns NaN if <code>number</code> is not provided.\n *\n * @function\n * @param {Number} [number] The number.\n * @returns {Number} The result.\n */\nCesiumMath.cbrt = defaultValue(Math.cbrt, function cbrt(number) {\n  var result = Math.pow(Math.abs(number), 1.0 / 3.0);\n  return number < 0.0 ? -result : result;\n});\n\n/**\n * Finds the base 2 logarithm of a number.\n *\n * @function\n * @param {Number} number The number.\n * @returns {Number} The result.\n */\nCesiumMath.log2 = defaultValue(Math.log2, function log2(number) {\n  return Math.log(number) * Math.LOG2E;\n});\n\n/**\n * @private\n */\nCesiumMath.fog = function (distanceToCamera, density) {\n  var scalar = distanceToCamera * density;\n  return 1.0 - Math.exp(-(scalar * scalar));\n};\n\n/**\n * Computes a fast approximation of Atan for input in the range [-1, 1].\n *\n * Based on Michal Drobot's approximation from ShaderFastLibs,\n * which in turn is based on \"Efficient approximations for the arctangent function,\"\n * Rajan, S. Sichun Wang Inkol, R. Joyal, A., May 2006.\n * Adapted from ShaderFastLibs under MIT License.\n *\n * @param {Number} x An input number in the range [-1, 1]\n * @returns {Number} An approximation of atan(x)\n */\nCesiumMath.fastApproximateAtan = function (x) {\n  //>>includeStart('debug', pragmas.debug);\n  Check.typeOf.number(\"x\", x);\n  //>>includeEnd('debug');\n\n  return x * (-0.1784 * Math.abs(x) - 0.0663 * x * x + 1.0301);\n};\n\n/**\n * Computes a fast approximation of Atan2(x, y) for arbitrary input scalars.\n *\n * Range reduction math based on nvidia's cg reference implementation: http://developer.download.nvidia.com/cg/atan2.html\n *\n * @param {Number} x An input number that isn't zero if y is zero.\n * @param {Number} y An input number that isn't zero if x is zero.\n * @returns {Number} An approximation of atan2(x, y)\n */\nCesiumMath.fastApproximateAtan2 = function (x, y) {\n  //>>includeStart('debug', pragmas.debug);\n  Check.typeOf.number(\"x\", x);\n  Check.typeOf.number(\"y\", y);\n  //>>includeEnd('debug');\n\n  // atan approximations are usually only reliable over [-1, 1]\n  // So reduce the range by flipping whether x or y is on top based on which is bigger.\n  var opposite;\n  var adjacent;\n  var t = Math.abs(x); // t used as swap and atan result.\n  opposite = Math.abs(y);\n  adjacent = Math.max(t, opposite);\n  opposite = Math.min(t, opposite);\n\n  var oppositeOverAdjacent = opposite / adjacent;\n  //>>includeStart('debug', pragmas.debug);\n  if (isNaN(oppositeOverAdjacent)) {\n    throw new DeveloperError(\"either x or y must be nonzero\");\n  }\n  //>>includeEnd('debug');\n  t = CesiumMath.fastApproximateAtan(oppositeOverAdjacent);\n\n  // Undo range reduction\n  t = Math.abs(y) > Math.abs(x) ? CesiumMath.PI_OVER_TWO - t : t;\n  t = x < 0.0 ? CesiumMath.PI - t : t;\n  t = y < 0.0 ? -t : t;\n  return t;\n};\nexport default CesiumMath;\n"],"names":["defaultValue","defined","DeveloperError","Check"],"mappings":"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"}