/**
 * @class Ext.Number
 *
 * A collection of useful static methods to deal with numbers
 * @singleton
 */
 
/**
 * @method clipIndices
 * Coerces a given index into a valid index given a `length`.
 *
 * Negative indexes are interpreted starting at the end of the collection. That is,
 * a value of -1 indicates the last item, or equivalent to `length - 1`.
 *
 * When handling methods that take "begin" and "end" arguments like most array or
 * string methods, this method can be used like so:
 *
 *      function foo (array, begin, end) {
 *          var range = Ext.Number.clipIndices(array.length, [begin, end]);
 *
 *          begin = range[0];
 *          end   = range[1];
 *
 *          // 0 <= begin <= end <= array.length
 *
 *          var length = end - begin;
 *      }
 *
 * For example:
 *
 *      +---+---+---+---+---+---+---+---+
 *      |   |   |   |   |   |   |   |   |  length = 8
 *      +---+---+---+---+---+---+---+---+
 *        0   1   2   3   4   5   6   7
 *       -8  -7  -6  -5  -4  -3  -2  -1
 *
 *      console.log(Ext.Number.clipIndices(8, [3, 10]); // logs "[3, 8]"
 *      console.log(Ext.Number.clipIndices(8, [-5]);    // logs "[3, 8]"
 *      console.log(Ext.Number.clipIndices(8, []);
 *      console.log(Ext.Number.clipIndices(8, []);
 *
 * @param {Number} length 
 * @param {Number[]} indices 
 * @param {Object} [options] An object with different option flags.
 * @param {Boolean} [options.count=false] The second number in `indices` is the
 * count not and an index.
 * @param {Boolean} [options.inclusive=false] The second number in `indices` is
 * "inclusive" meaning that the item should be considered in the range. Normally,
 * the second number is considered the first item outside the range or as an
 * "exclusive" bound.
 * @param {Boolean} [options.wrap=true] Wraps negative numbers backwards from the
 * end of the array. Passing `false` simply clips negative index values at 0.
 * @return {Number[]} The normalized `[begin, end]` array where `end` is now
 * exclusive such that `length = end - begin`. Both values are between 0 and the
 * given `length` and `end` will not be less-than `begin`.
 */
 
/**
 * @method constrain
 * Checks whether or not the passed number is within a desired range.  If the number is already within the
 * range it is returned, otherwise the min or max value is returned depending on which side of the range is
 * exceeded. Note that this method returns the constrained value but does not change the current number.
 * @param {Number} number The number to check
 * @param {Number} min The minimum number in the range
 * @param {Number} max The maximum number in the range
 * @return {Number} The constrained value if outside the range, otherwise the current value
 */
 
/**
 * @method snap
 * Snaps the passed number between stopping points based upon a passed increment value.
 *
 * The difference between this and {@link #snapInRange} is that {@link #snapInRange} uses the minValue
 * when calculating snap points:
 *
 *     r = Ext.Number.snap(56, 2, 55, 65);        // Returns 56 - snap points are zero based
 *
 *     r = Ext.Number.snapInRange(56, 2, 55, 65); // Returns 57 - snap points are based from minValue
 *
 * @param {Number} value The unsnapped value.
 * @param {Number} increment The increment by which the value must move.
 * @param {Number} minValue The minimum value to which the returned value must be constrained. Overrides the increment.
 * @param {Number} maxValue The maximum value to which the returned value must be constrained. Overrides the increment.
 * @return {Number} The value of the nearest snap target.
 */
 
/**
 * @method snapInRange
 * Snaps the passed number between stopping points based upon a passed increment value.
 *
 * The difference between this and {@link #snap} is that {@link #snap} does not use the minValue
 * when calculating snap points:
 *
 *     r = Ext.Number.snap(56, 2, 55, 65);        // Returns 56 - snap points are zero based
 *
 *     r = Ext.Number.snapInRange(56, 2, 55, 65); // Returns 57 - snap points are based from minValue
 *
 * @param {Number} value The unsnapped value.
 * @param {Number} increment The increment by which the value must move.
 * @param {Number} [minValue=0] The minimum value to which the returned value must be constrained.
 * @param {Number} [maxValue=Infinity] The maximum value to which the returned value must be constrained.
 * @return {Number} The value of the nearest snap target.
 */
 
/**
 * @method roundToNearest
 * Round a number to the nearest interval.
 * @param {Number} value The value to round.
 * @param {Number} interval The interval to round to.
 * @return {Number} The rounded value.
 *
 * @since 6.2.0
 */
 
/**
 * @method sign
 * Returns the sign of the given number. See also MDN for Math.sign documentation
 * for the standard method this method emulates.
 * @param {Number} x The number.
 * @return {Number} The sign of the number `x`, indicating whether the number is
 * positive (1), negative (-1) or zero (0).
 * @method sign
 */
 
/**
 * @method log10
 * Returns the base 10 logarithm of a number.
 * This will use Math.log10, if available (ES6).
 * @param {Number} x The number.
 * @return {Number} Base 10 logarithm of the number 'x'.
 * @method log10
 */
 
/**
 * @method isEqual
 * Determines if two numbers `n1` and `n2` are equal within a given
 * margin of precision `epsilon`.
 * @param {Number} n1 First number.
 * @param {Number} n2 Second number.
 * @param {Number} epsilon Margin of precision.
 * @returns {Boolean} `true`, if numbers are equal. `false` otherwise.
 */
 
/**
 * @method isFinite
 * Determines if the value passed is a number and also finite.
 * This a Polyfill version of Number.isFinite(),differently than
 * the isFinite() function, this method doesn't convert the parameter to a number.
 * @param {Number} value Number to be tested.
 * @returns {Boolean} `true`, if the parameter is a number and finite, `false` otherwise.
 * @since 6.2
 */
 
/**
 * @method toFixed
 * Formats a number using fixed-point notation
 * @param {Number} value The number to format
 * @param {Number} precision The number of digits to show after the decimal point
 */
 
/**
 * @method from
 * Validate that a value is numeric and convert it to a number if necessary. Returns the specified default value if
 * it is not.
 *
 *     Ext.Number.from('1.23', 1); // returns 1.23
 *     Ext.Number.from('abc', 1); // returns 1
 *
 * @param {Object} value 
 * @param {Number} defaultValue The value to return if the original value is non-numeric
 * @return {Number} value, if numeric, defaultValue otherwise
 */
 
/**
 * @method randomInt
 * Returns a random integer between the specified range (inclusive)
 * @param {Number} from Lowest value to return.
 * @param {Number} to Highest value to return.
 * @return {Number} A random integer within the specified range.
 */
 
/**
 * @method correctFloat
 * Corrects floating point numbers that overflow to a non-precise
 * value because of their floating nature, for example `0.1 + 0.2`
 * @param {Number} n The number
 * @return {Number} The correctly rounded number
 */