recursal/MDN huggingface dataset:
Math.atan2()
============

A função **`Math.atan2()`** retorna o arco tangente do coeficiente dos argumentos passado.

Sintaxe
-------
```

Math.atan2(y, x)
```

### Parâmentros

`y`

Primeiro numero.

`x`

Segundo numero.

### Retorno

O arco tagente do coegiente dos parâmetros

Descrição
---------

O `Math.atan2()` método retorna um valor numérico entre -π e π representando o ângulo teta entre (x, y). Assim indo no sentido anti-horario ao ângulo, medido em radianos, entre o eixo X positivo, e o ponto`(x, y)`.Nota os argumentos para essa função: primeiro o eixo Y(ordenadas) e o eixo X(absissas) como segundo parâmetro.

![A simple diagram showing the angle returned by atan2(y, x)](/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2/atan2.png)

`Math.atan2()os argumentos são passados separados x e y enquanto no Math.atan() é passado a razão entre esses argumentos.`

Porque `atan2()` é um método estático de `Math`, você sempre usará `Math.atan2()`, ao inves de um objeto Math criado (`Math` não é um construtor).

Examples
--------

### Using `Math.atan2()`


```js
Math.atan2(90, 15); // 1.4056476493802699
Math.atan2(15, 90); // 0.16514867741462683

Math.atan2(±0, -0);               // ±PI.
Math.atan2(±0, +0);               // ±0.
Math.atan2(±0, -x);               // ±PI for x > 0.
Math.atan2(±0, x);                // ±0 for x > 0.
Math.atan2(-y, ±0);               // -PI/2 for y > 0.
Math.atan2(y, ±0);                // PI/2 for y > 0.
Math.atan2(±y, -Infinity);        // ±PI for finite y > 0.
Math.atan2(±y, +Infinity);        // ±0 for finite y > 0.
Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
Math.atan2(±Infinity, -Infinity); // ±3\*PI/4.
Math.atan2(±Infinity, +Infinity); // ±PI/4.
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.atan2 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.LN10
=========

A propriedade **`Math.LN10`** representa o logaritmo natural de 10, aproximadamente 2.302:


Math.LN10

=
ln
(
10
)
≈
2.302

\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302



| Property attributes of `Math.LN10` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Como `LN10` é uma propriedade estática de `Math`, você sempre deve usa-lo como `Math.LN10`, ao invés de uma propriedade do objeto `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.LN10`

A seguinte função retorna o log natural de 10:


```js
function getNatLog10() {
  return Math.LN10;
}

getNatLog10(); // 2.302585092994046
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln10 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
Math.LN2
========

A propriedade **`Math.LN2`** representa o logaritmo natural (também conhecido como logaritmo neperiano) de 2, que é aproximadamente 0.693:


Math.LN2

=
ln
(
2
)
≈
0.693

\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693



| Property attributes of `Math.LN2` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Por `LN2` ser uma propriedade estática de `Math`, deve-se sempre usá-la como `Math.LN2`, e não como uma propriedade de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.LN2`

A função a seguir retorna o logaritmo natural de 2:


```js
function getNatLog2() {
  return Math.LN2;
}

getNatLog2(); // 0.6931471805599453
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ln2 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log2()`
Math.E
======

A propriedade **`Math.E`** representa a base dos logarítmos naturais, aproximadamente 2.718.


Math.E

=
e
≈
2.718

\mathtt{\mi{Math.E}} = e \approx 2.718

Experimente
-----------

| Property attributes of `Math.E` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Como `E` é uma propriedade estática de `Math`, sempre use-a como `Math.E`, ao invés de uma propriedade de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.E`

A seguinte função retorna o valor de *e*:


```js
function getNapier() {
  return Math.E;
}

getNapier(); // 2.718281828459045
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.e |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log1p()`
Math.floor()
============

Resumo
------

A função **`Math.floor(x)`** retorna o menor número inteiro dentre o número "x".

Sintaxe
-------
```

Math.floor(x)
```

### Parâmetros

`x`

Um número.

Descrição
---------

Por `floor` ser um método estático de `Math`, você sempre irá usar como `Math.floor()`,e não como método do objeto `Math que você criou`.

Exemplos
--------

### Exemplo: Usando `Math.floor`


```js
Math.floor(45.95); // 45
Math.floor(-45.95); // -46
```

### Exemplo: Ajuste Decimal


```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.floor |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* The `Math` object it belongs to.
* `Math.abs`
* `Math.ceil()`
* `Math.round()`
Math.ceil()
===========

Resumo
------

`A função Math.ceil(x)` retorna o menor número inteiro maior ou igual a "x".

Sintaxe
-------
```

Math.ceil(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O menor inteiro maior ou igual ao número fornecido.

Descrição
---------

Por `ceil` ser um método estático de `Math`, você sempre usará como `Math.ceil()`, e não como um método do objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.ceil()`

O exemplo a seguir mostra um exemplo de uso de `Math.ceil()`.


```js
Math.ceil(0.95); // 1
Math.ceil(4); // 4
Math.ceil(7.004); // 8
Math.ceil(-0.95); // -0
Math.ceil(-4); // -4
Math.ceil(-7.004); // -7
```

### Ajuste decimal


```js
// Closure
(function () {
  /\*\*
 \* Decimal adjustment of a number.
 \*
 \* @param {String} type The type of adjustment.
 \* @param {Number} value The number.
 \* @param {Integer} exp The exponent (the 10 logarithm of the adjustment base).
 \* @returns {Number} The adjusted value.
 \*/
  function decimalAdjust(type, value, exp) {
    // If the exp is undefined or zero...
    if (typeof exp === "undefined" || +exp === 0) {
      return Math[type](value);
    }
    value = +value;
    exp = +exp;
    // If the value is not a number or the exp is not an integer...
    if (isNaN(value) || !(typeof exp === "number" && exp % 1 === 0)) {
      return NaN;
    }
    // Shift
    value = value.toString().split("e");
    value = Math[type](+(value[0] + "e" + (value[1] ? +value[1] - exp : -exp)));
    // Shift back
    value = value.toString().split("e");
    return +(value[0] + "e" + (value[1] ? +value[1] + exp : exp));
  }

  // Decimal round
  if (!Math.round10) {
    Math.round10 = function (value, exp) {
      return decimalAdjust("round", value, exp);
    };
  }
  // Decimal floor
  if (!Math.floor10) {
    Math.floor10 = function (value, exp) {
      return decimalAdjust("floor", value, exp);
    };
  }
  // Decimal ceil
  if (!Math.ceil10) {
    Math.ceil10 = function (value, exp) {
      return decimalAdjust("ceil", value, exp);
    };
  }
})();

// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.ceil |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* O objeto `Math` pertence a.
* `Math.abs()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.asinh()
============

A função **`Math.asinh()`** retorna o arco-seno hiperbólico de um número, isto é:



Math.asinh
(
x
)

=
arsinh
(
x
)
=
 the unique 

y

such that

sinh
(
y
)
=
x

\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{o} ; y ; \text{único tal que} ; \sinh(y) = x

Experimente
-----------

Sintaxe
-------
```

Math.asinh(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O arco-seno hiperbólico de um dado número.

Descrição
---------

Como `asinh()` é um métodos estático de `Math`, você deve sempre chamá-lo como `Math.asinh()`, ao invés de um método de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.asinh()`


```js
Math.asinh(1); // 0.881373587019543
Math.asinh(0); // 0
```

Polyfill
--------

Como uma solução simples a expressçao


\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)

 pode ser usada diretamente para uma emulação grosseira pela seguinte função:


```js
Math.asinh =
  Math.asinh ||
  function (x) {
    if (x === -Infinity) {
      return x;
    } else {
      return Math.log(x + Math.sqrt(x \* x + 1));
    }
  };
```


Apesar de formalmente correta, ela sofre de algumas problemas relacionadas à computação de ponto flutuante. Resultados precisos precisam de tratamento especial de positivos/negativos e argumentos pequenos/grandes como feitos por exemplo em em glibc ouGNU Scientific Library.

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.asinh |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.acosh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.log1p()
============

A função **`Math.log1p()`** retorna o logaritmo natural (base `e`) de 1 + um número, isto é



∀
x
>
-
1
,

Math.log1p
(
x
)

=
ln
(
1
+
x
)

\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)

Experimente
-----------

Sintaxe
-------
```

Math.log1p(x)
```

### Parâmetros

`x`

Um número.

### Valor de retorno

O logaritmo natural (base `e`) de **1** mais o número fornecido. Se o número for menor que **-1**, `NaN` será retornado.

Descrição
---------

Para valores muito pequenos de *x*, adicionando 1 pode reduzir ou eliminar precisão. Valores double floats costuman te dar em torno de 15 digitos de precisão no JavaScript. 1 + 1e-15 = 1.000000000000001, porém, 1 + 1e-16 = 1.000000000000000 e portanto, exatamente 1.0 naquele resultado, porque os números que passam de 15 digitos são arredondados.

Quando você calcula log(1 + x), você obterá um resultado muito perto de x, se x for um valor pequeno (isto é, porque eles são chamados logaritmos 'naturais'). Se você calcular Math.log(1 + 1.1111111111e-15) você obterá uma resposta perto de1.1111111111e-15. Ao invés, você vai acabar obtendo o logaritmo de 1.00000000000000111022 (o arrendondamento é feito em binário, portanto, as vezes isso pode parecer estranho), então você obterá o resultado 1.11022...e-15, com somente 3 digitos corretos. Se, ao invés, você calcular Math.log1p(1.1111111111e-15) você terá um retorno mais preciso de 1.1111111110999995e-15 com 15 digitos corretos de precisão (na verdade 16 nesse caso).

Se o valor de `x` for menor que -1, o valor retornado será sempre `NaN`.

Por conta do `log1p()` ser um metódo estático de `Math`, você sempre chamará como `Math.log1p()`, ao invés de chamar como um método de um objeto `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.log1p()`


```js
Math.log1p(1); // 0.6931471805599453
Math.log1p(0); // 0
Math.log1p(-1); // -Infinity
Math.log1p(-2); // NaN
```

Polyfill
--------

Isto pode ser implementado com a seguinte função:


```js
Math.log1p =
  Math.log1p ||
  function (x) {
    return Math.log(1 + x);
  };
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log1p |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.expm1()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.exp()
==========

Sumário
-------

A função **`Math.exp()`** retorna `ex`, onde `x` é o argumento, e `e` é a Constante de Euler, a base dos logaritmos naturais

Síntaxe
-------


```js
Math.exp(x);
```

### Parâmetros

`x`

Um número.

Descrição
---------

Pelo fato de `exp` ser um método estático de `Math`, você sempre utiliza-o como `Math.exp()`, não como um método do objeto `Math` que você criou.

Exemplos
--------

### Exemplo: Usando `Math.exp`


```js
Math.exp(-1); // 0.36787944117144233
Math.exp(0); // 1
Math.exp(1); // 2.718281828459045
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.exp |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* O objeto `Math` ao qual ele pertence.
* `Math.E`
* `Math.log()`
* `Math.pow()`
Math.SQRT2
==========

A propriedade **`Math.SQRT2`** representa a raiz quadrada de 2, que é aproximadamente 1.414:


Math.SQRT2

=

2

≈
1.414

\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414



| Property attributes of `Math.SQRT2` |
| --- |
| Writable | no |
| Enumerable | no |
| Configurable | no |

Descrição
---------

Por `SQRT2` ser uma propriedade estática de `Math`, deve-se sempre usá-la como `Math.SQRT2`, e não como propriedade de um objeto `Math` criado por você (`Math` não é um construtor).

Examples
--------

### Usando `Math.SQRT2`

A função a seguir retorna a raiz quadrada de 2:


```js
function getRoot2() {
  return Math.SQRT2;
}

getRoot2(); // 1.4142135623730951
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt2 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.pow()`
* `Math.sqrt()`
Math.tanh()
===========

A função **`Math.tanh()`** retorna a tangente hiperbólica de um número, que é:



tanh
x
=

sinh
x

cosh
x

=

e
x

-

e

-
x


e
x

+

e

-
x

=

e

2
x

-
1

e

2
x

+
1

\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

Experimente
-----------

Syntax
------
```

Math.tanh(x)
```

### Parameters

`x`

Um número.

### Return value

Uma tangente hiperbólica de um número dado.

Description
-----------

Because `tanh()` is a static method of `Math`, you always use it as `Math.tanh()`, rather than as a method of a `Math` object you created (`Math` is not a constructor).

Examples
--------

### Using `Math.tanh()`


```js
Math.tanh(0); // 0
Math.tanh(Infinity); // 1
Math.tanh(1); // 0.7615941559557649
```

Polyfill
--------

This can be emulated with the help of the `Math.exp()` function:


```js
Math.tanh =
  Math.tanh ||
  function (x) {
    var a = Math.exp(+x),
      b = Math.exp(-x);
    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
  };
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.tanh |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
Math.sinh()
===========

A função **`Math.sinh()`** retorna o seno hiperbólico de um número, que pode ser expresso usando a constante e:


Math.sinh(x)

=

e
x

-

e

-
x

2

\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}

Experimente
-----------

Sintáxe
-------
```

Math.sinh(x)
```

### Parâmetros

`x`

Um número.

### Valor retornado

O seno hiperbólico do número dado.

Descrição
---------

Como `sinh()` é um método estático de `Math`, você sempre deve usar como `Math.sinh()`, ao invés de um novo objeto instanciado `Math` (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.sinh()`


```js
Math.sinh(0); // 0
Math.sinh(1); // 1.1752011936438014
```

Polyfill
--------

Isso pode ser emulado com a ajuda da função `Math.exp()`:


```js
Math.sinh =
  Math.sinh ||
  function (x) {
    return (Math.exp(x) - Math.exp(-x)) / 2;
  };
```


ou usando apenas uma chamada para a função `Math.exp()`:


```js
Math.sinh =
  Math.sinh ||
  function (x) {
    var y = Math.exp(x);
    return (y - 1 / y) / 2;
  };
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sinh |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.tanh()`
Math.log2()
===========

A função **`Math.log2()`** retorna o logaritmo de base 2 de um número, que é



∀
x
>
0
,

Math.log2
(
x
)

=

log
2

(
x
)
=
the unique

y

such that

2
y

=
x

\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log\_2(x) = \text{the unique} ; y ; \text{such that} ; 2^y = x

Sintaxe
-------
```

Math.log2(x)
```

### Parâmetros

`x` Um número.

### Retorno

O logaritmo de base 2 de um número. Caso o número seja negativo, `NaN` é retornado.

Descrição
---------

Caso o valor de `x` seja menor que 0, então o retorno será sempre `NaN`.

Por `log2()` ser um método estático de `Math`, você sempre o usará como `Math.log2()`, ao invés de usá-lo como método de um objeto `Math` criado (`Math` não é um construtor).

Esta função é equivalente a `Math.log(x)/Math.log(2)`. Para log2(e) use a constante `Math.LOG2E` que é 1 / `Math.LN2`.

Exemplos
--------

### Usando `Math.log2()`


```js
Math.log2(3); // 1.584962500721156
Math.log2(2); // 1
Math.log2(1); // 0
Math.log2(0); // -Infinity
Math.log2(-2); // NaN
Math.log2(1024); // 10
```

Polyfill
--------

Este Polyfill simula a função `Math.log2`. Note que é retornado um valor não prcesiso Observe que é retornado valores imprecisos em algumas entradas (like 1 << 29), envolva em `Math.round()` se estiver trabalhando com máscaras de bits.


```js
Math.log2 =
  Math.log2 ||
  function (x) {
    return Math.log(x) \* Math.LOG2E;
  };
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.log2 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Veja também
-----------

* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.pow()`
Math.expm1()
============

The **`Math.expm1()`** function returns `ex - 1`, where `x` is the argument, and e the base of the natural logarithms.

Experimente
-----------

Syntax
------
```

Math.expm1(x)
```

### Parameters

`x`

Um número.

### Return value

Um número representando `ex - 1`, onde `e` é Euler's number e `x` ié o argumento.

Description
-----------

Porque `expm1()` é um método estático de is `Math`, você sempre o usurá como `Math.expm1()`, do que como um método de um objeto `Math` que você criou (`Math` não é um contrutor).

Polyfill
--------

This can be emulated with the help of the `Math.exp()` function:


```js
Math.expm1 =
  Math.expm1 ||
  function (x) {
    return Math.exp(x) - 1;
  };
```

Examples
--------

### Using `Math.expm1()`


```js
Math.expm1(-1); // -0.6321205588285577
Math.expm1(0); // 0
Math.expm1(1); // 1.718281828459045
```

Especificações
--------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.expm1 |

Compatibilidade com navegadores
-------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

See also
--------

* `Math.E`
* `Math.exp()`
* `Math.log()`
* `Math.log10()`
* `Math.log1p()`
* `Math.log2()`
* `Math.pow()`