    /** * @class Number * * 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 [MDN](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Number) * and is available under [Creative Commons: Attribution-Sharealike license](http://creativecommons.org/licenses/by-sa/2.0/). * </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. */