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

La méthode statique **`Math.max()`** renvoie le plus grand nombre parmi ceux passés en paramètres, ou `-Infinity` si aucun paramètre n'est fourni.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.max()
Math.max(valeur0)
Math.max(valeur0, valeur1)
Math.max(valeur0, valeur1, /\* … ,\*/ valeurN)
```

### Paramètres

`valeur1`, `valeur2`, … , `valeurN`

Zéro ou plusieurs nombres dont le plus grand sera renvoyé par la méthode.

### Valeur de retour

Le plus grand des nombres passés en arguments. S'il existe un des arguments qui ne peut pas être converti en nombre, c'est `NaN` qui sera renvoyé. Si aucun paramètre n'est passé, c'est `-Infinity` qui est renvoyé.

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

`max()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.max()`, elle ne doit pas être appelée comme la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

`Math.max.length` vaut 2, un signal faible indiquant qu'elle est conçue pour au moins deux paramètres.

Exemples
--------

### Utiliser `Math.max()`


```js
Math.max(10, 20); // 20
Math.max(-10, -20); // -10
Math.max(-10, 20); // 20
```

### Obtenir l'élément maximum d'un tableau

La méthode `Array.prototype.reduce()` peut être utilisée pour déterminer la valeur maximale d'un tableau de nombre en comparant les valeurs qui se suivent :


```js
const arr = [1, 2, 3];
const max = arr.reduce((a, b) => Math.max(a, b), -Infinity);
```


On peut également utiliser `Function.prototype.apply()` afin de trouver le maximum parmi un tableau de nombres. Avec la fonction suivante, `getMaxTableau([1,2,3])` sera équivalent à `Math.max(1, 2, 3)`, mais `getMaxTableau` pourra être utilisé sur des tableaux construits dans les scripts. Cet usage est à réserver aux tableaux qui ont relativement peu d'éléments (voir avertissement ci-après).


```js
function getMaxTableau(tableauNumérique) {
  return Math.max.apply(null, tableauNumérique);
}
```


Avec la syntaxe de décomposition, on pourra également utiliser cette forme, plus concise :


```js
const arr = [1, 2, 3];
const max = Math.max(...arr);
```


**Attention :** Utiliser la décomposition ou `apply()` de cette façon pourra échouer s'il y a trop d'éléments dans le tableau (car ceux-ci seront passés en arguments). Pour plus d'informations, consulter Utiliser `apply()` et les fonctions natives. La méthode proposée avec `reduce()` n'a pas cette contrainte.

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.min()`
Math.min()
==========

La fonction **`Math.min()`** renvoie le plus petit nombre d'une série de 0 ou plusieurs nombres ou bien `NaN` si au moins un des arguments fourni n'est pas un nombre ou ne peut pas être converti en nombre.

Exemple interactif
------------------

Syntaxe
-------


```js
Math.min([valeur1[,valeur2, ...]])
```

### Paramètres

`valeur1, valeur2, ...`

Des nombres.

### Valeur de retour

Le plus petit des nombres passés en arguments. S'il existe un argument qui ne peut pas être converti en nombre, c'est `NaN` qui sera renvoyé. Le résultat sera `Infinity` si aucun paramètre n'est fourni.

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

`min()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.min()` et ne doit pas être utilisée comme la méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).

Si aucun argument n'est fourni, le résultat renvoyé par la fonction sera `Infinity`.

Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera `NaN`.

Exemples
--------

### Utiliser `Math.min()`

Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z :


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

### Ramener une valeur dans un intervalle (*clipping*) avec `Math.min()`

`Math.min()` est souvent utilisée afin de ramener une certaine valeur dans un intervalle donné. Par exemple :


```js
var x = f(toto);

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


peut s'écrire


```js
var x = Math.min(f(toto), limite);
```


`Math.max()` peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné.

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.max()`
Math.sinh()
===========

La fonction **`Math.sinh()`** renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante `e`, est :


Math.sinh(x)

=

e
x

-

e

-
x

2

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

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le sinus hyperbolique de la valeur passée en argument.

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

`sinh()` est une méthode statique de `Math`, il faut utiliser la syntaxe `Math.sinh()`. Cette méthode ne doit pas être appelée depuis un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------


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

Prothèse d'émulation (*polyfill*)
---------------------------------

Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction `Math.exp()` :


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


ou encore, si on n'utilise qu'une fois `Math.exp()`, avec :


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

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

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

La fonction **`Math.clz32()`** renvoie le nombre de zéros de tête dans la représentation binaire sur 32 bits d'un nombre.

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur retournée

Le nombre de bits à zéro en tête de la représentation binaire sur 32 bits du nombre donné.

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

"`clz32`" est un raccourci pour CountLeadingZeroes32 (en français, « compter les zéros de tête »).

Si `x` n'est pas un nombre, il sera d'abord converti en nombre puis converti en un entier non signé sur 32 bits.

Si l'entier non signé sur 32 bits résultant vaut `0`, la fonction renverra `32`, car tous les bits valent `0`.

Cette fonction est particulièrement utile aux systèmes qui compilent du code JavaScript, comme Emscripten.

Exemples
--------


```js
Math.clz32(1); // 31
Math.clz32(1000); // 22
Math.clz32(); // 32

var liste = [
  NaN,
  Infinity,
  -Infinity,
  0,
  -0,
  null,
  undefined,
  "machin",
  {},
  [],
];
liste.every((n) => Math.clz32(n) == 32); // true

Math.clz32(true); // 31
Math.clz32(3.5); // 30
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math`
* `Math.imul`
Math.log2()
===========

La fonction **`Math.log2()`** renvoie le logarithme en base 2 d'un nombre :



∀
x
>
0
,

Math.log2
(
x
)

=

log
2

(
x
)
=
l'unique 

y

tel que

2
y

=
x

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

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est `NaN` qui sera renvoyé.

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

Si `x` est strictement inférieur à 0, la valeur renvoyée sera `NaN`.

`log2()` étant une méthode statique de `Math`, il faut utiliser `Math.log2()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Si on souhaite utiliser des constantes, on pourra employer `Math.LOG2E` ou `Math.LN2`.

Exemples
--------

### Utiliser `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
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

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

La fonction **`Math.atan2()`** renvoie l'arc tangente du quotient de ses arguments, ce qui, pour `Math.atan2(y,x)`, correspond à l'angle plan (exprimé en radians) entre la droite passant par l'origine et le point de coordonnées (x,y).

Exemple interactif
------------------

Syntaxe
-------


```js
Math.atan2(y, x);
```

### Paramètres

`y`

La coordonnée en ordonnée du point.

`x`

La coordonnée en abscisse du point.

### Valeur de retour

L'arc tangente du quotient formé par les deux arguments (compris dans 


[
-
π
,
π
]

[-\pi, \pi]

), c'est-à-dire l'angle, exprimé en radians entre l'axe des abscisses et la droite passant par l'origin (0,0) et le point de coordonnées (x,y).

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

La méthode `Math.atan2()` renvoie une valeur numérique comprise entre -Pi et Pi qui représente l'angle theta d'un point de coordonnées (x,y). Cela correspond à l'angle (dans le sens trigonométrique) entre l'axe des abscisses et le point de coordonnées (`x,y`). Attention, le premier argument de la fonction est l'ordonnée (y) et le second est l'abscisse (x).

![Graphique explicitant l'angle donné par un point de coordonnées X/Y](/fr/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2/atan2.png)

`Math.atan2()` utilise deux arguments `x` et `y`, alors que la méthode `Math.atan()` utilise le ratio de deux nombres comme un seul argument.

`atan2()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe `Math.atan2()`, elle ne doit pas être utilisée comme la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `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 pour x > 0.
Math.atan2( ±0, x );                // ±0 pour x > 0.
Math.atan2( -y, ±0 );               // -PI/2 pour y > 0.
Math.atan2( y, ±0 );                // PI/2 pour y > 0.
Math.atan2( ±y, -Infinity );        // ±PI pour y qui est un nombre fini > 0.
Math.atan2( ±y, +Infinity );        // ±0 pour y qui est un nombre fini > 0.
Math.atan2( ±Infinity, x );         // ±PI/2 pour x qui est un nombre fini.
Math.atan2( ±Infinity, -Infinity ); // ±3\*PI/4.
Math.atan2( ±Infinity, +Infinity ); // ±PI/4.
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.cos()`
* `Math.sin()`
* `Math.tan()`
Math.SQRT1\_2
=============

La propriété **`Math.SQRT1_2`** représente la racine carrée d'1/2 et vaut environ 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

Exemple interactif
------------------

| Attributs de `Math.SQRT1_2` |
| --- |
| Écrivable | Non |
| Énumérable | Non |
| Configurable | Non |

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

`SQRT1_2` est une propriété statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.SQRT1_2`. Elle ne doit pas être obtenue à partir d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

La fonction suivante renvoie la valeur de cette constante :


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

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

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

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

La fonction **`Math.tanh()`** renvoie la tangente hyperbolique d'un nombre définie par :



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}

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur de retour

La tangente hyperbolique du nombre fourni en argument.

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

`tanh()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe `Math.tanh()`, elle ne doit pas être utilisée comme une méthode d'un objet `Math` qui aurait été instancié (`Math` n'est pas une constructeur).

Exemples
--------

### Utiliser `Math.tanh()`


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

Prothèse d'émulation (*polyfill*)
---------------------------------

Cette méthode peut être émulée grâce à la fonction `Math.exp()` :


```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);
  };
```


et si on souhaite n'utiliser qu'un seul appel à `Math.exp()` :


```js
Math.tanhx =
  Math.tanhx ||
  function (x) {
    if (x === Infinity) {
      return 1;
    } else if (x === -Infinity) {
      return -1;
    } else {
      var y = Math.exp(2 \* x);
      return (y - 1) / (y + 1);
    }
  };
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

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

La fonction **`Math.cos()`** retourne le cosinus d'un angle dont la valeur est exprimée en radians.

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Une valeur numérique (exprimée en radians).

### Valeur de retour

Le cosinus de l'angle fourni en argument (exprimé en radians).

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

La méthode `Math.cos()` renvoie une valeur numérique comprise entre -1 et 1. Cela représente la valeur du cosinus de l'angle correspondant à cette valeur.

`cos` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.cos()`, ne pas utiliser une méthode d'un objet qui aurait été créé (`Math` n'est pas un constructeur).

Exemples
--------

### Utiliser `Math.cos()`


```js
Math.cos(0); // 1
Math.cos(1); // 0.5403023058681398

Math.cos(Math.PI); // -1
Math.cos(2 \* Math.PI); // 1
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.acos()`
* `Math.asin()`
* `Math.atan()`
* `Math.atan2()`
* `Math.sin()`
* `Math.tan()`
Math.floor()
============

La fonction **`Math.floor(x)`** renvoie le plus grand entier qui est inférieur ou égal à un nombre `x`.

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur de retour

Un nombre qui représente le plus grand entier inférieur ou égal à la valeur passée en argument.

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

`floor()` est une méthode statique de l'objet `Math`, elle doit toujours être utilisée avec la syntaxe `Math.floor()`, elle ne doit pas être utilisée avec un autre objet qui aurait été créé (`Math` n'est pas un constructeur).

**Note :** `Math.floor(null)` renvoie `0` et pas `NaN`.

Exemples
--------

### Utiliser `Math.floor`


```js
Math.floor(45.95); // 45
Math.floor(45.05); // 45
Math.floor(4); // 4
Math.floor(-45.05); // -46
Math.floor(-45.95); // -46
Math.floor(null); // 0
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.abs()`
* `Math.ceil()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.abs()
==========

La fonction **`Math.abs()`** retourne la valeur absolue d'un nombre, c'est-à-dire



Math.abs
(
x
)

=

|
x
|

=

{

x

si

x
≥
0

-
x

si

x
<
0


{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{si} \quad x \geq 0 \ -x & \text{si} \quad x < 0 \end{cases}

Exemple interactif
------------------

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur absolue

La valeur absolue du nombre passé en argument.

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

`abs` est une méthode statique de l'objet `Math` et doit toujours être utilisée avec la syntaxe `Math.abs()`.

Exemples
--------

### Utiliser `Math.abs()`

Si la méthode est utilisée avec une chaîne de caractères non numérique, avec un tableau à plus d'un élément, sans paramètre ou avec `undefined`, la valeur retournée sera `NaN`. Si elle est utilisée avec `null`, la fonction renverra 0.


```js
Math.abs("-1"); // 1
Math.abs(-2); // 2
Math.abs(null); // 0
Math.abs(""); // 0
Math.abs([]); // 0
Math.abs([2]); // 2
Math.abs([1, 2]); // NaN
Math.abs({}); // NaN
Math.abs("string"); // NaN
Math.abs(); // NaN
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.ceil()`
* `Math.floor()`
* `Math.round()`
* `Math.sign()`
* `Math.trunc()`
Math.random()
=============

La fonction **`Math.random()`** renvoie un nombre flottant pseudo-aléatoire compris dans l'intervalle `[0, 1[` (ce qui signifie que 0 est compris dans l'intervalle mais que 1 en est exclu) selon une distribution approximativement uniforme sur cet intervalle. Ce nombre peut ensuite être multiplié afin de couvrir un autre intervalle. La graine (*seed*) du générateur est choisie par l'algorithme et ne peut pas être choisie ou réinitialisée par l'utilisateur.

Exemple interactif
------------------

**Note :** `Math.random()` **ne fournit pas** de nombres aléatoires propres à une cryptographie sécurisée. Les résultats de cette méthode ne doivent pas être utilisées dans des applications liées à la sécurité. À la place, on préfèrera utiliser l'API Web Crypto et plus précisément la méthode `window.crypto.getRandomValues()`.

Syntaxe
-------


```js
Math.random();
```

### Valeur de retour

Un nombre flottant pseudo-aléatoire, généré entre 0 (inclus) et 1 (exclu)

Exemples
--------

En JavaScript, les nombres sont représentés comme des nombres flottants selon la norme IEEE 754 et les arrondis sont pris aux plus près. Aussi, les intervalles revendiqués par les fonctions ci-après (en dehors de `Math.random()`) ne sont pas théoriquement et précisément exacts. Si on utilise des bornes supérieures très grande (2^53 ou plus), il est alors possible, dans de très rares cas, d'obtenir la borne supérieure comme résultat alors que celle-ci devrait être exclue de l'intervalle.

### Obtenir un nombre aléatoire entre 0 et 1


```js
// On renvoie un nombre aléatoire entre 0 (inclus) et 1 (exclus)
function getRandom() {
  return Math.random();
}
```

### Obtenir un nombre aléatoire dans un intervalle


```js
// On renvoie un nombre aléatoire entre une valeur min (incluse)
// et une valeur max (exclue)
function getRandomArbitrary(min, max) {
  return Math.random() \* (max - min) + min;
}
```

### Obtenir un entier aléatoire dans un intervalle ouvert à droite


```js
// On renvoie un entier aléatoire entre une valeur min (incluse)
// et une valeur max (exclue).
// Attention : si on utilisait Math.round(), on aurait une distribution
// non uniforme !
function getRandomInt(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min)) + min;
}
```


**Attention :** Utiliser `Math.round()` entraînerait une distribution non-uniforme et réduirait le caractère aléatoire de la méthode.

### Obtenir un entier aléatoire dans un intervalle fermé


```js
// On renvoie un entier aléatoire entre une valeur min (incluse)
// et une valeur max (incluse).
// Attention : si on utilisait Math.round(), on aurait une distribution
// non uniforme !
function getRandomIntInclusive(min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() \* (max - min + 1)) + min;
}
```

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

La fonction **`Math.cosh()`** renvoie le cosinus hyperbolique d'un nombre, défini par :


Math.cosh(x)

=

e
x

+

e

-
x

2

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

Exemple interactif
------------------

(Voir la page sur e)

Syntaxe
-------


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

### Paramètres

`x`

Un nombre.

### Valeur de retour

Le cosinus hyperbolique du nombre passé en argument.

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

`cosh()` étant une méthode statique de `Math`, il faut utiliser `Math.cosh()` et non pas la méthode d'un objet `Math` créé sur mesure (`Math` n'est pas un constructeur).

Exemple
-------

### Utiliser `Math.cosh()`


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

Prothèse d'émulation (*polyfill*)
---------------------------------

Cette fonction peut être émulée grâce à la fonction `Math.exp()` :


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


On peut également utiliser un unique appel à `exp()` :


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

Spécifications
--------------

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

Compatibilité des navigateurs
-----------------------------

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

Voir aussi
----------

* `Math.acosh()`
* `Math.asinh()`
* `Math.atanh()`
* `Math.sinh()`
* `Math.tanh()`