restructuredtext .. mathematical_methods:

Métodos Matemáticos

Esses métodos são funções incorporadas ao JavaScript que realizam operações matemáticas em números. Todos os métodos matemáticos são acessados através de Math.

Ver também

Documentação MDN sobre Math

Constantes Matemáticas 

Math.PI 

A constante Math.PI representa o valor de π (pi), aproximadamente 3.14159265358979. É comumente usada em cálculos envolvendo círculos e ângulos.

Valor

Aproximadamente 3.141592653589793

Exemplos

// Calcular a circunferência de um círculo (C = 2πr)
raio = 10;
2 * Math.PI * raio;
// 62.83185307179586

// Calcular a área de um círculo (A = πr²)
raio = 5;
Math.PI * Math.pow(raio, 2);
// 78.53981633974483

// Converter graus para radianos (radianos = graus × π/180)
graus = 180;
graus * (Math.PI / 180);
// 3.141592653589793 (equivalente a 180° = π radianos)

graus = 90;
graus * (Math.PI / 180);
// 1.5707963267948966 (equivalente a 90° = π/2 radianos)

Math.E 

A constante de Euler (e), base dos logaritmos naturais. É fundamental em cálculos de crescimento exponencial, juros compostos e probabilidade.

Valor

Aproximadamente 2.718281828459045

Exemplos

Math.E;
// 2.718281828459045

// Usado em cálculos de crescimento exponencial
// Exemplo: crescimento populacional onde taxa = 0.05 (5%) e tempo = 10 anos
populacaoInicial = 1000;
taxa = 0.05;
tempo = 10;
populacaoInicial * Math.pow(Math.E, taxa * tempo);
// 1648.72 (aproximadamente)

Math.LN2 

Logaritmo natural de 2 (ln 2). Útil em cálculos de meia-vida e tempo de duplicação.

Valor

Aproximadamente 0.6931471805599453

Exemplos

Math.LN2;
// 0.6931471805599453

// Calcular tempo de duplicação: t = ln(2) / taxa_crescimento
taxaCrescimento = 0.07;  // 7% ao ano
Math.LN2 / taxaCrescimento;
// 9.90 anos (regra de 70)

Math.LN10 

Logaritmo natural de 10 (ln 10). Usado para converter entre logaritmos de bases diferentes.

Valor

Aproximadamente 2.302585092994046

Exemplos

Math.LN10;
// 2.302585092994046

Math.LOG2E 

Logaritmo de base 2 de e (log₂ e). Útil em ciência da computação e teoria da informação.

Valor

Aproximadamente 1.4426950408889634

Exemplos

Math.LOG2E;
// 1.4426950408889634

Math.LOG10E 

Logaritmo de base 10 de e (log₁₀ e). Usado em cálculos científicos e conversões.

Valor

Aproximadamente 0.4342944819032518

Exemplos

Math.LOG10E;
// 0.4342944819032518

Operações com Valores 

Math.abs()

Retorna o valor absoluto de um número, ou seja, sua magnitude sem considerar o sinal. O valor absoluto é sempre não-negativo e representa a distância do número até zero.

Sintaxe

Math.abs(x)

Parâmetros

x: Um número.

Valor de retorno

O valor absoluto do número fornecido (sempre ≥ 0).

Exemplos

Math.abs(-5);      // 5
Math.abs(5);       // 5
Math.abs(0);       // 0
Math.abs(-3.14);   // 3.14

// Calcular diferença absoluta entre dois valores
valor1 = 10;
valor2 = 3;
Math.abs(valor1 - valor2);   // 7

valor1 = 3;
valor2 = 10;
Math.abs(valor1 - valor2);   // 7 (mesmo resultado)

// Calcular variação de temperatura
temperaturaInicial = 15;
temperaturaFinal = -5;
Math.abs(temperaturaFinal - temperaturaInicial);
// 20 graus de variação

Arredondamento de Números 

Math.round()

Arredonda um número para o inteiro mais próximo usando a regra matemática padrão: se a parte decimal for menor que 0.5, arredonda para baixo; se for maior ou igual a 0.5, arredonda para cima.

Sintaxe

Math.round(x)

Parâmetros

x: Um número.

Valor de retorno

O número arredondado para o inteiro mais próximo.

Exemplos

Math.round(4.7);     // 5 (0.7 ≥ 0.5, arredonda para cima)
Math.round(4.4);     // 4 (0.4 < 0.5, arredonda para baixo)
Math.round(4.5);     // 5 (0.5 = 0.5, arredonda para cima)
Math.round(-4.5);    // -4 (arredonda em direção a zero)
Math.round(-4.6);    // -5

// Arredondar preço para duas casas decimais
preco = 19.876;
Math.round(preco * 100) / 100;   // 19.88

// Arredondar para uma casa decimal
valor = 3.14159;
Math.round(valor * 10) / 10;     // 3.1

Math.floor()

Arredonda um número para baixo, retornando o maior inteiro que seja menor ou igual ao número fornecido. Sempre arredonda em direção ao infinito negativo.

Sintaxe

Math.floor(x)

Parâmetros

x: Um número.

Valor de retorno

O maior inteiro ≤ x.

Exemplos

Math.floor(4.9);     // 4 (remove a parte decimal)
Math.floor(4.1);     // 4
Math.floor(4.0);     // 4
Math.floor(-4.1);    // -5 (vai para o próximo inteiro menor)
Math.floor(-4.9);    // -5

// Obter apenas a parte inteira de um número positivo
Math.floor(10.999);  // 10

// Calcular quantos grupos completos de 10 cabem em um número
total = 47;
Math.floor(total / 10);  // 4 grupos de 10

// Converter porcentagem para índice de array
porcentagem = 75;
tamanhoArray = 100;
Math.floor((porcentagem / 100) * tamanhoArray);  // 75

Math.ceil()

Arredonda um número para cima, retornando o menor inteiro que seja maior ou igual ao número fornecido. Sempre arredonda em direção ao infinito positivo.

Sintaxe

Math.ceil(x)

Parâmetros

x: Um número.

Valor de retorno

O menor inteiro ≥ x.

Exemplos

Math.ceil(4.1);      // 5 (arredonda para cima)
Math.ceil(4.9);      // 5
Math.ceil(4.0);      // 4
Math.ceil(-4.1);     // -4 (vai para o próximo inteiro maior)
Math.ceil(-4.9);     // -4

// Calcular número mínimo de páginas necessárias
totalItens = 25;
itensPorPagina = 10;
Math.ceil(totalItens / itensPorPagina);   // 3 páginas

totalItens = 30;
itensPorPagina = 10;
Math.ceil(totalItens / itensPorPagina);   // 3 páginas

// Calcular número de caixas necessárias
totalProdutos = 47;
produtosPorCaixa = 12;
Math.ceil(totalProdutos / produtosPorCaixa);  // 4 caixas

Remove a parte decimal de um número, mantendo apenas a parte inteira. Diferente de floor() e ceil(), simplesmente “corta” os dígitos após o ponto decimal sem arredondar, sempre movendo em direção a zero.

Sintaxe

Math.trunc(x)

Parâmetros

x: Um número.

Valor de retorno

A parte inteira de x (sem casas decimais).

Exemplos

Math.trunc(4.9);     // 4 (remove .9)
Math.trunc(4.1);     // 4 (remove .1)
Math.trunc(-4.9);    // -4 (remove .9, move para zero)
Math.trunc(-4.1);    // -4 (remove .1, move para zero)

// Comparação entre trunc e floor com números negativos
Math.trunc(-4.7);    // -4 (remove decimal)
Math.floor(-4.7);    // -5 (arredonda para baixo)

// Separar parte inteira de um número
numero = 123.456;
parteInteira = Math.trunc(numero);        // 123
parteDecimal = numero - parteInteira;     // 0.456

Operações de Potenciação e Raízes 

Math.pow()

Calcula a potência de um número, elevando a base ao expoente (base^expoente). Esta operação multiplica a base por ela mesma o número de vezes indicado pelo expoente.

Sintaxe

Math.pow(base, expoente)

Parâmetros

base: O número da base.
expoente: O expoente usado para elevar a base.

Valor de retorno

A base elevada à potência do expoente.

Exemplos

// Potências simples (multiplicação repetida)
Math.pow(7, 2);    // 49 (7 × 7)
Math.pow(7, 3);    // 343 (7 × 7 × 7)
Math.pow(2, 10);   // 1024 (2¹⁰, útil em computação)

// Expoentes fracionários calculam raízes
Math.pow(4, 0.5);     // 2 (raiz quadrada: 4^(1/2) = √4)
Math.pow(8, 1/3);     // 2 (raiz cúbica: 8^(1/3) = ∛8)
Math.pow(27, 1/3);    // 3 (raiz cúbica: 27^(1/3) = ∛27)

// Expoentes negativos calculam divisões
Math.pow(2, -1);      // 0.5 (2⁻¹ = 1/2)
Math.pow(10, -2);     // 0.01 (10⁻² = 1/100)

// Cálculo de juros compostos: M = C × (1 + i)^t
capital = 1000;
taxa = 0.05;    // 5%
tempo = 3;      // 3 anos
capital * Math.pow(1 + taxa, tempo);  // 1157.63

Nota

Você também pode usar o operador de exponenciação ** como alternativa: 2 ** 3 é equivalente a Math.pow(2, 3)

Math.sqrt()

Calcula a raiz quadrada de um número, ou seja, encontra o número que multiplicado por ele mesmo resulta no valor fornecido (√x = y, onde y² = x).

Sintaxe

Math.sqrt(x)

Parâmetros

x: Um número maior ou igual a zero.

Valor de retorno

A raiz quadrada do número fornecido.

Atenção

Retorna NaN se o número for negativo (não há raiz quadrada real de números negativos).

Exemplos

Math.sqrt(9);      // 3 (3 × 3 = 9)
Math.sqrt(16);     // 4 (4 × 4 = 16)
Math.sqrt(2);      // 1.414... (√2 é irracional)
Math.sqrt(0);      // 0
Math.sqrt(-1);     // NaN (número negativo)

// Calcular lado de um quadrado conhecendo a área
area = 25;
Math.sqrt(area);   // 5 metros de lado

// Calcular hipotenusa (Teorema de Pitágoras: c = √(a² + b²))
cateto1 = 3;
cateto2 = 4;
Math.sqrt(Math.pow(cateto1, 2) + Math.pow(cateto2, 2));  // 5

Math.cbrt()

Calcula a raiz cúbica de um número, ou seja, encontra o número que multiplicado por ele mesmo três vezes resulta no valor fornecido (∛x = y, onde y³ = x).

Sintaxe

Math.cbrt(x)

Parâmetros

x: Um número (pode ser negativo).

Valor de retorno

A raiz cúbica do número fornecido.

Exemplos

Math.cbrt(8);      // 2 (2 × 2 × 2 = 8)
Math.cbrt(27);     // 3 (3 × 3 × 3 = 27)
Math.cbrt(-8);     // -2 (raiz cúbica de negativo é válida)
Math.cbrt(0);      // 0

// Calcular aresta de um cubo conhecendo o volume
volume = 64;
Math.cbrt(volume);  // 4 metros de aresta

Math.hypot()

Calcula a hipotenusa ou distância euclidiana usando o Teorema de Pitágoras. Retorna √(a² + b²) sem risco de overflow ou underflow em cálculos intermediários.

Sintaxe

Math.hypot(valor1, valor2)

Parâmetros

valor1, valor2: Números dos quais calcular a hipotenusa.

Valor de retorno

A raiz quadrada da soma dos quadrados (√(valor1² + valor2²)).

Atenção

Retorna NaN se algum argumento não puder ser convertido para número.

Exemplos

// Teorema de Pitágoras: triângulo com catetos 3 e 4
Math.hypot(3, 4);
// 5 (hipotenusa = √(3² + 4²) = √(9 + 16) = √25 = 5)

// Calcular distância entre dois pontos no plano cartesiano
// Fórmula: d = √((x2-x1)² + (y2-y1)²)
x1 = 0, y1 = 0;
x2 = 3, y2 = 4;
Math.hypot(x2 - x1, y2 - y1);
// 5 (distância do ponto (0,0) ao ponto (3,4))

// Distância entre dois pontos quaisquer
pontoA_x = 1, pontoA_y = 2;
pontoB_x = 4, pontoB_y = 6;
Math.hypot(pontoB_x - pontoA_x, pontoB_y - pontoA_y);
// 5 (distância entre os pontos)

Funções Trigonométricas 

Math.sin()

Calcula o seno de um ângulo em radianos. O seno representa a razão entre o cateto oposto e a hipotenusa em um triângulo retângulo, variando entre -1 e 1.

Sintaxe

Math.sin(x)

Parâmetros

x: Um ângulo em radianos.

Valor de retorno

O seno do ângulo (valor entre -1 e 1).

Exemplos

Math.sin(0);                    // 0 (sen 0° = 0)
Math.sin(Math.PI / 2);          // 1 (sen 90° = 1)
Math.sin(Math.PI);              // 0 (sen 180° ≈ 0)
Math.sin(Math.PI * 3/2);        // -1 (sen 270° = -1)

// Trabalhar com graus (converter para radianos primeiro)
graus = 90;
Math.sin(graus * Math.PI / 180);     // 1

graus = 30;
Math.sin(graus * Math.PI / 180);     // 0.5 (sen 30° = 1/2)

// Calcular altura de um objeto usando ângulo de elevação
distancia = 100;     // metros
anguloGraus = 30;
anguloRadianos = anguloGraus * Math.PI / 180;
altura = distancia * Math.sin(anguloRadianos);  // 50 metros

Math.cos()

Calcula o cosseno de um ângulo em radianos. O cosseno representa a razão entre o cateto adjacente e a hipotenusa em um triângulo retângulo, variando entre -1 e 1.

Sintaxe

Math.cos(x)

Parâmetros

x: Um ângulo em radianos.

Valor de retorno

O cosseno do ângulo (valor entre -1 e 1).

Exemplos

Math.cos(0);                    // 1 (cos 0° = 1)
Math.cos(Math.PI / 2);          // 0 (cos 90° ≈ 0)
Math.cos(Math.PI);              // -1 (cos 180° = -1)
Math.cos(Math.PI * 3/2);        // 0 (cos 270° ≈ 0)

// Trabalhar com graus
graus = 60;
Math.cos(graus * Math.PI / 180);     // 0.5 (cos 60° = 1/2)

// Calcular posição em movimento circular
// x = raio × cos(ângulo), y = raio × sin(ângulo)
raio = 10;
angulo = Math.PI / 4;  // 45°
posicaoX = raio * Math.cos(angulo);  // 7.07...
posicaoY = raio * Math.sin(angulo);  // 7.07...

Math.tan()

Calcula a tangente de um ângulo em radianos. A tangente é a razão entre o seno e o cosseno (tan θ = sen θ / cos θ), ou a razão entre cateto oposto e adjacente.

Sintaxe

Math.tan(x)

Parâmetros

x: Um ângulo em radianos.

Valor de retorno

A tangente do ângulo.

Exemplos

Math.tan(0);                    // 0 (tan 0° = 0)
Math.tan(Math.PI / 4);          // 1 (tan 45° = 1)
Math.tan(Math.PI / 2);          // Infinity (tan 90° = ∞, indefinido)

// Calcular inclinação/declive
graus = 45;
Math.tan(graus * Math.PI / 180);  // 1 (inclinação de 45°)

// Calcular altura usando ângulo e distância horizontal
distanciaHorizontal = 50;
anguloGraus = 30;
anguloRadianos = anguloGraus * Math.PI / 180;
altura = distanciaHorizontal * Math.tan(anguloRadianos);  // 28.87 metros

Logaritmos e Exponenciais 

Math.exp()

Calcula e elevado à potência de um número (e^x), onde e é a constante de Euler (≈ 2.718). Esta é a função exponencial natural, fundamental em cálculos de crescimento contínuo.

Sintaxe

Math.exp(x)

Parâmetros

x: Um número (o expoente).

Valor de retorno

e^x (e elevado a x).

Exemplos

Math.exp(0);     // 1 (e⁰ = 1, qualquer número elevado a 0 é 1)
Math.exp(1);     // 2.718... (e¹ = e)
Math.exp(2);     // 7.389... (e²)
Math.exp(-1);    // 0.368... (e⁻¹ = 1/e)

// Crescimento exponencial contínuo: P(t) = P₀ × e^(rt)
populacaoInicial = 1000;
taxa = 0.03;        // 3% ao ano (crescimento contínuo)
anos = 10;
populacaoFinal = populacaoInicial * Math.exp(taxa * anos);
// 1349.86 (crescimento de ~35% em 10 anos)

Math.log()

Calcula o logaritmo natural (base e) de um número. É a operação inversa de Math.exp(): se e^y = x, então ln(x) = y.

Sintaxe

Math.log(x)

Parâmetros

x: Um número maior que zero.

Valor de retorno

O logaritmo natural de x (ln x).

Atenção

Retorna -Infinity para 0 e NaN para números negativos.

Exemplos

Math.log(1);              // 0 (ln 1 = 0, pois e⁰ = 1)
Math.log(Math.E);         // 1 (ln e = 1, pois e¹ = e)
Math.log(10);             // 2.303... (ln 10)
Math.log(0);              // -Infinity
Math.log(-5);             // NaN

// Calcular tempo para duplicar (regra de 70)
// t = ln(2) / taxa
taxaCrescimento = 0.07;  // 7% ao ano
Math.log(2) / taxaCrescimento;  // 9.90 anos

// Calcular taxa de crescimento a partir de dois valores
valorInicial = 100;
valorFinal = 150;
anos = 5;
taxaCrescimento = Math.log(valorFinal / valorInicial) / anos;
// 0.0811 (8.11% ao ano)

Math.log2()

Calcula o logaritmo de base 2 de um número. Responde à pergunta: “2 elevado a que potência resulta em x?” Muito usado em ciência da computação.

Sintaxe

Math.log2(x)

Parâmetros

x: Um número maior que zero.

Valor de retorno

O logaritmo de base 2 de x (log₂ x).

Exemplos

Math.log2(2);        // 1 (2¹ = 2)
Math.log2(4);        // 2 (2² = 4)
Math.log2(8);        // 3 (2³ = 8)
Math.log2(1024);     // 10 (2¹⁰ = 1024)

// Calcular quantos bits são necessários para representar um número
valorMaximo = 255;
Math.ceil(Math.log2(valorMaximo + 1));  // 8 bits

// Determinar profundidade de uma árvore binária completa
totalNos = 127;
Math.floor(Math.log2(totalNos + 1));  // 7 níveis

Math.log10()

Calcula o logaritmo de base 10 de um número (logaritmo decimal). Responde à pergunta: “10 elevado a que potência resulta em x?” Útil em escalas logarítmicas.

Sintaxe

Math.log10(x)

Parâmetros

x: Um número maior que zero.

Valor de retorno

O logaritmo de base 10 de x (log₁₀ x).

Exemplos

Math.log10(10);      // 1 (10¹ = 10)
Math.log10(100);     // 2 (10² = 100)
Math.log10(1000);    // 3 (10³ = 1000)
Math.log10(2);       // 0.301... (10^0.301 ≈ 2)

// Calcular número de dígitos de um inteiro positivo
numero = 12345;
Math.floor(Math.log10(numero)) + 1;  // 5 dígitos

// Calcular magnitude de um terremoto (escala Richter)
amplitude = 1000;
Math.log10(amplitude);  // 3.0 (magnitude)