Completamos el repaso a las novedades de ES6 con los nuevos métodos estáticos de la clase Math.

Math.sign(x)

Esta función nos devuelve 1 si el signo del parámetro es positivo, -1 si es negativo, y +/-0 para valores cero. Veamos un ejemplo:

Math.sign(5); // 1
Math.sign('5'); // 1
Math.sign(-5); // -1
Math.sign(0); // 0
Math.sign(-0); // -0
Math.sign(NaN); //NaN
Math.sign(-Infinity) //-1

Math.trunc(x)

Este método elimina la parte decimal del parámetro. Complementa a los métodos Math.ceil(), Math.floor() y Math.round(), con la principal diferencia de que en este caso nos devuelve la parte entera sin redondear de ningún modo.

Math.trunc(5.1); //5
Math.trunc(5.9); //5
Manth.trunc('-0.12'); //-0
Manth.trunc(-0.9); //-0

Math.cbrt(x)

El nombre del método Math.cbrt(x) viene de cube root, y como es de imaginar, devuelve la raíz cúbica de x , es decir: $\sqrt[3]{x}$

Math.cbrt(27); //3

Métodos relacionados con exponentes y logaritmos

Debido a que los números de coma flotante en base 10, se representan internamente como mantisa x E^exp, resulta que las fracciones pequeñas se representan de forma más precisa si son un valor entre 0 y 1.

Para aclarar un poco esta idea, veamos el siguiente ejemplo:

$(1) 0.00012 = 1.2 × 10^{−4}$ – Dígitos significativos: 12

$(2) 1.00012 = 1.00012 × 10^{0}$ – Dígitos significativos: 100012

Como se puede apreciar, el primer ejemplo necesita almacenar menos dígitos significativos, por lo que nos ofrecerá una mayor resolución frente al segundo.

Aprovechando esta posibilidad, se han creado 2 métodos concretos: expm1 y log1p.

Math.expm1(x)

Este método nos da mayor precisión con los decimales cuando el resultado de Math.exp() es muy cercano a 1.

A efectos prácticos, devuelve Math.exp(x) -1, es decir $e^{x} -1$

Podemos ver la diferencia con el siguiente ejemplo:

//partimos de 1e-10, es decir 0.0000000001
//Math.exp(1e-10) será 1.0000000001
//pero veamos como se ve afectada la precisión de estos métodos:

//ES5
Math.exp(1e-10)-1; //1.000000082740371e-10
//ES6
Math.expm1(1e-10); //1.00000000005e-10

Como podemos ver del ejemplo, el nuevo método ofrece una mayor precisión.

Math.log1p(x)

Éste método devuelve la inversa de Math.expm1(), y del mismo módo, permite especificar parámetros cercanos a 1 con una mayor precisión.

A efectos prácticos, devuelve Math.log(1 + x), es decir: $log(1+x)$

Veamos un ejemplo:

//ES5
Math.log(1 + 1e-16); //0

//ES6
Math.log1p(1e-16); //1e-16, es decir 0.0000000000000001

Como vemos el primer caso no es tan preciso y devuelve directamente cero.

Math.log2(x)

Este método devuelve el logaritmo base 2 del argumento, es decir $log_{2}(x)$.

Math.log2(8); //3

Math.log10(x)

Este método devuelve el logaritmo base 10 del argumento, es decir $log_{10}(x)$.

Math.log10(10000); //4

Math.clz32(x)

Este método cuenta los bits cero por la izquierda de un entero de 32 bits. Lo entenderás mejor con un ejemplo:

//un entero 3, está representado en binario por '11'.
//esto, en un integer será 00...011, con 30 bits a 0 y luego dos a 1. Por tanto:
Math.clz32(3); //30

//otros ejemplos:
Math.clz32(2); //30
Math.clz32(1); //31
Math.clz32(0b01000000000000000000000000000000); //1
Math.clz32(0b00001000000000000000000000000000); //4

Operaciones trigonométricas

Además de los métodos anteriores, ES6 incluye en la clase Math una serie de operaciones trigonométricas comunes:

Math.sinh(x)

Devuelve el seno hiperbólico de x

Math.cosh(x)

Devuelve el coseno hiperbólico de x

Math.tanh(x)

Devuelve la tangente hiperbólica de x

Math.asinh(x)

Devuelve la inversa del seno hiperbólico de x

Math.acosh(x)

Devuelve la inversa del coseno hiperbólico de x.

Math.atanh(x)

Devuelve la inversa de la tangente hiperbólica de x.

Math.hypot(…values)

El nombre se debe a al teorema de Pitágoras ya que este método nos devuelve la hipotenusa dados los catetos. Observar, sin embargo, que le podemos pasar tantos valores como queramos. La fórmula que aplica es la siguiente :
$$\sqrt[2]{{arg_1}^{2} + {arg_2}^{2} + … + {arg_n}^{2}}$$

Veamos unos ejemplos de este último:

Math.hypot(3, 4); //5
Math.hypot(3,4,12); //9

Conclusiones

ES6 potencia la librería Math con más funciones trigonométricas y otras operaciones básicas como obtener el signo o truncar números. Obviamente no alcanza todo el potencial de librerías matemáticas dedicadas como puedan ser Math.js o numbers.js, pero puede que nos evite tener que sobrecargar nuestra página con una librería extra, o crear uno de estos métodos tan primarios a mano.

Espero que te haya sido de ayuda 😉