/**
* @class Number
* @extend
*
* Creates a wrapper object to allow you to work with numerical values.
*
* The primary uses for the `Number` object are:
*
* If the argument cannot be converted into a number, it returns `NaN`.
*
* In a non-constructor context (i.e., without the `new` operator), `Number` can
* be used to perform a type conversion.
*
* # Using the `Number` object to assign values to numeric variables
*
* The following example uses the `Number` object's properties to assign values to
* several numeric variables:
*
* biggestNum = Number.MAX_VALUE;
* smallestNum = Number.MIN_VALUE;
* infiniteNum = Number.POSITIVE_INFINITY;
* negInfiniteNum = Number.NEGATIVE_INFINITY;
* notANum = Number.NaN;
*
* # Using `Number` to convert a `Date` object
*
* The following example converts the `Date` object to a numerical value using
* `Number` as a function:
*
* var d = new Date("December 17, 1995 03:24:00");
* print(Number(d));
*
* This displays "819199440000".
*
* The following example converts the Date object to a numerical value using
* `Number` as a function:
*
* <div class="notice">
* Documentation for this class comes from <a href="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Number">MDN</a>
* and is available under <a href="http://creativecommons.org/licenses/by-sa/2.0/">Creative Commons: Attribution-Sharealike license</a>.
* </div>
*/
/**
* @method constructor
* Creates new Number object.
* @param value
* The numeric value of the object being created.
*/
//Properties
/**
* @property {Number} MAX_VALUE
* @static
* The largest positive representable number. The largest negative representable
* number is `-MAX_VALUE`.
*
* The `MAX_VALUE` property has a value of approximately 1.79E+308. Values larger than `MAX_VALUE` are
* represented as `"Infinity"`.
*
* Because `MAX_VALUE` is a static property of `Number`, you always use it as `Number.MAX_VALUE`,
* rather than as a property of a `Number` object you created.
*
* The following code multiplies two numeric values. If the result is less than or equal to
* `MAX_VALUE`, the `func1` function is called; otherwise, the `func2` function is called.
*
* if (num1 * num2 <= Number.MAX_VALUE)
* func1();
* else
* func2();
*/
/**
* @property {Number} MIN_VALUE
* @static
* The smallest positive representable number -- that is, the positive number
* closest to zero (without actually being zero). The smallest negative
* representable number is `-MIN_VALUE`.
*
* The `MIN_VALUE` property is the number closest to 0, not the most negative number, that JavaScript
* can represent.
*
* `MIN_VALUE` has a value of approximately 5e-324. Values smaller than `MIN_VALUE` ("underflow
* values") are converted to 0.
*
* Because `MIN_VALUE` is a static property of `Number`, you always use it as `Number.MIN_VALUE`,
* rather than as a property of a `Number` object you created.
*
* The following code divides two numeric values. If the result is greater than or equal to
* `MIN_VALUE`, the `func1` function is called; otherwise, the `func2` function is called.
*
* if (num1 / num2 >= Number.MIN_VALUE)
* func1()
* else
* func2()
*/
/**
* @property {Number} NaN
* @static
* Special "not a number" value.
*/
/**
* @property {Number} NEGATIVE_INFINITY
* Special value representing negative infinity; returned on overflow.
*
* The value of `Number.NEGATIVE_INFINITY` is the same as the negative value of the global object's
* Infinity property.
*
* This value behaves slightly differently than mathematical infinity:
*
* * Any positive value, including POSITIVE_INFINITY, multiplied by NEGATIVE_INFINITY is NEGATIVE_INFINITY.
* * Any negative value, including NEGATIVE_INFINITY, multiplied by NEGATIVE_INFINITY is
* POSITIVE_INFINITY.
* * Zero multiplied by NEGATIVE_INFINITY is NaN.
* * NaN multiplied by NEGATIVE_INFINITY is NaN.
* * NEGATIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is
* POSITIVE_INFINITY.
* * NEGATIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is
* NEGATIVE_INFINITY.
* * NEGATIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.
* * Any number divided by NEGATIVE_INFINITY is Zero.
*
* Several JavaScript methods (such as the `Number` constructor, `parseFloat`, and `parseInt`) return
* `NaN` if the value specified in the parameter is significantly lower than `Number.MIN_VALUE`.
*
* You might use the `Number.NEGATIVE_INFINITY` property to indicate an error condition that returns a
* finite number in case of success. Note, however, that `isFinite` would be more appropriate in such
* a case.
*
* In the following example, the variable smallNumber is assigned a value that is smaller than the
* minimum value. When the `if` statement executes, `smallNumber` has the value `"-Infinity"`, so
* `smallNumber` is set to a more manageable value before continuing.
*
* var smallNumber = (-Number.MAX_VALUE) * 2
* if (smallNumber == Number.NEGATIVE_INFINITY) {
* smallNumber = returnFinite();
* }
*/
/**
* @property {Number} POSITIVE_INFINITY
* Special value representing infinity; returned on overflow.
*
* The value of `Number.POSITIVE_INFINITY` is the same as the value of the global object's Infinity
* property.
*
* This value behaves slightly differently than mathematical infinity:
*
* * Any positive value, including POSITIVE_INFINITY, multiplied by POSITIVE_INFINITY is
* POSITIVE_INFINITY.
* * Any negative value, including NEGATIVE_INFINITY, multiplied by POSITIVE_INFINITY is
* NEGATIVE_INFINITY.
* * Zero multiplied by POSITIVE_INFINITY is NaN.
* * NaN multiplied by POSITIVE_INFINITY is NaN.
* * POSITIVE_INFINITY, divided by any negative value except NEGATIVE_INFINITY, is
* NEGATIVE_INFINITY.
* * POSITIVE_INFINITY, divided by any positive value except POSITIVE_INFINITY, is
* POSITIVE_INFINITY.
* * POSITIVE_INFINITY, divided by either NEGATIVE_INFINITY or POSITIVE_INFINITY, is NaN.
* * Any number divided by POSITIVE_INFINITY is Zero.
*
* Several JavaScript methods (such as the `Number` constructor, `parseFloat`, and `parseInt`) return
* `NaN` if the value specified in the parameter is significantly higher than `Number.MAX_VALUE`.
*
* You might use the `Number.POSITIVE_INFINITY` property to indicate an error condition that returns a
* finite number in case of success. Note, however, that `isFinite` would be more appropriate in such
* a case.
*
* In the following example, the variable `bigNumber` is assigned a value that is larger than the
* maximum value. When the if statement executes, `bigNumber` has the value "Infinity", so `bigNumber`
* is set to a more manageable value before continuing.
*
* var bigNumber = Number.MAX_VALUE * 2
* if (bigNumber == Number.POSITIVE_INFINITY) {
* bigNumber = returnFinite();
* }
*/
//Methods
/**
* @method toExponential
* Returns a string representing the number in exponential notation.
*
* A string representing a `Number` object in exponential notation with one digit before the decimal
* point, rounded to `fractionDigits` digits after the decimal point. If the `fractionDigits` argument
* is omitted, the number of digits after the decimal point defaults to the number of digits necessary
* to represent the value uniquely.
*
* If you use the `toExponential` method for a numeric literal and the numeric literal has no exponent
* and no decimal point, leave a space before the dot that precedes the method call to prevent the dot
* from being interpreted as a decimal point.
*
* If a number has more digits that requested by the `fractionDigits` parameter, the number is rounded
* to the nearest number represented by `fractionDigits` digits. See the discussion of rounding in the
* description of the `toFixed` method, which also applies to `toExponential`.
*
* var num=77.1234;
*
* alert("num.toExponential() is " + num.toExponential()); //displays 7.71234e+1
*
* alert("num.toExponential(4) is " + num.toExponential(4)); //displays 7.7123e+1
*
* alert("num.toExponential(2) is " + num.toExponential(2)); //displays 7.71e+1
*
* alert("77.1234.toExponential() is " + 77.1234.toExponential()); //displays 7.71234e+1
*
* alert("77 .toExponential() is " + 77 .toExponential()); //displays 7.7e+1
*
* @param {Number} fractionDigits An integer specifying the number of digits after the decimal
* point. Defaults to as many digits as necessary to specify the number.
* @return {String} Exponential notation of number.
*/
/**
* @method toFixed
* Returns a string representing the number in fixed-point notation.
*
* @return {String} A string representation of `number` that does not use
* exponential notation and has exactly `digits` digits after the decimal place.
* The number is rounded if necessary, and the fractional part is padded with
* zeros if necessary so that it has the specified length. If `number` is greater
* than 1e+21, this method simply calls `Number.toString()` and returns a string
* in exponential notation.
*
* @param {Number} digits The number of digits to appear after the decimal point; this may be a
* value between 0 and 20, inclusive, and implementations may optionally support a larger range of
* values. If this argument is omitted, it is treated as 0.
*/
/**
* @method toLocaleString
* Returns a human readable string representing the number using the locale of the
* environment. Overrides the `Object.prototype.toLocaleString` method.
*
* This method available to numbers will convert the number into a string which is suitable for
* presentation in the given locale.
*
* var number = 3500
* console.log(number.toLocaleString()); // Displays "3,500" in English locale
*
* @return {String} String representing the number.
*/
/**
* @method toPrecision
* Returns a string representing the number to a specified precision in fixed-
* point or exponential notation.
*
* A string representing a `Number` object in fixed-point or
* exponential notation rounded to precision significant digits. See the
* discussion of rounding in the description of the `toFixed` method, which also
* applies to `toPrecision`.
*
* If the precision argument is omitted, behaves as Number.toString. If it is a
* non-integer value, it is rounded to the nearest integer. After rounding, if
* that value is not between 1 and 100 (inclusive), a RangeError is thrown.
*
* @param {Number} precision An integer specifying the number of significant digits.
* @return {String} String that represents `Number` object.
*/
/**
* @method toString
* Returns a string representing the specified object. Overrides the
* `Object.prototype.toString` method.
*
* The `Number` object overrides the `toString` method of the `Object` object; it does not inherit
* `Object.toString`. For `Number` objects, the toString method returns a string representation of the
* object in the specified radix.
*
* The `toString` method parses its first argument, and attempts to return a string representation in
* the specified radix (base). For radixes above 10, the letters of the alphabet indicate numerals
* greater than 9. For example, for hexadecimal numbers (base 16), A through F are used.
*
* If `toString` is given a radix not between 2 and 36, an exception is thrown.
*
* If the radix is not specified, JavaScript assumes the preferred radix is 10.
*
* var count = 10;
* print(count.toString()); // displays "10"
* print((17).toString()); // displays "17"
*
* var x = 7;
* print(x.toString(2)); // displays "111"
*
* @param {Number} radix An integer between 2 and 36 specifying the base to use for representing
* numeric values.
* @return {String} The number represented as a string.
*/
/**
* @method valueOf
* Returns the primitive value of the specified object. Overrides the
* `Object.prototype.valueOf` method.
*
* The `valueOf` method of `Number` returns the primitive value of a `Number` object as a number data
* type.
*
* This method is usually called internally by JavaScript and not explicitly in code.
*
* var x = new Number();
* print(x.valueOf()); // prints "0"
*
* @return {Number} The primitive value of the number.
*/