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

A função **`Math.atanh()`** retorna o arco tangente hiperbólico de um número, onde



∀
x
∊

(

-
1
,
1

)

,

Math.atanh
(
x
)

=
arctanh
(
x
)
=
 the unique 

y

such that

tanh
(
y
)
=
x

\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } ; y ; \text{such that} ; \tanh(y) = x

Sintaxe
-------
```

Math.atanh(x)
```

### Parâmetros

`x`

O número.

### Valor retornado

O arco tangente hiperbólico do parâmetro recebido.

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

Por `atanh()` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.atanh()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.atanh()`


```js
Math.atanh(-2); // NaN
Math.atanh(-1); // -Infinity
Math.atanh(0); // 0
Math.atanh(0.5); // 0.5493061443340548
Math.atanh(1); // Infinity
Math.atanh(2); // NaN
```


For values greater than 1 or less than -1, `NaN` is returned.

Para valores menores que -1 ou maiores que 1, `NaN` é retornado.

Polyfill
--------

Para 


|
x
|

<
1

\left|x\right| < 1

, temos 


artanh
(
x
)
=

1
2

ln

(

1
+
x

1
-
x

)

\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)

, esse comportamento pode ser emulado com a seguinte função:


```js
Math.atanh =
  Math.atanh ||
  function (x) {
    return Math.log((1 + x) / (1 - x)) / 2;
  };
```

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

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

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.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.asin()
===========

A função Math.asin() retorna o arco seno (em radianos) de um número, onde



∀
x
∊
[

-
1

;
1
]
,

Math.asin
(
x
)

=
arcsin
(
x
)
=o único valor


y
∊

[

-

π
2

;

π
2

]

tal que sin
(
y
)
=
x

\forall x \in [{-1};1],;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \sin(y) = x

Sintaxe
-------
```

Math.asin(x)
```

### Parâmetros

`x`

Um número.

### Valor retornado

O arco seno (em radianos) do parâmetro recebido se o parâmetro estiver entre **-1** e **1**; senão, `NaN`.

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

O método `Math.asin()` retorna um valor numérico entre 


-

π
2

-\frac{\pi}{2}

 e 


π
2

\frac{\pi}{2}

 radianos para todo `x` entre -1 e 1. Se o valor de `x` estiver fora deste intervalo `NaN` é retornado.

Por `asin()` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.asin()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.asin()`


```js
Math.asin(-2); // NaN
Math.asin(-1); // -1.5707963267948966 (-pi/2)
Math.asin(0); // 0
Math.asin(0.5); // 0.5235987755982989
Math.asin(1); // 1.5707963267948966 (pi/2)
Math.asin(2); // NaN
```


Para valores menores que -1 ou maiores que 1, `Math.asin()` retorna `NaN`.

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

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

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

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

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

* `Math.acos()`
* `Math.atan()`
* `Math.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.random()
=============

Sumário
-------

A função **`Math.random()`** retorna um número pseudo-aleatório no intervalo `[0, 1[`, ou seja, de 0 (inclusivo) até, mas não incluindo, 1 (exclusivo), que depois você pode dimensionar para um intervalo desejado. A implementação seleciona uma semente para o algoritmo de geração de números aleatórios; esta semente não pode ser escolhida ou reatribuída.

**Nota:** **`Math.random()`** não gera números criptograficamente seguros. Não a use para nada relacionado a segurança. Use a API Web Crypto, mais precisamente o método `window.crypto.getRandomValues()`.

Sintaxe
-------
```

Math.random()
```

### Valor retornado

Um número pseudo-aleatório entre 0 (inclusivo) e 1 (exclusivo).

Exemplos
--------

Note que os números em JavaScript são pontos flutuantes que seguem o padrão IEEE 754 com comportamento *arredondar-para-o-par-mais-próximo*, os intervalos que serão citados nos exemplos a seguir (exceto o exemplo do `Math.random()`), não são exatas. Se limites extremamente grandes forem escolhidos (253 ou maior), em raros casos é possível que o limite superior (que seria exclusivo) seja retornado.

### Gerando um número aleatório entre 0 (inclusivo) e 1 (exclusivo)


```js
function getRandom() {
  return Math.random();
}
```

### Gerando um número aleatório entre dois valores

Este exemplo retorna um número entre dois valores definidos. O valor retornado será maior ou igual a `min`, e menor que `max`.


```js
function getRandomArbitrary(min, max) {
  return Math.random() \* (max - min) + min;
}
```

### Gerando um número inteiro aleatório entre dois valores

Este exemplo retorna um número *inteiro* entre dois valores definidos. O valor não poderá ser menor que `min` (ou do próximo inteiro maior que `min`, caso `min` não seja inteiro), e será menor (mas não igual) a `max`.


```js
function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min) + min);
}
```


**Nota:** Pode ser tentandor usar `Math.round()` para arredondar `min` e `max`, mas dessa maneira a aleatoriedade dos números seguiria uma distribuição não-uniforme, que talvez não seja o que você precisa.

### Gerando um número inteiro aleatório entre dois valores, inclusive

A função `getRandomInt()` acima tem intervalo com o valor mínimo incluído e o máximo excluído. Mas se você precisar que a função inclua, tanto o mínimo quanto o máximo, em seus resultados? A função `getRandomIntInclusive()` abaixo faz isso.


```js
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min + 1)) + min;
}
```

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

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Math.log10()
============

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



∀
x
>
0
,

Math.log10
(
x
)

=

log
10

(
x
)
=
the unique

y

such that

10
y

=
x

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

Sintaxe
-------
```

Math.log10(x)
```

### Parâmetros

`x`

Um número.

### Retorno

O logaritmo de base 10 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 `log10()` ser um método estático de `Math`, você sempre o usará como `Math.log10()`, 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(10). Para log10(e) use a constante `Math.LOG10E` que é 1 / `Math.LN10`.

Exemplos
--------

### Usando `Math.log10()`


```js
Math.log10(2); // 0.3010299956639812
Math.log10(1); // 0
Math.log10(0); // -Infinity
Math.log10(-2); // NaN
Math.log10(100000); // 5
```

Polyfill
--------

Isso pode ser simulado a partir da seguinte função:


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

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

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

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.log2()`
* `Math.pow()`
Math.acosh()
============

A função Math.acosh() retorna o arco cosseno hiperbólico de um número, onde



∀
x
≥
1
,

Math.acosh
(
x
)

=
arcosh
(
x
)
=
 the unique 

y
≥
0

such that

cosh
(
y
)
=
x

\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } ; y \geq 0 ; \text{such that} ; \cosh(y) = x

Sintaxe
-------
```

Math.acosh(x)
```

### Parâmetros

`x`

Um número.

### Valor retornado

The hyperbolic arc-cosine of the given number. If the number is less than **1**, `NaN`.

O arco cosseno hiperbólico do número recebido. Se o número for menor que 1, `NaN` é retornado.

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

Por `acosh()` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.acosh()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.acosh()`


```js
Math.acosh(-1); // NaN
Math.acosh(0); // NaN
Math.acosh(0.5); // NaN
Math.acosh(1); // 0
Math.acosh(2); // 1.3169578969248166
```


For values less than 1 `Math.acosh()` returns `NaN`.

Para valores menores que 1, `Math.acosh()` retornará `NaN`.

Polyfill
--------

Para todo 


x
≥
1

x \geq 1

, temos 


arcosh
(
x
)
=
ln

(

x
+

x
2

-
1

)

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

. Dessa maneira, este comportamento pode ser emulado da seguinte maneira:


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

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

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

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

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

See also
--------

* `Math.asinh()`
* `Math.atanh()`
* `Math.cosh()`
* `Math.sinh()`
* `Math.tanh()`
Math.log()
==========

A função **`Math.log()`** retorna o logaritmo natural(base `e`) de um número, que é:



∀
x
>
0
,

Math.log
(
x
)

=
ln
(
x
)
=
the unique

y

such that

e
y

=
x

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

Sintaxe
-------
```

Math.log(x)
```

### Parâmetros

`x`

Um número.

### Retorno

O logaritmo natural (base `e`) de um número dado. Se o número é negativo, `NaN` é retornado.

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

Se o valor de `x` é negativo, o retorno será sempre `NaN`.

Por `log()` ser um método estático de `Math`, você sempre o usará como `Math.log()`, ao invés de um método de um objeto de `Math` que você criou(`Math` não é um construtor).

Caso você precise do logaritmo natural de 2 ou 10, use as constantes `Math.LN2` ou `Math.LN10` . Caso você precise de um logaritmo de base 2 ou 10, use `Math.log2()` ou `Math.log10()` . Caso você precise utilizar logaritmo de outras bases, use Math.log(x) / Math.log(outraBase) como no exemplo abaixo; talvez você queira pré-calcular 1 / Math.log(outraBase) .

Exemplos
--------

### Usando `Math.log()`


```js
Math.log(-1); // NaN, out of range
Math.log(0); // -Infinity
Math.log(1); // 0
Math.log(10); // 2.302585092994046
```

### Usando `Math.log()` como uma base diferente

As funções a seguir retornam o logaritmo de `y` na base `x` (ie. 


log
x

y

\log\_x y

):


```js
function getBaseLog(x, y) {
  return Math.log(y) / Math.log(x);
}
```


Caso você execute `getBaseLog(10, 1000)` será retornado `2.9999999999999996` devido ao arredondamento de ponto-flutuante, o qual é bem próximo do retorno exato de 3.

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

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

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

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

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

* `Math.exp()`
* `Math.log1p()`
* `Math.log10()`
* `Math.log2()`
* `Math.pow()`
Math.sin()
==========

A função **`Math.sin()`** retorna o seno de um número.

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

Sintaxe
-------
```

Math.sin(x)
```

### Paramêtros

`x`

Um número (dado em radianos)

### Valor retornado

O seno de um número dado.

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

O método `Math.sin()` retorna um valor numérico entre -1 e 1, que representa o seno de um angulo dado em radianos.

Como `sin()` é um método estático de `Math`, você sempre o usa como `Math.sin()`, ao invés de um método de um objeto Math que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.sin()`


```js
Math.sin(0); // 0
Math.sin(1); // 0.8414709848078965

Math.sin(Math.PI / 2); // 1
```

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

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

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.atan2()`
* `Math.cos()`
* `Math.tan()`
Math.tan()
==========

Resumo
------

A função **`Math.tan()`** retorna a tangente de um número.

Sintaxe
-------
```

Math.tan(x)
```

### Parâmetros

`x`

Um número representando um ângulo em radianos.

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

O método `tan` retorna um valor numérico que representa a tangente do ângulo.

Como `tan` é um método estático de `Math`, use sempre `Math.tan()`, ao invés de um método de um objeto `Math` que você tenha criado.

Exemplos
--------

### Exemplo: Usando `Math.tan`

A seguinte função retorna a tangente da variável `x`:


```js
function getTan(x) {
  return Math.tan(x);
}
```


Como a função `Math.tan()` trabalha com radianos, mas normalment epe mais fácil trabalhar em graus, a seguinte função aceita um valor em graus, converte-o para radianos e retorna a tangente.


```js
function getTanDeg(deg) {
  var rad = (deg \* Math.PI) / 180;
  return Math.tan(rad);
}
```

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

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

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

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.
Math.sqrt()
===========

Resumo
------

A função **Math.sqrt()** retorna a raiz quadrada de um número (


x

\sqrt{x}

) .

Sintaxe
-------
```

Math.sqrt(x)
```

### Parâmetros

`x`

Um número.

### Valor retornado

A raiz quadrada do número recebido. Se o número for negativo, a função retornará `NaN`.

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

Se o valor de `x` for negativo, `Math.sqrt()` retorna `NaN`.

Por `sqrt` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.sqrt()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Exemplo: Usando `Math.sqrt`


```js
Math.sqrt(9); // 3
Math.sqrt(2); // 1.414213562373095

Math.sqrt(1); // 1
Math.sqrt(0); // 0
Math.sqrt(-1); // NaN
```

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

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

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

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

Ver também
----------

* `Math.cbrt()`
* `Math.exp()`
* `Math.log()`
* `Math.pow()`
Math.cosh()
===========

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


Math.cosh(x)

=

e
x

+

e

-
x

2

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

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

Sintaxe
-------
```

Math.cosh(x)
```

### Parâmetros

**`x`**

Um número.

### Valor de retorno

O cosseno hiperbólico do número dado.

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

Por `cosh()` ser um método estático de `Math`, sempre utilize como `Math.cosh()`, ao invés de como um método de um objeto `Math` que você criou (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.cosh()`


```js
Math.cosh(0); // 1
Math.cosh(1); // 1.5430806348152437
Math.cosh(-1); // 1.5430806348152437
```

Polyfill
--------

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


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


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


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

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

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

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.sinh()`
* `Math.tanh()`
Math.SQRT1\_2
=============

A propriedade `Math.SQRT1_2` representa a raiz quadrada de 


1
2

\frac{1}{2}

, que é aproximadamente 0.707:



Math.SQRT1\_2

=

1
2

=

1

2

≈
0.707

\mathtt{\mi{Math.SQRT1\_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707



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

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

Por `SQRT1_2` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.SQRT1_2()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.SQRT1_2`

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


```js
function getRoot1\_2() {
  return Math.SQRT1\_2;
}

getRoot1\_2(); // 0.7071067811865476
```

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

| Specification |
| --- |
| ECMAScript Language Specification # sec-math.sqrt1\_2 |

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.pow()
==========

A função **`Math.pow()`** retorna a *base* elevada ao expoente *power*, ou seja, `baseexpoente`.

Sintaxe
-------
```

Math.pow(base, expoente)
```

### Parâmetros

`base`

O número da base.

`expoente`

O expoente usado para elevar a `base`.

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

Como `pow()` é um método estático de `Math`, você sempre irá usá-lo como `Math.pow()`, ao invés de usá-lo como um método de um objeto do tipo `Math` que você tenha criado (`Math` não é um construtor).

Exemplos
--------

### Usando `Math.pow()`


```js
// simples
Math.pow(7, 2); // 49
Math.pow(7, 3); // 343
Math.pow(2, 10); // 1024
// expoentes fracionários
Math.pow(4, 0.5); // 2 (raiz quadrada de 4)
Math.pow(8, 1 / 3); // 2 (raiz cúbica de 8)
Math.pow(2, 0.5); // 1.4142135623730951 (raiz quadrada de 2)
Math.pow(2, 1 / 3); // 1.2599210498948732 (raiz cúbica de 2)
// expoentes com sinais
Math.pow(7, -2); // 0.02040816326530612 == (1/7)2 == (1/49)
Math.pow(8, -1 / 3); // 0.5 == (1/8)1/3 == 1/2
// bases com sinal
Math.pow(-7, 2); // 49 (quadrados sempre são positivos)
Math.pow(-7, 3); // -343 (cubos podem ser negativos conforme a base)
Math.pow(-7, 0.5); // NaN (números negativos não tem uma raiz quadrada real)
// devido ao fato que raízes "par" e "ímpar" são próximas,
// e limitam a precisão de ponto flutuante,
// bases negativas com expoentes fracionários sempre retornam NaN
Math.pow(-7, 1 / 3); // NaN
```

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

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

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

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

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

* `Math.cbrt()` 
Experimental
* `Math.exp()`
* `Math.log()`
* `Math.sqrt()`
* Operador Exponencial (en-US) 
Experimental
Math.atan()
===========

A função **`Math.atan()`** retorna a arco tangente (em radianos) de um número, onde



Math.atan
(
x
)

=
arctan
(
x
)
=
 the unique 

y
∊

[

-

π
2

;

π
2

]

such that

tan
(
y
)
=
x

\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } ; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] , \text{such that} ; \tan(y) = x

Sintaxe
-------
```

Math.atan(x)
```

### Parâmetros

`x`

Um número.

### Valor retornado

O arco tangente (em radianos) do parâmetro recebido.

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

O método `Math.atan()` retorna um valor numérico entre 


-

π
2

-\frac{\pi}{2}

 e 


π
2

\frac{\pi}{2}

 radianos.

Por `atan()` ser um método estático de `Math`, deve-se sempre usá-lo como `Math.atan()`, e não como um método de um objeto `Math` que você criou.

Exemplos
--------

### Usando `Math.atan()`


```js
Math.atan(1); // 0.7853981633974483
Math.atan(0); // 0
Math.atan(-0); // -0

Math.atan(Infinity); // 1.5707963267948966
Math.atan(-Infinity); // -1.5707963267948966

// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system
Math.atan(y / x);
```


Talvez você queira evitar usar **±**`Infinity` por motivos estéticos. Nesse caso, `Math.atan2()` com `0` como segundo parâmentro pode ser uma solução melhor.

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

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

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.atan2()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.LOG10E
===========

A propriedade **`Math.LOG10E`** representa o logaritmo com base 10 de `e`, aproximadamente 0.434:


Math.LOG10E

=

log
10

(
e
)
≈
0.434

\mathtt{\mi{Math.LOG10E}} = \log\_10(e) \approx 0.434



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

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

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

Exemplos
--------

### Usando `Math.LOG10E`

A função a seguir retorna o logaritmo com base 10 de `e`:


```js
function getLog10e() {
  return Math.LOG10E;
}

getLog10e(); // 0.4342944819032518
```

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

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

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.min()
==========

A função **`Math.min()`** retorna o menor valor passado como parâmetro, ou `NaN` se o parâmetro não é ou não pode ser convertido para um número.

Syntax
------
```

Math.min([valor1[, valor2[, ...]]])
```

### Parâmetros

`valor1, valor2, ...`

Números.

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

Por que `min()` é um método estático de `Math`, você sempre usa como `Math.min()`, e não como um método de um objeto `Math` que você criou (`Math` não é um construtor).

Se nenhum argumento for dado, o resultado é `Infinity`.

Se pelo menos um dos argumentos não pode ser convertido para um número, o resultado é `NaN`.

Exemplos
--------

### Usando `Math.min()`

Este encontra o min de `x` e `y` e atribui a `z` :
```

var x = 10, y = -20;
var z = Math.min(x, y);
```

### Cortando um valor com `Math.min()`

`Math.min()` é muitas vezes usado para cortar um valor sempre menor do que ou igual a um limite. Por exemplo, este.
```

var x = f(foo);

if (x > boundary) {
  x = boundary;
}
```


pode ser escrita como este
```

var x = Math.min(f(foo), boundary);
```


`Math.max()` pode ser usado de uma maneira semelhante ao corte de um valor na outra extremidade.

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

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

Compatibilidade do navegador
----------------------------

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

Veja Também
-----------

* `Math.max()`