El objeto Math

Operaciones matemáticas

Cuando trabajamos con Javascript, es posible realizar gran cantidad de operaciones matemáticas de forma nativa, sin necesidad de librerías externas. Para ello, haremos uso del objeto Math, un objeto interno de Javascript que tiene incorporadas ciertas constantes y métodos (funciones) para trabajar matemáticamente.

Constantes de Math

El objeto Math de Javascript incorpora varias constantes que podemos necesitar en algunas operaciones matemáticas. Veamos su significado y valor aproximado:

Constante Descripción Valor
Math.E Número de Euler 2.718281828459045
Math.LN2 Equivalente a Math.log(2) 0.6931471805599453
Math.LN10 Equivalente a Math.log(10) 2.302585092994046
Math.LOG2E Equivalente a Math.log2(Math.E) 1.4426950408889634
Math.LOG10E Equivalente a Math.log10(Math.E) 0.4342944819032518
Math.PI Número PI o Π 3.141592653589793
Math.SQRT1_2 Equivalente a Math.sqrt(1/2). 0.7071067811865476
Math.SQRT2 Equivalente a Math.sqrt(2). 1.4142135623730951

Además de estas constantes, el objeto Math también nos proporciona gran cantidad de métodos o funciones para trabajar con números. Vamos a analizarlos.

Métodos matemáticos

Los siguientes métodos matemáticos están disponibles en Javascript a través del objeto Math:

Método Descripción Ejemplo
Math.abs(x) Devuelve el valor absoluto de x. |x|
Math.sign(x) Devuelve el signo del número: 1 positivo, -1 negativo
Math.exp(x) Exponenciación. Devuelve el número e elevado a x. ex
Math.expm1(x) Equivalente a Math.exp(x) - 1. ex-1
Math.max(a, b, c...) Devuelve el número más grande de los indicados por parámetro.
Math.min(a, b, c...) Devuelve el número más pequeño de los indicados por parámetro.
Math.pow(base, exp) Potenciación. Devuelve el número base elevado a exp. baseexp
Math.sqrt(x) Devuelve la raíz cuadrada de x. √x
Math.cbrt(x) Devuelve la raíz cúbica de x. 3x
Math.imul(a, b) Equivalente a a * b, pero a nivel de bits.
Math.clz32(x) Devuelve el número de ceros a la izquierda de x en binario (32 bits).

Veamos algunos ejemplos aplicados a las mencionadas funciones anteriormente:

Math.abs(-5);             // 5
Math.sign(-5); // -1
Math.exp(1); // e, o sea, 2.718281828459045
Math.expm1(1); // 1.718281828459045
Math.max(1, 40, 5, 15); // 40
Math.min(5, 10, -2, 0); // -2
Math.pow(2, 10); // 1024 (Equivale a 2**10)
Math.sqrt(2); // 1.4142135623730951 (Equivale a Math.SQRT2)
Math.cbrt(2); // 1.2599210498948732
Math.imul(0xffffffff, 7); // -7

// Ejemplo de clz32 (count leading zeros)
const x = 1;
"0".repeat(Math.clz32(x)) + x.toString(2);
// Devuelve "00000000000000000000000000000001"

Existe uno más, Math.random() que merece una explicación más detallada, por lo que lo explicamos en el apartado siguiente.

Método Math.random()

Uno de los métodos más útiles e interesantes del objeto Math es Math.random().

Método Descripción
Math.random() Devuelve un número al azar entre 0 y 1 con 16 decimales.

Este método nos da un número al azar entre los valores 0 y 1, con 16 decimales. Normalmente, cuando queremos trabajar con números aleatorios, lo que buscamos es obtener un número entero al azar entre a y b. Para ello, se suele hacer lo siguiente:

// Obtenemos un número al azar entre [0, 1) con 16 decimales
let x = Math.random();

// Multiplicamos dicho número por el valor máximo que buscamos (5)
x = x * 5;

// Redondeamos inferiormente, quedándonos sólo con la parte entera
x = Math.floor(x);

Este ejemplo nos dará en x un valor al azar entre 0 y 5 (5 no incluido). Lo hemos realizado por pasos para entenderlo mejor, pero podemos realizarlo directamente como se ve en el siguiente ejemplo:

// Número al azar entre 0 y 5 (no incluido)
const x = Math.floor(Math.random() * 5);

// Equivalente al anterior
const x = ~~(Math.random() * 5);

Como se puede ver en el segundo ejemplo anterior, utilizamos el operador a nivel de bits ~~ (doble negación) como reemplazo rápido de Math.floor(), una función que realiza un redondeo inferior, y que veremos al final de este tema.

Si lo deseas, puedes utilizar librerías específicas para generar números aleatorios como random.js o chance.js, esta última permitiendo incluso generar otros tipos de datos aleatorios como textos, GUIDs o colores hexadecimales.

Métodos de logaritmos

Javascript incorpora varios métodos en el objeto Math para trabajar con logaritmos. Desde logaritmos neperianos hasta logaritmos binarios a través de las siguientes funciones:

Método Descripción Ejemplo
Math.log(x) Devuelve el logaritmo natural en base e de x. loge x o ln x
Math.log10(x) Devuelve el logaritmo decimal (en base 10) de x. log10 x ó log x
Math.log2(x) Devuelve el logaritmo binario (en base 2) de x. log2 x
Math.log1p(x) Devuelve el logaritmo natural de (1+x). loge (1+x) o ln (1+x)

A continuación, unos ejemplos de estas funciones aplicadas en Javascript:

Math.log(2);    // 0.6931471805599453
Math.log10(2); // 0.3010299956639812
Math.log2(2); // 1
Math.log1p(2); // 1.0986122886681096

Métodos de redondeo

Como hemos visto anteriormente, es muy común necesitar métodos para redondear números y reducir el número de decimales o aproximar a una cifra concreta. Para ello, de forma nativa, Javascript proporciona los siguientes métodos de redondeo:

Método Descripción
Math.round(x) Devuelve x con redondeo (el entero más cercano)
Math.ceil(x) Devuelve x con redondeo superior (el entero más alto)
Math.floor(x) Devuelve x con redondeo inferior (el entero más bajo)
Math.fround(x) Devuelve x con redondeo (flotante con precisión simple)
Math.trunc(x) Trunca el número x (devuelve sólo la parte entera)

Veamos las diferencias de utilizar los diferentes métodos anteriores para redondear un número decimal y los resultados obtenidos:

// Redondeo natural, el más cercano
Math.round(3.75); // 4
Math.round(3.25); // 3

// Redondeo superior (el más alto)
Math.ceil(3.75); // 4
Math.ceil(3.25); // 4

// Redondeo inferior (el más bajo)
Math.floor(3.75); // 3
Math.floor(3.25); // 3

// Redondeo con precisión
Math.round(3.123456789); // 3
Math.fround(3.123456789); // 3.1234567165374756

// Truncado (sólo parte entera)
Math.trunc(3.75); // 3
Math.round(-3.75); // -4
Math.trunc(-3.75); // -3

Métodos trigonométricos

Por último, y no por ello menos importante, el objeto Math nos proporciona de forma nativa una serie de métodos trigonométricos, que nos permiten hacer cálculos con operaciones como seno, coseno, tangente y relacionados:

Método Descripción
Math.sin(x) Seno de x
Math.asin(x) Arcoseno de x
Math.sinh(x) Seno hiperbólico de x
Math.asinh(x) Arcoseno hiperbólico de x
Math.cos(x) Coseno de x
Math.acos(x) Arcocoseno de x
Math.cosh(x) Coseno hiperbólico de x
Math.acosh(x) Arcocoseno hiperbólico de x
Math.tan(x) Tangente de x
Math.atan(x) Arcotangente de x
Math.tanh(x) Tangente hiperbólica de x
Math.atanh(x) Arcotangente hiperbólica de x
Math.atan2(x, y) Arcotangente del conciente de x/y
Math.hypot(a, b..) Devuelve la raíz cuadrada de a2 + b2 + ...

Otras librerías matemáticas

Si de forma nativa no encuentras una forma sencilla de resolver el problema matemático que tienes entre manos, no olvides que existen una serie de librerías de terceros que pueden hacernos la vida más fácil a la hora de trabajar con otros valores matemáticos.

A continuación, detallamos algunas de ellas:

Librería Descripción GitHub
Math.js Librería matemática de propósito general. josdejong/mathjs
Fraction.js Librería matemática para trabajar con fracciones. infusion/Fraction.js
Polynomial.js Librería matemática para trabajar con polinomios. infusion/Polynomial.js
Complex.js Librería matemática para trabajar con números complejos. infusion/Complex.js
Angles.js Librería matemática para trabajar con ángulos. infusion/Angles.js
BitSet.js Librería matemática para trabajar con vectores de bits. infusion/BitSet.js

Habrás comprobado que, al contrario que muchos otros objetos de Javascript, en estas ocasiones hemos indicado explícitamente el objeto, por ejemplo Math.round(numero), en lugar de hacerlo sobre la variable: numero.round(). Esto ocurre porque Math es un objeto con métodos y constantes estáticas, algo que veremos en profundidad en futuros temas.

Tabla de contenidos