Operaciones matemáticas (Math)

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 Logaritmo natural en base 2 0.6931471805599453
Math.LN10 Logaritmo decimal 2.302585092994046
Math.LOG2E Logaritmo base 2 de E 1.4426950408889634
Math.LOG10E Logaritmo base 10 de E 0.4342944819032518
Math.PI Número PI o Π 3.141592653589793
Math.SQRT1_2 Raíz cuadrada de 1/2 0.7071067811865476
Math.SQRT2 Raíz cuadrada de 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. Observa que algunos de ellos sólo están disponibles en ECMAScript 6:

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
Math.sqrt(2); // 1.4142135623730951
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 Ejemplo
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 y Ejemplo
Math.log(x) Devuelve el logaritmo natural en base e de x. Ej: loge x o ln x
Math.log10(x) Devuelve el logaritmo decimal (en base 10) de x. Ej: log10 x ó log x
Math.log2(x) Devuelve el logaritmo binario (en base 2) de x. Ej: log2 x
Math.log1p(x) Devuelve el logaritmo natural de (1+x). Ej: loge (1+x) o ln (1+x)

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

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 el redondeo de x (el entero más cercano)
Math.ceil(x) Devuelve el redondeo superior de x. (el entero más alto)
Math.floor(x) Devuelve el redondeo inferior de x. (el entero más bajo)
Math.fround(x) Devuelve el redondeo de x (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.

Manz
Publicado por Manz

Docente, divulgador informático y freelance. Autor de Emezeta.com, es profesor en la Universidad de La Laguna y dirige el curso de Programación web FullStack y Diseño web FrontEnd de EOI en Tenerife (Canarias). En sus ratos libres, busca GIF de gatos en Internet.