Math
features Number
propertiesMath
methodsNumber.parseInt()
and the new integer literalsNumber
properties
Number.EPSILON
Number.isInteger(number)
Math
functionality
You can now specify integers in binary and octal notation:
Number
properties The global object Number
gained a few new properties:
Number.EPSILON
for comparing floating point numbers with a tolerance for rounding errors.Number.isInteger(num)
checks whether num
is an integer (a number without a decimal fraction):
Number.isSafeInteger(number)
Number.MIN_SAFE_INTEGER
Number.MAX_SAFE_INTEGER
Number.isNaN(num)
checks whether num
is the value NaN
. In contrast to the global function isNaN()
, it doesn’t coerce its argument to a number and is therefore safer for non-numbers:
Number
are mostly equivalent to the global functions with the same names: Number.isFinite
, Number.parseFloat
, Number.parseInt
.Math
methods The global object Math
has new methods for numerical, trigonometric and bitwise operations. Let’s look at four examples.
Math.sign()
returns the sign of a number:
Math.trunc()
removes the decimal fraction of a number:
Math.log10()
computes the logarithm to base 10:
Math.hypot()
Computes the square root of the sum of the squares of its arguments (Pythagoras’ theorem):
ECMAScript 5 already has literals for hexadecimal integers:
ECMAScript 6 brings two new kinds of integer literals:
0b
or 0B
:
0o
or 0O
(that’s a zero followed by the capital letter O; the first variant is safer):
Remember that the Number
method toString(radix)
can be used to see numbers in a base other than 10:
(The double dots are necessary so that the dot for property access isn’t confused with a decimal dot.)
In the Node.js file system module, several functions have the parameter mode
. Its value is used to specify file permissions, via an encoding that is a holdover from Unix:
That means that permissions can be represented by 9 bits (3 categories with 3 permissions each):
User | Group | All | |
---|---|---|---|
Permissions | r, w, x | r, w, x | r, w, x |
Bit | 8, 7, 6 | 5, 4, 3 | 2, 1, 0 |
The permissions of a single category of users are stored in 3 bits:
Bits | Permissions | Octal digit |
---|---|---|
000 | ––– | 0 |
001 | ––x | 1 |
010 | –w– | 2 |
011 | –wx | 3 |
100 | r–– | 4 |
101 | r–x | 5 |
110 | rw– | 6 |
111 | rwx | 7 |
That means that octal numbers are a compact representation of all permissions, you only need 3 digits, one digit per category of users. Two examples:
Number.parseInt()
and the new integer literals Number.parseInt()
(which does the same as the global function parseInt()
) has the following signature:
Number.parseInt()
: hexadecimal number literals Number.parseInt()
provides special support for the hexadecimal literal notation – the prefix 0x
(or 0X
) of string
is removed if:
radix
is missing or 0. Then radix
is set to 16. As a rule, you should never omit the radix
.radix
is 16.For example:
In all other cases, digits are only parsed until the first non-digit:
Number.parseInt()
: binary and octal number literals However, Number.parseInt()
does not have special support for binary or octal literals!
If you want to parse these kinds of literals, you need to use Number()
:
Number.parseInt()
works fine with numbers that have a different base, as long as there is no special prefix and the parameter radix
is provided:
Number
properties This section describes new properties that the constructor Number
has picked up in ECMAScript 6.
Four number-related functions are already available as global functions and have been added to Number
, as methods: isFinite
and isNaN
, parseFloat
and parseInt
. All of them work almost the same as their global counterparts, but isFinite
and isNaN
don’t coerce their arguments to numbers, anymore, which is especially important for isNaN
. The following subsections explain all the details.
Number.isFinite(number)
Number.isFinite(number)
determines whether number
is an actual number (neither Infinity
nor -Infinity
nor NaN
):
The advantage of this method is that it does not coerce its parameter to number (whereas the global function does):
Number.isNaN(number)
Number.isNaN(number)
checks whether number
is the value NaN
.
One ES5 way of making this check is via !==
:
A more descriptive way is via the global function isNaN()
:
However, this function coerces non-numbers to numbers and returns true
if the result is NaN
(which is usually not what you want):
The new method Number.isNaN()
does not exhibit this problem, because it does not coerce its arguments to numbers:
Number.parseFloat
and Number.parseInt
The following two methods work exactly like the global functions with the same names. They were added to Number
for completeness sake; now all number-related functions are available there.
Number.parseFloat(string)
^{1}
Number.parseInt(string, radix)
^{2}
Number.EPSILON
Especially with decimal fractions, rounding errors can become a problem in JavaScript^{3}. For example, 0.1 and 0.2 can’t be represented precisely, which you notice if you add them and compare them to 0.3 (which can’t be represented precisely, either).
Number.EPSILON
specifies a reasonable margin of error when comparing floating point numbers. It provides a better way to compare floating point values, as demonstrated by the following function.
Number.isInteger(number)
JavaScript has only floating point numbers (doubles). Accordingly, integers are simply floating point numbers without a decimal fraction.
Number.isInteger(number)
returns true
if number
is a number and does not have a decimal fraction.
JavaScript numbers have only enough storage space to represent 53 bit signed integers. That is, integers i in the range −2^{53} < i < 2^{53} are safe. What exactly that means is explained momentarily. The following properties help determine whether a JavaScript integer is safe:
Number.isSafeInteger(number)
Number.MIN_SAFE_INTEGER
Number.MAX_SAFE_INTEGER
The notion of safe integers centers on how mathematical integers are represented in JavaScript. In the range (−2^{53}, 2^{53}) (excluding the lower and upper bounds), JavaScript integers are safe: there is a one-to-one mapping between them and the mathematical integers they represent.
Beyond this range, JavaScript integers are unsafe: two or more mathematical integers are represented as the same JavaScript integer. For example, starting at 2^{53}, JavaScript can represent only every second mathematical integer:
Therefore, a safe JavaScript integer is one that unambiguously represents a single mathematical integer.
Number
properties related to safe integers The two static Number
properties specifying the lower and upper bound of safe integers could be defined as follows:
Number.isSafeInteger()
determines whether a JavaScript number is a safe integer and could be defined as follows:
For a given value n
, this function first checks whether n
is a number and an integer. If both checks succeed, n
is safe if it is greater than or equal to MIN_SAFE_INTEGER
and less than or equal to MAX_SAFE_INTEGER
.
How can we make sure that results of computations with integers are correct? For example, the following result is clearly not correct:
We have two safe operands, but an unsafe result:
The following result is also incorrect:
This time, the result is safe, but one of the operands isn’t:
Therefore, the result of applying an integer operator op
is guaranteed to be correct only if all operands and the result are safe. More formally:
implies that a op b
is a correct result.
Math
functionality The global object Math
has several new methods in ECMAScript 6.
Math.sign(x)
Math.sign(x)
returns:
-1
if x
is a negative number (including -Infinity
).0
if x
is zero^{4}.+1
if x
is a positive number (including Infinity
).NaN
if x
is NaN
or not a number.Examples:
Math.trunc(x)
Math.trunc(x)
removes the decimal fraction of x
. Complements the other rounding methods Math.floor()
, Math.ceil()
and Math.round()
.
You could implement Math.trunc()
like this:
Math.cbrt(x)
Math.cbrt(x)
returns the cube root of x
(∛x).
A small fraction can be represented more precisely if it comes after zero. I’ll demonstrate this with decimal fractions (JavaScript’s numbers are internally stored with base 2, but the same reasoning applies).
Floating point numbers with base 10 are internally represented as mantissa × 10^{exponent}. The mantissa has a single digit before the decimal dot and the exponent “moves” the dot as necessary. That means if you convert a small fraction to the internal representation, a zero before the dot leads to a smaller mantissa than a one before the dot. For example:
Precision-wise, the important quantity here is the capacity of the mantissa, as measured in significant digits. That’s why (A) gives you higher precision than (B).
Additionally, JavaScript represents numbers close to zero (e.g. small fractions) with higher precision.
Math.expm1(x)
Math.expm1(x)
returns Math.exp(x)-1
. The inverse of Math.log1p()
.
Therefore, this method provides higher precision whenever Math.exp()
has results close to 1. You can see the difference between the two in the following interaction:
The former is the better result, which you can verify by using a library (such as decimal.js) for floating point numbers with arbitrary precision (“bigfloats”):
Math.log1p(x)
Math.log1p(x)
returns Math.log(1 + x)
. The inverse of Math.expm1()
.
Therefore, this method lets you specify parameters that are close to 1 with a higher precision. The following examples demonstrate why that is.
The following two calls of log()
produce the same result:
In contrast, log1p()
produces different results:
The reason for the higher precision of Math.log1p()
is that the correct result for 1 + 1e-16
has more significant digits than 1e-16
:
Math.log2(x)
Math.log2(x)
computes the logarithm to base 2.
Math.log10(x)
Math.log10(x)
computes the logarithm to base 10.
Emscripten pioneered a coding style that was later picked up by asm.js: The operations of a virtual machine (think bytecode) are expressed in static subset of JavaScript. That subset can be executed efficiently by JavaScript engines: If it is the result of a compilation from C++, it runs at about 70% of native speed.
The following Math
methods were mainly added to support asm.js and similar compilation strategies, they are not that useful for other applications.
Math.fround(x)
Math.fround(x)
rounds x
to a 32 bit floating point value (float
). Used by asm.js to tell an engine to internally use a float
value.
Math.imul(x, y)
Math.imul(x, y)
multiplies the two 32 bit integers x
and y
and returns the lower 32 bits of the result. This is the only 32 bit basic math operation that can’t be simulated by using a JavaScript operator and coercing the result back to 32 bits. For example, idiv
could be implemented as follows:
In contrast, multiplying two large 32 bit integers may produce a double that is so large that lower bits are lost.
Math.clz32(x)
x
.
Why is this interesting? Quoting “Fast, Deterministic, and Portable Counting Leading Zeros” by Miro Samek:
Counting leading zeros in an integer number is a critical operation in many DSP algorithms, such as normalization of samples in sound or video processing, as well as in real-time schedulers to quickly find the highest-priority task ready-to-run.
Math.sinh(x)
x
.Math.cosh(x)
x
.Math.tanh(x)
x
.Math.asinh(x)
x
.Math.acosh(x)
x
.Math.atanh(x)
x
.Math.hypot(...values)
JavaScript’s integers have a range of 53 bits. That is a problem whenever 64 bit integers are needed. For example: In its JSON API, Twitter had to switch from integers to strings when tweet IDs became too large.
At the moment, the only way around that limitation is to use a library for higher-precision numbers (bigints or bigfloats). One such library is decimal.js.
Plans to support larger integers in JavaScript exist, but may take a while to come to fruition.