From bf8e099b9c8b3c60d60b3712b4fc97b052c39887 Mon Sep 17 00:00:00 2001 From: julieng Date: Tue, 3 Aug 2021 08:03:23 +0200 Subject: convert content to md --- .../reference/global_objects/math/abs/index.md | 107 +++----- .../reference/global_objects/math/acos/index.md | 112 +++----- .../reference/global_objects/math/acosh/index.md | 106 +++----- .../reference/global_objects/math/asin/index.md | 113 +++----- .../reference/global_objects/math/asinh/index.md | 94 +++---- .../reference/global_objects/math/atan/index.md | 108 +++----- .../reference/global_objects/math/atan2/index.md | 126 ++++----- .../reference/global_objects/math/atanh/index.md | 105 +++----- .../reference/global_objects/math/cbrt/index.md | 89 +++---- .../reference/global_objects/math/ceil/index.md | 118 ++++----- .../reference/global_objects/math/clz32/index.md | 93 +++---- .../reference/global_objects/math/cos/index.md | 106 +++----- .../reference/global_objects/math/cosh/index.md | 114 ++++---- .../reference/global_objects/math/e/index.md | 89 +++---- .../reference/global_objects/math/exp/index.md | 109 +++----- .../reference/global_objects/math/expm1/index.md | 105 ++++---- .../reference/global_objects/math/floor/index.md | 106 +++----- .../reference/global_objects/math/fround/index.md | 87 +++--- .../reference/global_objects/math/hypot/index.md | 120 ++++----- .../reference/global_objects/math/imul/index.md | 95 +++---- .../reference/global_objects/math/index.md | 295 ++++++++++----------- .../reference/global_objects/math/ln10/index.md | 89 +++---- .../reference/global_objects/math/ln2/index.md | 89 +++---- .../reference/global_objects/math/log/index.md | 121 ++++----- .../reference/global_objects/math/log10/index.md | 103 +++---- .../reference/global_objects/math/log10e/index.md | 89 +++---- .../reference/global_objects/math/log1p/index.md | 103 +++---- .../reference/global_objects/math/log2/index.md | 94 +++---- .../reference/global_objects/math/log2e/index.md | 89 +++---- .../reference/global_objects/math/max/index.md | 132 ++++----- .../reference/global_objects/math/min/index.md | 125 ++++----- .../reference/global_objects/math/pi/index.md | 85 ++---- .../reference/global_objects/math/pow/index.md | 106 +++----- .../reference/global_objects/math/random/index.md | 105 +++----- .../reference/global_objects/math/round/index.md | 106 +++----- .../reference/global_objects/math/sign/index.md | 92 +++---- .../reference/global_objects/math/sin/index.md | 105 +++----- .../reference/global_objects/math/sinh/index.md | 109 ++++---- .../reference/global_objects/math/sqrt/index.md | 103 +++---- .../reference/global_objects/math/sqrt1_2/index.md | 75 ++---- .../reference/global_objects/math/sqrt2/index.md | 75 ++---- .../reference/global_objects/math/tan/index.md | 112 +++----- .../reference/global_objects/math/tanh/index.md | 111 ++++---- .../reference/global_objects/math/trunc/index.md | 101 +++---- 44 files changed, 1869 insertions(+), 2847 deletions(-) (limited to 'files/fr/web/javascript/reference/global_objects/math') diff --git a/files/fr/web/javascript/reference/global_objects/math/abs/index.md b/files/fr/web/javascript/reference/global_objects/math/abs/index.md index c632d426db..6a1a7d758d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/abs/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/abs/index.md @@ -9,40 +9,39 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs original_slug: Web/JavaScript/Reference/Objets_globaux/Math/abs --- -
{{JSRef}}
+{{JSRef}} -

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

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

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

+Math.abs(x)=|x|={xsix≥0-xsix<0{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{si} \quad x \geq 0 \\ -x & \text{si} \quad x < 0 \end{cases} -
{{EmbedInteractiveExample("pages/js/math-abs.html")}}
+{{EmbedInteractiveExample("pages/js/math-abs.html")}} -

Syntaxe

+## Syntaxe -
Math.abs(x);
+ Math.abs(x); -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur absolue

+### Valeur absolue -

La valeur absolue du nombre passé en argument.

+La valeur absolue du nombre passé en argument. -

Description

+## Description -

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

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

Exemples

+## Exemples -

Utiliser Math.abs()

+### 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 {{jsxref("undefined")}}, la valeur retournée sera {{jsxref("NaN")}}. Si elle est utilisée avec {{jsxref("null")}}, la fonction renverra 0.

+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 {{jsxref("undefined")}}, la valeur retournée sera {{jsxref("NaN")}}. Si elle est utilisée avec {{jsxref("null")}}, la fonction renverra 0. -
Math.abs('-1');     // 1
+```js
+Math.abs('-1');     // 1
 Math.abs(-2);       // 2
 Math.abs(null);     // 0
 Math.abs('');       // 0
@@ -51,50 +50,26 @@ Math.abs([2]);      // 2
 Math.abs([1,2]);    // NaN
 Math.abs({});       // NaN
 Math.abs("string"); // NaN
-Math.abs();         // NaN
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.abs")}}

- -

Voir aussi

- - +Math.abs(); // NaN +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.abs', 'Math.abs')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.abs")}} + +## Voir aussi + +- {{jsxref("Math.ceil()")}} +- {{jsxref("Math.floor()")}} +- {{jsxref("Math.round()")}} +- {{jsxref("Math.sign()")}} +- {{jsxref("Math.trunc()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/acos/index.md b/files/fr/web/javascript/reference/global_objects/math/acos/index.md index 3a2f6fa132..2d120f115d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/acos/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/acos/index.md @@ -9,92 +9,66 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos original_slug: Web/JavaScript/Reference/Objets_globaux/Math/acos --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.acos() renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par :

+La fonction **`Math.acos()`** renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par : -

∀x∊[-1;1],Math.acos(x)=arccos(x)= le seul  y∊[0;π]tel quecos(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x

+∀x∊[-1;1],Math.acos(x)=arccos(x)= le seul  y∊[0;π]tel quecos(y)=x\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ the unique } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x -
{{EmbedInteractiveExample("pages/js/math-acos.html")}}
+{{EmbedInteractiveExample("pages/js/math-acos.html")}} -

Syntaxe

+## Syntaxe -
Math.acos(x)
+ Math.acos(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre (représentant un angle exprimé en radians).
-
+- `x` + - : Un nombre (représentant un angle exprimé en radians). -

Valeur de retour

+### Valeur de retour -

L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie {{jsxref("NaN")}} sinon.

+L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie {{jsxref("NaN")}} sinon. -

Description

+## Description -

La méthode acos renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de x est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.

+La méthode `acos` renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de `x` est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}. -

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

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

Exemples

+## Exemples -

Utiliser Math.acos()

+### Utiliser `Math.acos()` -
Math.acos(-2);  // NaN
+```js
+Math.acos(-2);  // NaN
 Math.acos(-1);  // 3.141592653589793
 Math.acos(0);   // 1.5707963267948966
 Math.acos(0.5); // 1.0471975511965979
 Math.acos(1);   // 0
 Math.acos(2);   // NaN
-
- -

Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, Math.acos renvoie NaN.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.acos")}}

- -

Voir aussi

- - +``` + +Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.acos` renvoie `NaN`. + +## Spécifications + +| Spécification | Statut | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.acos', 'Math.acos')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.acos")}} + +## Voir aussi + +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.sin()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/acosh/index.md b/files/fr/web/javascript/reference/global_objects/math/acosh/index.md index 26a4b11b80..cb4ff0b1c1 100644 --- a/files/fr/web/javascript/reference/global_objects/math/acosh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/acosh/index.md @@ -10,88 +10,70 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/acosh --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.acosh() renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par :

+La fonction **`Math.acosh()`** renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par : -

∀x≥1,Math.acosh(x)=arcosh(x)= l'unique y≥0tel quecosh(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

+∀x≥1,Math.acosh(x)=arcosh(x)= l'unique y≥0tel quecosh(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 -
{{EmbedInteractiveExample("pages/js/math-acosh.html")}}
+{{EmbedInteractiveExample("pages/js/math-acosh.html")}} -

Syntaxe

+## Syntaxe -
Math.acosh(x)
+ Math.acosh(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera {{jsxref("NaN")}}.

+L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera {{jsxref("NaN")}}. -

Description

+## Description -

acosh étant une méthode statique de Math, il faut l'utiliser avec Math.acosh(), plutôt qu'en faisant appel à une méthode d'un autre objet créé (Math n'est pas un constructeur).

+`acos`h étant une méthode statique de `Math`, il faut l'utiliser avec `Math.acosh()`, plutôt qu'en faisant appel à une méthode d'un autre objet créé (`Math` n'est pas un constructeur). -

Exemple

+## Exemple -

Utiliser Math.acosh()

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

Pour les valeurs strictement inférieures à 1 Math.acosh renvoie {{jsxref("NaN")}}.

+Pour les valeurs strictement inférieures à 1 `Math.acosh` renvoie {{jsxref("NaN")}}. -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Pour tout x≥1x \geq 1, arcosh(x)=ln(x+x2-1)\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right), on peut donc émuler cette fonction avec le code suivant :

+Pour tout x≥1x \geq 1, arcosh(x)=ln(x+x2-1)\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right), on peut donc émuler cette fonction avec le code suivant : -
function acosh(x) {
+```js
+function acosh(x) {
   return Math.log(x + Math.sqrt(x * x - 1));
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}{{Spec2('ES6')}}Définition initiale
{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.acosh")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}} | {{Spec2('ES6')}} | Définition initiale | +| {{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.acosh")}} + +## Voir aussi + +- {{jsxref("Math.asinh()")}} +- {{jsxref("Math.atanh()")}} +- {{jsxref("Math.cosh()")}} +- {{jsxref("Math.sinh()")}} +- {{jsxref("Math.tanh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/asin/index.md b/files/fr/web/javascript/reference/global_objects/math/asin/index.md index b094e1bdce..b7d502cfb9 100644 --- a/files/fr/web/javascript/reference/global_objects/math/asin/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/asin/index.md @@ -9,91 +9,66 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin original_slug: Web/JavaScript/Reference/Objets_globaux/Math/asin --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.asin() renvoie l'arc sinus d'un nombre (en radians). Elle est définie par :

+La fonction **`Math.asin()`** renvoie l'arc sinus d'un nombre (en radians). Elle est définie par : -

∀x∊[-1;1],Math.asin(x)=arcsin(x)= le seul y∊[-π2;π2]tel quesin(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

+∀x∊[-1;1],Math.asin(x)=arcsin(x)= le seul y∊[-π2;π2]tel quesin(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 -
{{EmbedInteractiveExample("pages/js/math-asin.html")}}
+{{EmbedInteractiveExample("pages/js/math-asin.html")}} -

Syntaxe

+## Syntaxe -
Math.asin(x)
+ Math.asin(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'arc sinus du nombre passé en argument (exprimé en radians). Si ce nombre n'est pas compris entre -1 et 1, la valeur renvoyée sera {{jsxref("NaN")}}.

+L'arc sinus du nombre passé en argument (exprimé en radians). Si ce nombre n'est pas compris entre -1 et 1, la valeur renvoyée sera {{jsxref("NaN")}}. -

Description

+## Description -

La méthode Math.asin() renvoie une valeur numérique comprise entre -π2-\frac{\pi}{2} et π2\frac{\pi}{2} pour x compris entre -1 et 1. Si x est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.

+La méthode `Math.asin()` renvoie une valeur numérique comprise entre -π2-\frac{\pi}{2} et π2\frac{\pi}{2} pour `x` compris entre -1 et 1. Si `x` est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}. -

Math.asin() est une méthode statique de Math et doit toujours être utilisée avec la syntaxe Math.asin(), elle ne doit pas être appelée à partir d'un autre objet créé (Math n'est pas un constructeur).

+`Math.asin()` est une méthode statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.asin()`, elle ne doit pas être appelée à partir d'un autre objet créé (`Math` n'est pas un constructeur). -

Exemples

+## Exemples -

Utiliser Math.asin()

+### Utiliser `Math.asin()` -
Math.asin(-2);  // NaN
+```js
+Math.asin(-2);  // NaN
 Math.asin(-1);  // -1.570796326794897 (-pi/2)
 Math.asin(0);   // 0
 Math.asin(0.5); // 0.5235987755982989
 Math.asin(1);   // 1.570796326794897 (pi/2)
-Math.asin(2);   // NaN
- -

Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, Math.asin() renvoie {{jsxref("NaN")}}.

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -
{{Compat("javascript.builtins.Math.asin")}}
- -

Voir aussi

- - +Math.asin(2); // NaN +``` + +Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, `Math.asin()` renvoie {{jsxref("NaN")}}. + +## Spécifications + +| Spécification | Statut | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.asin', 'Math.asin')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.asin")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.sin()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/asinh/index.md b/files/fr/web/javascript/reference/global_objects/math/asinh/index.md index e831b9abcb..607a90d9f4 100644 --- a/files/fr/web/javascript/reference/global_objects/math/asinh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/asinh/index.md @@ -9,80 +9,60 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/asinh --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.asinh() renvoie l'arc sinus hyperbolique d'un nombre :

+La fonction **`Math.asinh()`** renvoie l'arc sinus hyperbolique d'un nombre : -

Math.asinh(x)=arsinh(x)= le seul ytel quesinh(y)=x\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x

+Math.asinh(x)=arsinh(x)= le seul ytel quesinh(y)=x\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x -
{{EmbedInteractiveExample("pages/js/math-asinh.html")}}
+{{EmbedInteractiveExample("pages/js/math-asinh.html")}} -

Syntaxe

+## Syntaxe -
Math.asinh(x)
+ Math.asinh(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'arc sinus hyperbolique du nombre passé en argument.

+L'arc sinus hyperbolique du nombre passé en argument. -

Description

+## Description -

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

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

Exemple

+## Exemple -

Utiliser Math.asinh()

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

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.asinh")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.asinh")}} + +## Voir aussi + +- {{jsxref("Math.acosh()")}} +- {{jsxref("Math.atanh()")}} +- {{jsxref("Math.cosh()")}} +- {{jsxref("Math.sinh()")}} +- {{jsxref("Math.tanh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/atan/index.md b/files/fr/web/javascript/reference/global_objects/math/atan/index.md index 3c6754866d..3f9a23100f 100644 --- a/files/fr/web/javascript/reference/global_objects/math/atan/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/atan/index.md @@ -9,40 +9,39 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atan --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.atan() renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par :

+La fonction **`Math.atan()`** renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par : -

Math.atan(x)=arctan(x)=le seuly∊[-π2;π2]tel quetan(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

+Math.atan(x)=arctan(x)=le seuly∊[-π2;π2]tel quetan(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 -
{{EmbedInteractiveExample("pages/js/math-atan.html")}}
+{{EmbedInteractiveExample("pages/js/math-atan.html")}} -

Syntaxe

+## Syntaxe -
Math.atan(x)
+ Math.atan(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'arc tangente du nombre passé en argument (exprimé en radians).

+L'arc tangente du nombre passé en argument (exprimé en radians). -

Description

+## Description -

La méthode Math.atan() renvoie une valeur numérique comprise entre -π2-\frac{\pi}{2} et π2\frac{\pi}{2}.

+La méthode `Math.atan()` renvoie une valeur numérique comprise entre -π2-\frac{\pi}{2} et π2\frac{\pi}{2}. -

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

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

Exemples

+## Exemples -

Utiliser Math.atan()

+### Utiliser `Math.atan()` -
Math.atan(1);  // 0.7853981633974483
+```js
+Math.atan(1);  // 0.7853981633974483
 Math.atan(0);  // 0
 Math.atan(-0); // -0
 
@@ -52,51 +51,26 @@ Math.atan(-Infinity); // -1.5707963267948966
 // L'angle formé entre la droite [(0,0);(x,y)] et l'axe des abscisses
 // dans un système de coordonnées cartésienne
 Math.atan(y / x);
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -
{{Compat("javascript.builtins.Math.atan")}}
- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.atan', 'Math.atan')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.atan")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.sin()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/atan2/index.md b/files/fr/web/javascript/reference/global_objects/math/atan2/index.md index 24923087e3..c95dd9050b 100644 --- a/files/fr/web/javascript/reference/global_objects/math/atan2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/atan2/index.md @@ -9,102 +9,76 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atan2 --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.atan2() renvoie l'arc tangente du quotient de ses arguments.

+La fonction **`Math.atan2()`** renvoie l'arc tangente du quotient de ses arguments. -
{{EmbedInteractiveExample("pages/js/math-atan2.html")}}
+{{EmbedInteractiveExample("pages/js/math-atan2.html")}} -

Syntaxe

+## Syntaxe -
Math.atan2(y, x)
+ Math.atan2(y, x) -

Paramètres

+### Paramètres -
-
x
-
La coordonnée en abscisse du point.
-
y
-
La coordonnée en ordonnée du point.
-
+- `x` + - : La coordonnée en abscisse du point. +- `y` + - : La coordonnée en ordonnée du point. -

Valeur de retour

+### Valeur de retour -

L'arc tangente du quotient formé par les deux arguments, 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).

+L'arc tangente du quotient formé par les deux arguments, 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

+## 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).

+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

+![Graphique explicitant l'angle donné par un point de coordonnées X/Y](https://mdn.mozillademos.org/files/11565/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.

+`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).

+`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

+## Exemples -

Utiliser Math.atan2()

+### Utiliser `Math.atan2()` -
Math.atan2(90, 15); // 1.4056476493802699
+```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( ±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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.atan2")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.atan2")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.sin()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/atanh/index.md b/files/fr/web/javascript/reference/global_objects/math/atanh/index.md index f159f35630..ce23e62351 100644 --- a/files/fr/web/javascript/reference/global_objects/math/atanh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/atanh/index.md @@ -10,90 +10,71 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/atanh --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.atanh() renvoie l'arc tangente hyperbolique d'un nombre :

+La fonction **`Math.atanh()`** renvoie l'arc tangente hyperbolique d'un nombre : -

∀x∊(-1,1),Math.atanh(x)=arctanh(x)= le seul y  tel quetanh(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

+∀x∊(-1,1),Math.atanh(x)=arctanh(x)= le seul y  tel quetanh(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 -
{{EmbedInteractiveExample("pages/js/math-atanh.html")}}
+{{EmbedInteractiveExample("pages/js/math-atanh.html")}} -

Syntaxe

+## Syntaxe -
Math.atanh(x)
+ Math.atanh(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'arc tangente hyperbolique du nombre passé en argument.

+L'arc tangente hyperbolique du nombre passé en argument. -

Description

+## Description -

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

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

Exemple

+## Exemple -

Utiliser Math.atanh()

+### Utiliser `Math.atanh()` -
Math.atanh(-2);  // NaN
+```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
-
+``` -

Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, {{jsxref("NaN")}} sera renvoyé.

+Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, {{jsxref("NaN")}} sera renvoyé. -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Pour |x|<1\left|x\right| < 1, on a la formule suivante : artanh(x)=12ln(1+x1-x)\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)et on peut donc émuler la fonction avec :

+Pour |x|<1\left|x\right| < 1, on a la formule suivante : artanh(x)=12ln(1+x1-x)\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)et on peut donc émuler la fonction avec : -
Math.atanh = Math.atanh || function(x) {
+```js
+Math.atanh = Math.atanh || function(x) {
   return Math.log((1+x)/(1-x)) / 2;
 };
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.atanh")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | Statut | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.atanh")}} + +## Voir aussi + +- {{jsxref("Math.acosh()")}} +- {{jsxref("Math.asinh()")}} +- {{jsxref("Math.cosh()")}} +- {{jsxref("Math.sinh()")}} +- {{jsxref("Math.tanh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md b/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md index fb9daa3cc0..8fe0f00c04 100644 --- a/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/cbrt/index.md @@ -11,38 +11,37 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cbrt --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.cbrt() renvoie la racine cubique (le nom anglais étant cubic root) d'un nombre :

+La fonction **`Math.cbrt()`** renvoie la racine cubique (le nom anglais étant _cubic root_) d'un nombre : -

Math.cbrt(x)=x3=le seulytel quey3=x\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x

+Math.cbrt(x)=x3=le seulytel quey3=x\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x -
{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}
+{{EmbedInteractiveExample("pages/js/math-cbrt.html")}} -

Syntaxe

+## Syntaxe -
Math.cbrt(x)
+ Math.cbrt(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La racine cubique du nombre passé en argument.

+La racine cubique du nombre passé en argument. -

Description

+## Description -

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

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

Exemple

+## Exemple -

Utiliser Math.cbrt()

+### Utiliser `Math.cbrt()` -
Math.cbrt(NaN); // NaN
+```js
+Math.cbrt(NaN); // NaN
 Math.cbrt(-1); // -1
 Math.cbrt(-0); // -0
 Math.cbrt(-Infinity); // -Infinity
@@ -50,39 +49,21 @@ Math.cbrt(0); // 0
 Math.cbrt(1); // 1
 Math.cbrt(Infinity); // Infinity
 Math.cbrt(null); // 0
-Math.cbrt(2);  // 1.2599210498948732
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.cbrt")}}

- -

Voir aussi

- - +Math.cbrt(2);  // 1.2599210498948732 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.cbrt")}} + +## Voir aussi + +- {{jsxref("Math.pow()")}} +- {{jsxref("Math.sqrt()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/ceil/index.md b/files/fr/web/javascript/reference/global_objects/math/ceil/index.md index 93e8919368..fced464d1b 100644 --- a/files/fr/web/javascript/reference/global_objects/math/ceil/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/ceil/index.md @@ -9,52 +9,51 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil original_slug: Web/JavaScript/Reference/Objets_globaux/Math/ceil --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.ceil() retourne le plus petit entier supérieur ou égal au nombre donné.

+La fonction **`Math.ceil()`** retourne le plus petit entier supérieur ou égal au nombre donné. -
{{EmbedInteractiveExample("pages/js/math-ceil.html")}}
+{{EmbedInteractiveExample("pages/js/math-ceil.html")}} -

Syntaxe

+## Syntaxe -
Math.ceil(x)
+ Math.ceil(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Le plus petit entier qui est supérieur ou égal au nombre donné.

+Le plus petit entier qui est supérieur ou égal au nombre donné. -

Description

+## Description -

ceil() est une méthode statique de Math. Elle doit être utilisée avec la syntaxe Math.ceil(), plutôt que comme une méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+`ceil()` est une méthode statique de `Math`. Elle doit être utilisée avec la syntaxe `Math.ceil()`, plutôt que comme une méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -
-

Note : Math.ceil(null) renverra 0 et pas {{jsxref("NaN")}}.

-
+> **Note :** `Math.ceil(null)` renverra `0` et pas {{jsxref("NaN")}}. -

Exemples

+## Exemples -

Utiliser Math.ceil()

+### Utiliser `Math.ceil()` -

Voici un exemple d'utilisation de Math.ceil().

+Voici un exemple d'utilisation de `Math.ceil()`. -
Math.ceil(.95);    // 1
+```js
+Math.ceil(.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
-Math.ceil(null);   // 0
+Math.ceil(null); // 0 +``` -

Arrondi décimal

+### Arrondi décimal -
// Fermeture
+```js
+// Fermeture
 (function(){
 
 	/**
@@ -74,7 +73,7 @@ Math.ceil(null);   // 0
exp = +exp; // Si value n'est pas un nombre // ou si l'exposant n'est pas entier - if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { + if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) { return NaN; } // Décalage @@ -125,50 +124,25 @@ Math.ceil10(55.51, -1); // 55.6 Math.ceil10(51, 1); // 60 Math.ceil10(-55.59, -1); // -55.5 Math.ceil10(-59, 1); // -50 - - -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.ceil")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.ceil")}} + +## Voir aussi + +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.floor()")}} +- {{jsxref("Math.round()")}} +- {{jsxref("Math.sign()")}} +- {{jsxref("Math.trunc()")}}{ diff --git a/files/fr/web/javascript/reference/global_objects/math/clz32/index.md b/files/fr/web/javascript/reference/global_objects/math/clz32/index.md index c3298823a6..416bc22e28 100644 --- a/files/fr/web/javascript/reference/global_objects/math/clz32/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/clz32/index.md @@ -11,82 +11,61 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/clz32 --- -
{{JSRef}}
+{{JSRef}} -

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

+La fonction **`Math.clz32()`** renvoie le nombre de zéros de tête dans la représentation binaire sur 32 bits d'un nombre. -
{{EmbedInteractiveExample("pages/js/math-clz32.html")}}
+{{EmbedInteractiveExample("pages/js/math-clz32.html")}} -

Syntaxe

+## Syntaxe -
Math.clz32(x)
-
+ Math.clz32(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur retournée

+### Valeur retournée -

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

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

Description

+## Description -

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

+"`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 `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.

+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.

+Cette fonction est particulièrement utile aux systèmes qui compilent du code JavaScript, comme [Emscripten](/fr/docs/Emscripten). -

Exemples

+## Exemples -
Math.clz32(1)                // 31
+```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
+liste.every(n => Math.clz32(n) == 32); // true
 
 Math.clz32(true)             // 31
 Math.clz32(3.5)              // 30
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaire
{{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.clz32")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | Statut | Commentaire | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.clz32")}} + +## Voir aussi + +- {{jsxref("Math")}} +- {{jsxref("Math.imul")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/cos/index.md b/files/fr/web/javascript/reference/global_objects/math/cos/index.md index 2015708e27..9b78bfd357 100644 --- a/files/fr/web/javascript/reference/global_objects/math/cos/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/cos/index.md @@ -9,87 +9,61 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cos --- -
{{JSRef}}
+{{JSRef}} -

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

+La fonction **`Math.cos()`** retourne le [cosinus](https://fr.wikipedia.org/wiki/Cosinus) d'un angle dont la valeur est exprimée en [radians](https://fr.wikipedia.org/wiki/Radian). -
{{EmbedInteractiveExample("pages/js/math-cos.html")}}
+{{EmbedInteractiveExample("pages/js/math-cos.html")}} -

Syntaxe

+## Syntaxe -
Math.cos(x)
+ Math.cos(x) -

Paramètres

+### Paramètres -
-
x
-
Une valeur numérique (exprimée en radians).
-
+- `x` + - : Une valeur numérique (exprimée en radians). -

Valeur de retour

+### Valeur de retour -

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

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

Description

+## 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.

+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).

+`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

+## Exemples -

Utiliser Math.cos()

+### Utiliser `Math.cos()` -
Math.cos(0);           // 1
+```js
+Math.cos(0);           // 1
 Math.cos(1);           // 0.5403023058681398
 
 Math.cos(Math.PI);     // -1
 Math.cos(2 * Math.PI); // 1
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.cos")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.cos', 'Math.cos')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.cos")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.sin()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/cosh/index.md b/files/fr/web/javascript/reference/global_objects/math/cosh/index.md index 76c7d9fe17..d0306213b6 100644 --- a/files/fr/web/javascript/reference/global_objects/math/cosh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/cosh/index.md @@ -11,93 +11,77 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/cosh --- -
{{JSRef}}
+{{JSRef}} -

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

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

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

+Math.cosh(x)=ex+e-x2\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2} -
{{EmbedInteractiveExample("pages/js/math-cosh.html")}}
+{{EmbedInteractiveExample("pages/js/math-cosh.html")}} +(Voir la page sur {{jsxref("Objets_globaux/Math/E","e","",1)}}) +## Syntaxe -

(Voir la page sur {{jsxref("Objets_globaux/Math/E","e","",1)}})

+ Math.cosh(x) -

Syntaxe

+### Paramètres -
Math.cosh(x)
+- `x` + - : Un nombre. -

Paramètres

+### Valeur de retour -
-
x
-
Un nombre.
-
+Le cosinus hyperbolique du nombre passé en argument. -

Valeur de retour

+## Description -

Le cosinus hyperbolique du nombre passé en argument.

+`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). -

Description

+## Exemple -

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).

+### Utiliser `Math.cosh()` -

Exemple

- -

Utiliser Math.cosh()

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

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Cette fonction peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :

+Cette fonction peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} : -
Math.cosh = Math.cosh || function(x) {
+```js
+Math.cosh = Math.cosh || function(x) {
     return (Math.exp(x) + Math.exp(-x)) / 2;
-}
+} +``` -

On peut également utiliser un unique appel à {{jsxref("Objets_globaux/Math/exp", "exp()")}} :

+On peut également utiliser un unique appel à {{jsxref("Objets_globaux/Math/exp", "exp()")}} : -
Math.cosh = Math.cosh || function(x) {
+```js
+Math.cosh = Math.cosh || function(x) {
     var y = Math.exp(x);
     return (y + 1 / y) / 2;
-}
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.cosh', 'Math.cosh')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.cosh")}}

- -

Voir aussi

- - +} +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.cosh', 'Math.cosh')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.cosh")}} + +## Voir aussi + +- {{jsxref("Math.acosh()")}} +- {{jsxref("Math.asinh()")}} +- {{jsxref("Math.atanh()")}} +- {{jsxref("Math.sinh()")}} +- {{jsxref("Math.tanh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/e/index.md b/files/fr/web/javascript/reference/global_objects/math/e/index.md index f4df99a2cb..540d7769eb 100644 --- a/files/fr/web/javascript/reference/global_objects/math/e/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/e/index.md @@ -9,74 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/E original_slug: Web/JavaScript/Reference/Objets_globaux/Math/E --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.E représente la base du logarithme naturel, e, et vaut environ 2.718.

+La propriété **`Math.E`** représente la base du logarithme naturel, e, et vaut environ 2.718. -

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

+Math.E=e≈2.718\mathtt{\mi{Math.E}} = e \approx 2.718 -
{{EmbedInteractiveExample("pages/js/math-e.html")}}
+{{EmbedInteractiveExample("pages/js/math-e.html")}}{{js_property_attributes(0,0,0)}} +## Description +`E` étant une propriété statique de `Math`, il doit toujours être utilisé avec la syntaxe `Math.E`, et non pas être appelé comme propriété d'un autre objet `Math` qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.E` -

E étant une propriété statique de Math, il doit toujours être utilisé avec la syntaxe Math.E, et non pas être appelé comme propriété d'un autre objet Math qui aurait été créé (Math n'est pas un constructeur).

+La fonction suivante renvoie la valeur de e : -

Exemples

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

Utiliser Math.E

+getNapier(); // 2.718281828459045 +``` -

La fonction suivante renvoie la valeur de e :

+## Spécifications -
function getNapier() {
-   return Math.E;
-}
+| Spécification                                                    | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                         | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.e', 'Math.E')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.e', 'Math.E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.E")}}
+
+## Voir aussi
 
-getNapier(); // 2.718281828459045
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.e', 'Math.E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.E")}}

- -

Voir aussi

- - +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log1p()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/exp/index.md b/files/fr/web/javascript/reference/global_objects/math/exp/index.md index 29ac4ef407..e6be9fc5c3 100644 --- a/files/fr/web/javascript/reference/global_objects/math/exp/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/exp/index.md @@ -9,85 +9,58 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp original_slug: Web/JavaScript/Reference/Objets_globaux/Math/exp --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.exp() renvoie l'exponentielle d'un nombre (donnée par e^x, où x est la valeur passée en argument et e la valeur du {{jsxref("Objets_globaux/Math/E","nombre d'Euler (parfois appelé constante de Napier)","",1)}}.

+La fonction **`Math.exp()`** renvoie l'exponentielle d'un nombre (donnée par `e^x`, où `x` est la valeur passée en argument et `e` la valeur du {{jsxref("Objets_globaux/Math/E","nombre d'Euler (parfois appelé constante de Napier)","",1)}}. -
{{EmbedInteractiveExample("pages/js/math-exp.html")}}
+{{EmbedInteractiveExample("pages/js/math-exp.html")}} -

Syntaxe

+## Syntaxe -
Math.exp(x)
+ Math.exp(x) -

Paramètres

+### Paramètres -
-
x
-
-

Un nombre.

-
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

L'exponentielle du nombre passé en argument (e^x).

+L'exponentielle du nombre passé en argument (`e^x`). -

Description

+## Description -

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

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

Exemples

+## Exemples -

Utiliser Math.exp()

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

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.exp")}}

- -

Voir aussi

- - +Math.exp(1); // 2.718281828459045 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.exp', 'Math.exp')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.exp")}} + +## Voir aussi + +- {{jsxref("Math.E")}} +- {{jsxref("Math.expm1()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} +- {{jsxref("Math.log1p()")}} +- {{jsxref("Math.log2()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/expm1/index.md b/files/fr/web/javascript/reference/global_objects/math/expm1/index.md index 372880a5df..2d8223041f 100644 --- a/files/fr/web/javascript/reference/global_objects/math/expm1/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/expm1/index.md @@ -11,81 +11,66 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/expm1 --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.expm1() renvoie e^x - 1, avec x l'argument donné et {{jsxref("Objets_globaux/Math/E","e")}} la base du logarithme nepérien.

+La fonction **`Math.expm1()`** renvoie` e^x` - 1, avec `x` l'argument donné et {{jsxref("Objets_globaux/Math/E","e")}} la base du logarithme nepérien. -
{{EmbedInteractiveExample("pages/js/math-expm1.html")}}
+{{EmbedInteractiveExample("pages/js/math-expm1.html")}} -

Syntaxe

+## Syntaxe -
Math.expm1(x)
+ Math.expm1(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Un nombre qui représente e^x- 1 où x est la valeur passée en argument et e^x l'exponentielle du nombre.

+Un nombre qui représente `e^x- 1` où `x` est la valeur passée en argument et `e^x` l'exponentielle du nombre. -

Description

+## Description -

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

+`expm1()` étant une méthode statique de `Math`, il faut utiliser `Math.expm1()`et non pas la méthode d'un autre objet qui aurait été créé sur mesure (`Math `n'est pas un constructeur). -

Exemple

+## Exemple -

Utiliser Math.expm1()

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

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Cette fonction peut être émulée en utilisant la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :

+Cette fonction peut être émulée en utilisant la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} : -
Math.expm1 = Math.expm1 || function(x) {
+```js
+Math.expm1 = Math.expm1 || function(x) {
     return Math.exp(x) - 1;
-};
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.expm1")}}

- -

Voir aussi

- - +}; +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.expm1")}} + +## Voir aussi + +- {{jsxref("Math.E")}} +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} +- {{jsxref("Math.log1p()")}} +- {{jsxref("Math.log2()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/floor/index.md b/files/fr/web/javascript/reference/global_objects/math/floor/index.md index 4b9a6e5422..65bc3d23fc 100644 --- a/files/fr/web/javascript/reference/global_objects/math/floor/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/floor/index.md @@ -9,89 +9,61 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor original_slug: Web/JavaScript/Reference/Objets_globaux/Math/floor --- -
{{JSRef}}
+{{JSRef}} -

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

+La fonction **`Math.floor(x)`** renvoie le plus grand entier qui est inférieur ou égal à un nombre `x`. -
{{EmbedInteractiveExample("pages/js/math-floor.html")}}
+{{EmbedInteractiveExample("pages/js/math-floor.html")}} -

Syntaxe

+## Syntaxe -
Math.floor(x)
+ Math.floor(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

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

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

Description

+## 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).

+`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 {{jsxref("NaN")}}.

-
+> **Note :** `Math.floor(null)` renvoie `0` et pas {{jsxref("NaN")}}. -

Exemples

+## Exemples -

Utiliser Math.floor

+### Utiliser `Math.floor` -
Math.floor( 45.95); //  45
+```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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.floor")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.floor', 'Math.floor')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.floor")}} + +## Voir aussi + +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.ceil()")}} +- {{jsxref("Math.round()")}} +- {{jsxref("Math.sign()")}} +- {{jsxref("Math.trunc()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/fround/index.md b/files/fr/web/javascript/reference/global_objects/math/fround/index.md index 6b5ec47735..77cf804d99 100644 --- a/files/fr/web/javascript/reference/global_objects/math/fround/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/fround/index.md @@ -10,40 +10,39 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround original_slug: Web/JavaScript/Reference/Objets_globaux/Math/fround --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.fround() renvoie le nombre flottant à précision simple sur 32 bits qui est le plus proche du nombre fourni.

+La fonction **`Math.fround()`** renvoie le nombre flottant à [précision simple](https://en.wikipedia.org/wiki/Single_precision "link to the wikipedia page on single precision") sur 32 bits qui est le plus proche du nombre fourni. -
{{EmbedInteractiveExample("pages/js/math-fround.html")}}
+{{EmbedInteractiveExample("pages/js/math-fround.html")}} -

Syntaxe

+## Syntaxe -
Math.fround(x)
+ Math.fround(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument.

+Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument. -

Description

+## Description -

Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bits. Cela permet d'obtenir une précision fine. Toutefois, lorsqu'on manipule des valeurs représentées sur 32 bits (par exemple des valeurs extraites d'un {{jsxref("Float32Array")}}) et qu'on souhaite comparer celles-ci avec des valeurs sur 32 bits, on peut obtenir des inégalités alors que les valeurs semblent identiques.

+Un moteur JavaScript utilise des nombres flottant à précision simple sur 64 bits. Cela permet d'obtenir une précision fine. Toutefois, lorsqu'on manipule des valeurs représentées sur 32 bits (par exemple des valeurs extraites d'un {{jsxref("Float32Array")}}) et qu'on souhaite comparer celles-ci avec des valeurs sur 32 bits, on peut obtenir des inégalités alors que les valeurs semblent identiques. -

Pour résoudre ce problème, on peut utiliser Math.fround() afin de transformer un nombre représenté sur 64 bits en un nombre représenté sur 32 bits. Pour le moteur JavaScript, la valeur sera toujours représentée sur 64 bits mais elle aura été « arrondie » à partir du 23e bit de la mantisse. Si le nombre passé en argument se situe en dehors de l'intervalle représentable sur 32 bits, la méthode renverra {{jsxref("Infinity")}} ou -Infinity.

+Pour résoudre ce problème, on peut utiliser `Math.fround()` afin de transformer un nombre représenté sur 64 bits en un nombre représenté sur 32 bits. Pour le moteur JavaScript, la valeur sera toujours représentée sur 64 bits mais elle aura été « arrondie » à partir du 23e bit de la mantisse. Si le nombre passé en argument se situe en dehors de l'intervalle représentable sur 32 bits, la méthode renverra {{jsxref("Infinity")}} ou `-Infinity`. -

fround étant une méthode statique de Math, il faut utiliser Math.fround() et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+`fround `étant une méthode statique de `Math`, il faut utiliser `Math.fround()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -

Exemples

+## Exemples -

Utiliser Math.fround()

+### Utiliser `Math.fround()` -
Math.fround(0);     // 0
+```js
+Math.fround(0);     // 0
 Math.fround(1);     // 1
 
 // 1.337 ne peut pas être représenté correctement
@@ -51,36 +50,20 @@ Math.fround(1);     // 1
 Math.fround(1.337); // 1.3370000123977661
 
 Math.fround(1.5);   // 1.5
-Math.fround(NaN);   // NaN
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.fround")}}

- -

Voir aussi

- - +Math.fround(NaN); // NaN +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.fround', 'Math.fround')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.fround")}} + +## Voir aussi + +- {{jsxref("Math.round()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/hypot/index.md b/files/fr/web/javascript/reference/global_objects/math/hypot/index.md index bba9aaebe8..977f6c4965 100644 --- a/files/fr/web/javascript/reference/global_objects/math/hypot/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/hypot/index.md @@ -11,59 +11,59 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot original_slug: Web/JavaScript/Reference/Objets_globaux/Math/hypot --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.hypot() renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante :

+La fonction **`Math.hypot()`** renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante : -

Math.hypot(v1,v2,…,vn)=∑i=1nvi2=v12+v22+…+vn2\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}

+Math.hypot(v1,v2,…,vn)=∑i=1nvi2=v12+v22+…+vn2\mathtt{\operatorname{Math.hypot}(v*1, v_2, \dots, v_n)} = \sqrt{\sum*{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2} -
{{EmbedInteractiveExample("pages/js/math-hypot.html")}}
+{{EmbedInteractiveExample("pages/js/math-hypot.html")}} -

Syntaxe

+## Syntaxe -
Math.hypot([valeur1[,valeur2, ...]])
+ Math.hypot([valeur1[,valeur2, ...]]) -

Paramètres

+### Paramètres -
-
valeur1, valeur2, ...
-
Des nombres.
-
+- `valeur1, valeur2, ...` + - : Des nombres. -

Valeur de retour

+### Valeur de retour -

La racine carrée de la somme des carrés des arguments. S'il existe un des arguments qui ne peut pas être converti en un nombre, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée.

+La racine carrée de la somme des carrés des arguments. S'il existe un des arguments qui ne peut pas être converti en un nombre, c'est la valeur {{jsxref("NaN")}} qui sera renvoyée. -

Description

+## Description -

hypot() étant une méthode statique de Math, il faut utiliser Math.hypot()et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+`hypot()` étant une méthode statique de `Math`, il faut utiliser `Math.hypot()`et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -

Si aucun argument n'est donné, le résultat sera +0.Si, parmi les arguments, au moins un ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.Si cette fonction est utilisée avec un argument : Math.hypot(x) sera équivalente à Math.abs(x).

+Si aucun argument n'est donné, le résultat sera +0.Si, parmi les arguments, au moins un ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.Si cette fonction est utilisée avec un argument : `Math.hypot(x)` sera équivalente à `Math.abs(x)`. -

Cette fonction permet entre autres de gérer certains cas où, pour les grands nombres, l'utilisation de {{jsxref("Math.sqrt()")}} aurait renvoyé {{jsxref("Infinity")}} à cause des calculs intermédiaires.

+Cette fonction permet entre autres de gérer certains cas où, pour les grands nombres, l'utilisation de {{jsxref("Math.sqrt()")}} aurait renvoyé {{jsxref("Infinity")}} à cause des calculs intermédiaires. -

Exemples

+## Exemples -

Utiliser Math.hypot()

+### Utiliser `Math.hypot()` -
Math.hypot(3, 4)        // 5
+```js
+Math.hypot(3, 4)        // 5
 Math.hypot(3, 4, 5)     // 7.0710678118654755
 Math.hypot()            // 0
 Math.hypot(NaN)         // NaN
-Math.hypot(3, 4, "toto") // NaN, +"toto" => NaN
-Math.hypot(3, 4, "5")   // 7.0710678118654755, +"5" => 5
+Math.hypot(3, 4, "toto") // NaN, +"toto" => NaN
+Math.hypot(3, 4, "5")   // 7.0710678118654755, +"5" => 5
 Math.hypot(-3)          // 3, the same as Math.abs(-3)
-
+``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :

+Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante : -
Math.hypot =  Math.hypot || function() {
+```js
+Math.hypot =  Math.hypot || function() {
     var y = 0;
     var length = arguments.length;
 
-    for (var i = 0; i < length; i++) {
+    for (var i = 0; i < length; i++) {
       if(arguments[i] === Infinity || arguments[i] === -Infinity) {
         return Infinity;
       }
@@ -71,56 +71,40 @@ Math.hypot(-3)          // 3, the same as Math.abs(-3)
     }
     return Math.sqrt(y);
 };
-
+``` -

Voici une seconde version qui évite les dépassements :

+Voici une seconde version qui évite les dépassements : -
Math.hypot = function (x, y) {
+```js
+Math.hypot = function (x, y) {
   // https://bugzilla.mozilla.org/show_bug.cgi?id=896264#c28
   var max = 0;
   var s = 0;
-  for (var i = 0; i < arguments.length; i += 1) {
+  for (var i = 0; i < arguments.length; i += 1) {
     var arg = Math.abs(Number(arguments[i]));
-    if (arg > max) {
+    if (arg > max) {
       s *= (max / arg) * (max / arg);
       max = arg;
     }
-    s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
+    s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max);
   }
   return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s);
 };
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}}{{Spec2('ES2015')}}Définition initiale
{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.hypot")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ------------------- | +| {{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}} | {{Spec2('ES2015')}} | Définition initiale | +| {{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.hypot")}} + +## Voir aussi + +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.pow()")}} +- {{jsxref("Math.sqrt()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/imul/index.md b/files/fr/web/javascript/reference/global_objects/math/imul/index.md index bdfb591384..507c94f070 100644 --- a/files/fr/web/javascript/reference/global_objects/math/imul/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/imul/index.md @@ -10,81 +10,66 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul original_slug: Web/JavaScript/Reference/Objets_globaux/Math/imul --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.imul() renvoie le résultat de la multiplication de deux nombres, calculée avec la représentation sur 32 bits de ces nombres, à la façon du langage C.

+La fonction **`Math.imul()`** renvoie le résultat de la multiplication de deux nombres, calculée avec la représentation sur 32 bits de ces nombres, à la façon du langage C. -
{{EmbedInteractiveExample("pages/js/math-imul.html")}}
+{{EmbedInteractiveExample("pages/js/math-imul.html")}} -

Syntaxe

+## Syntaxe -
Math.imul(a, b)
+ Math.imul(a, b) -

Paramètres

+### Paramètres -
-
a
-
Le premier nombre.
-
b
-
Le second nombre.
-
+- `a` + - : Le premier nombre. +- `b` + - : Le second nombre. -

Valeur de retour

+### Valeur de retour -

Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C).

+Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C). -

Description

+## Description -

Math.imul() permet d'effectuer une multiplication rapide pour des entiers sur 32 bits avec une sémantique proche du langage C. Cela est utile pour des aspects de performance, notamment pour des projets comme Emscripten. imul() étant une méthode statique de Math, il faut utiliser Math.imul() et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec Math.imul() car cela implique une opération de conversion des flottants vers les entiers pour la multiplication puis une opération de conversion du résultat en flottant. Dans la pratique, Math.imul() est notamment pertinent pour asm.js.

+`Math.imul()` permet d'effectuer une multiplication rapide pour des entiers sur 32 bits avec une sémantique proche du langage C. Cela est utile pour des aspects de performance, notamment pour des projets comme [Emscripten](/fr/docs/Mozilla/Projects/Emscripten). `imul() `étant une méthode statique de `Math`, il faut utiliser `Math.imul()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec `Math.imul()` car cela implique une opération de conversion des flottants vers les entiers pour la multiplication puis une opération de conversion du résultat en flottant. Dans la pratique, ` Math``.imul() ` est notamment pertinent pour asm.js. -

Exemples

+## Exemples -

Utiliser Math.imul()

+### Utiliser `Math.imul()` -
Math.imul(2, 4);          // 8
+```js
+Math.imul(2, 4);          // 8
 Math.imul(-1, 8);         //-8
 Math.imul(-2, -2);        // 4
 Math.imul(0xffffffff, 5); //-5
 Math.imul(0xfffffffe, 5); //-10
-
+``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :

+Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante : -
Math.imul = Math.imul || function(a, b) {
-  var ah  = (a >>> 16) & 0xffff;
-  var al = a & 0xffff;
-  var bh  = (b >>> 16) & 0xffff;
-  var bl = b & 0xffff;
+```js
+Math.imul = Math.imul || function(a, b) {
+  var ah  = (a >>> 16) & 0xffff;
+  var al = a & 0xffff;
+  var bh  = (b >>> 16) & 0xffff;
+  var bl = b & 0xffff;
   // Le décalage par 0 rétablit le signe de la partie haute
   // le |0 final convertit la valeur non-signée en une valeur signée
-  return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0);
+  return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0);
 };
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}{{Spec2('ES6')}}Définition initiale
{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.imul")}}

+``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{SpecName('ES6', '#sec-math.imul', 'Math.imul')}} | {{Spec2('ES6')}} | Définition initiale | +| {{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.imul")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/index.md b/files/fr/web/javascript/reference/global_objects/math/index.md index 86ab1bee47..f0fd2ba0b4 100644 --- a/files/fr/web/javascript/reference/global_objects/math/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/index.md @@ -8,163 +8,138 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math original_slug: Web/JavaScript/Reference/Objets_globaux/Math --- -
{{JSRef}}
- -

L'objet Math est un objet natif dont les méthodes et propriétés permettent l'utilisation de constantes et fonctions mathématiques. Cet objet n'est pas une fonction.

- -
-

Attention : Math fonctionne avec le type {{jsxref("Number")}}. Il ne fonctionne pas avec les grands entiers/{{jsxref("BigInt")}}.

-
- -

Description

- -

Contrairement aux autres objets globaux, Math n'est pas un constructeur. Toutes les propriétés et les méthodes de Math sont statiques (pour éventuellement étendre cette API, ce qui est fortement déconseillé, on n'utilisera donc pas Math.prototype).

- -

Pour accéder à la constante PI, on utilise Math.PI.
- Pour accéder à la fonction sinus, on utilise Math.sin(x) où x est l'argument de cette méthode.

- -

Les constantes sont définies avec la précision des nombres réels en JavaScript.

- -

Propriétés

- -
-
{{jsxref("Math.E")}}
-
Nombre d'Euler, la base des logarithmes naturels, environ 2,718.
-
{{jsxref("Math.LN2")}}
-
Logarithme naturel de 2, environ 0,693.
-
{{jsxref("Math.LN10")}}
-
Logarithme naturel de 10, environ 2,302.
-
{{jsxref("Math.LOG2E")}}
-
Logarithme de base 2 de E, environ 1,442.
-
{{jsxref("Math.LOG10E")}}
-
Logarithme de base 10 de E, environ 0,434.
-
{{jsxref("Math.PI")}}
-
Quotient de la circonférence d'un cercle par son diamètre, environ 3,14159.
-
{{jsxref("Math.SQRT1_2")}}
-
Racine carrée de 1/2 ; équivalent de 1 sur la racine carrée de 2, environ 0,707.
-
{{jsxref("Math.SQRT2")}}
-
Racine carrée de 2, environ 1,414.
-
- -

Méthodes

- -

Note : Les fonctions trigonométriques (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) acceptent ou retournent des angles en radians. Pour convertir des degrés en radians, multipliez la valeur en degrés par (Math.PI / 180). Pour passer des radians en degrés, divisez la valeur en radians par (Math.PI / 180).

- -

Note : La précision des fonctions mathématiques dépend notamment de l'implémentation. Cela signifie que différents navigateurs peuvent fournir des résultats différents. On peut même avoir un même moteur JavaScript qui, sur des architectures et/ou des systèmes d'exploitation différents, fournit des résultats différents.

- -
-
{{jsxref("Objets_globaux/Math/abs", "Math.abs(x)")}}
-
Retourne la valeur absolue d'un nombre.
-
{{jsxref("Objets_globaux/Math/acos", "Math.acos(x)")}}
-
Retourne l'arc cosinus d'un nombre.
-
{{jsxref("Objets_globaux/Math/acosh", "Math.acosh(x)")}}
-
Retourne l'arc cosinus hyperbolique d'un nombre.
-
{{jsxref("Objets_globaux/Math/asin", "Math.asin(x)")}}
-
Retourne l'arc sinus d'un nombre.
-
{{jsxref("Objets_globaux/Math/asinh", "Math.asinh(x)")}}
-
Retourne l'arc sinus hyperbolique d'un nombre.
-
{{jsxref("Objets_globaux/Math/atan", "Math.atan(x)")}}
-
Retourne l'arc tangente d'un nombre.
-
{{jsxref("Objets_globaux/Math/atanh", "Math.atanh(x)")}}
-
Retourne l'arc tangente hyperbolique d'un nombre
-
{{jsxref("Objets_globaux/Math/atan2", "Math.atan2(y, x)")}}
-
Retourne l'arc tangente du quotient de ses arguments.
-
{{jsxref("Objets_globaux/Math/cbrt", "Math.cbrt(x)")}}
-
Renvoie la racine cubique d'un nombre.
-
{{jsxref("Objets_globaux/Math/ceil", "Math.ceil(x)")}}
-
Retourne le plus petit entier supérieur ou égal à la valeur passée en paramètre.
-
{{jsxref("Objets_globaux/Math/clz32", "Math.clz32(x)")}}
-
Renvoie le nombre de zéros qui préfixent un entier sur 32 bits.
-
{{jsxref("Objets_globaux/Math/cos", "Math.cos(x)")}}
-
Retourne le cosinus d'un nombre.
-
{{jsxref("Objets_globaux/Math/cosh", "Math.cosh(x)")}}
-
Renvoie le cosinus hyperbolique d'un nombre.
-
{{jsxref("Objets_globaux/Math/exp", "Math.exp(x)")}}
-
Renvoie l'exponentielle d'un nombre (soit E^nombre) avec E la constante d'Euler (2,718...).
-
{{jsxref("Objets_globaux/Math/expm1", "Math.expm1(x)")}}
-
Renvoie le résultat de 1 moins l'exponentielle d'un nombre.
-
{{jsxref("Objets_globaux/Math/floor", "Math.floor(x)")}}
-
Retourne le plus grand entier inférieur ou égal à la valeur passée en paramètre.
-
{{jsxref("Objets_globaux/Math/fround", "Math.fround(x)")}}
-
Renvoie le nombre flottant exprimé sur 32 bits le plus proche de l'argument.
-
{{jsxref("Objets_globaux/Math/hypot", "Math.hypot([x[,y[,…]]])")}}
-
Retourne la racine carré de la somme des carrés des arguments.
-
{{jsxref("Objets_globaux/Math/imul", "Math.imul(x, y)")}}
-
Retourne le résultat de la multiplication d'entiers sur 32 bits.
-
{{jsxref("Objets_globaux/Math/log", "Math.log(x)")}}
-
Retourne le logarithme naturel (loge) d'un nombre.
-
{{jsxref("Objets_globaux/Math/log1p", "Math.log1p(x)")}}
-
Retourne le logarithme naturel de 1 + un nombre.
-
{{jsxref("Objets_globaux/Math/log10", "Math.log10(x)")}}
-
Retourne le logarithme en base 10 d'un nombre.
-
{{jsxref("Objets_globaux/Math/log2", "Math.log2(x)")}}
-
Retourne le logarithme en base 2 d'un nombre.
-
{{jsxref("Objets_globaux/Math/max", "Math.max([x[,y[,…]]])")}}
-
Retourne la plus grande valeur d'une liste de nombres.
-
{{jsxref("Objets_globaux/Math/min", "Math.min([x[,y[,…]]])")}}
-
Retourne la plus petite valeur d'une liste de nombres.
-
{{jsxref("Objets_globaux/Math/pow", "Math.pow(x,y)")}}
-
Retourne le calcul de x à la puissance y (x correspond à la base et y à l'exposant).
-
{{jsxref("Objets_globaux/Math/random", "Math.random()")}}
-
Retourne un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu).
-
{{jsxref("Objets_globaux/Math/round", "Math.round(x)")}}
-
Retourne l'arrondi d'un nombre.
-
{{jsxref("Objets_globaux/Math/sign", "Math.sign(x)")}}
-
Retourne le signe d'un nombre, indiquant s'il est positif, négatif ou égal à zéro.
-
{{jsxref("Objets_globaux/Math/sin", "Math.sin(x)")}}
-
Retourne le sinus d'un nombre.
-
{{jsxref("Objets_globaux/Math/sinh", "Math.sinh(x)")}}
-
Retourne le sinus hyperbolique d'un nombre.
-
{{jsxref("Objets_globaux/Math/sqrt", "Math.sqrt(x)")}}
-
Retourne la racine carrée d'un nombre.
-
{{jsxref("Objets_globaux/Math/tan", "Math.tan(x)")}}
-
Retourne la tangente d'un nombre.
-
{{jsxref("Objets_globaux/Math/tanh", "Math.tanh(x)")}}
-
Retourne la tangente hyperbolique d'un nombre
-
Math.toSource() {{Non-standard_inline}}
-
Renvoie la chaîne de caractères "Math".
-
{{jsxref("Objets_globaux/Math/trunc", "Math.trunc(x)")}}
-
Retourne la partie entière d'un nombre (la partie décimale est retirée).
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.1
{{SpecName('ES5.1', '#sec-15.8', 'Math')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math-object', 'Math')}}{{Spec2('ES6')}}Nouvelles méthodes ajoutées : {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} et {{jsxref("Math.clz32()", "clz32()")}}.
{{SpecName('ESDraft', '#sec-math-object', 'Math')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math")}}

- -

Voir aussi

- - +{{JSRef}} + +L'objet **`Math`** est un objet natif dont les méthodes et propriétés permettent l'utilisation de constantes et fonctions mathématiques. Cet objet n'est pas une fonction. + +> **Attention :** `Math` fonctionne avec le type {{jsxref("Number")}}. Il ne fonctionne pas avec les grands entiers/{{jsxref("BigInt")}}. + +## Description + +Contrairement aux autres objets globaux, `Math` n'est pas un constructeur. Toutes les propriétés et les méthodes de `Math` sont statiques (pour éventuellement étendre cette API, ce qui est fortement déconseillé, on n'utilisera donc pas `Math.prototype`). + +Pour accéder à la constante PI, on utilise `Math.PI`. +Pour accéder à la fonction _sinus_, on utilise `Math.sin(x)` où `x` est l'argument de cette méthode. + +Les constantes sont définies avec la précision des nombres réels en JavaScript. + +## Propriétés + +- {{jsxref("Math.E")}} + - : Nombre d'Euler, la base des logarithmes naturels, environ 2,718. +- {{jsxref("Math.LN2")}} + - : Logarithme naturel de 2, environ 0,693. +- {{jsxref("Math.LN10")}} + - : Logarithme naturel de 10, environ 2,302. +- {{jsxref("Math.LOG2E")}} + - : Logarithme de base 2 de E, environ 1,442. +- {{jsxref("Math.LOG10E")}} + - : Logarithme de base 10 de E, environ 0,434. +- {{jsxref("Math.PI")}} + - : Quotient de la circonférence d'un cercle par son diamètre, environ 3,14159. +- {{jsxref("Math.SQRT1_2")}} + - : Racine carrée de 1/2 ; équivalent de 1 sur la racine carrée de 2, environ 0,707. +- {{jsxref("Math.SQRT2")}} + - : Racine carrée de 2, environ 1,414. + +## Méthodes + +> **Note :** Les fonctions trigonométriques (`sin()`, `cos()`, `tan()`, `asin()`, `acos()`, `atan()`, `atan2()`) acceptent ou retournent des angles en radians. Pour convertir des degrés en radians, multipliez la valeur en degrés par (`Math.PI / 180`). Pour passer des radians en degrés, divisez la valeur en radians par (`Math.PI / 180`). + +> **Note :** La précision des fonctions mathématiques dépend notamment de l'implémentation. Cela signifie que différents navigateurs peuvent fournir des résultats différents. On peut même avoir un même moteur JavaScript qui, sur des architectures et/ou des systèmes d'exploitation différents, fournit des résultats différents. + +- {{jsxref("Objets_globaux/Math/abs", "Math.abs(x)")}} + - : Retourne la valeur absolue d'un nombre. +- {{jsxref("Objets_globaux/Math/acos", "Math.acos(x)")}} + - : Retourne l'arc cosinus d'un nombre. +- {{jsxref("Objets_globaux/Math/acosh", "Math.acosh(x)")}} + - : Retourne l'arc cosinus hyperbolique d'un nombre. +- {{jsxref("Objets_globaux/Math/asin", "Math.asin(x)")}} + - : Retourne l'arc sinus d'un nombre. +- {{jsxref("Objets_globaux/Math/asinh", "Math.asinh(x)")}} + - : Retourne l'arc sinus hyperbolique d'un nombre. +- {{jsxref("Objets_globaux/Math/atan", "Math.atan(x)")}} + - : Retourne l'arc tangente d'un nombre. +- {{jsxref("Objets_globaux/Math/atanh", "Math.atanh(x)")}} + - : Retourne l'arc tangente hyperbolique d'un nombre +- {{jsxref("Objets_globaux/Math/atan2", "Math.atan2(y, x)")}} + - : Retourne l'arc tangente du quotient de ses arguments. +- {{jsxref("Objets_globaux/Math/cbrt", "Math.cbrt(x)")}} + - : Renvoie la racine cubique d'un nombre. +- {{jsxref("Objets_globaux/Math/ceil", "Math.ceil(x)")}} + - : Retourne le plus petit entier supérieur ou égal à la valeur passée en paramètre. +- {{jsxref("Objets_globaux/Math/clz32", "Math.clz32(x)")}} + - : Renvoie le nombre de zéros qui préfixent un entier sur 32 bits. +- {{jsxref("Objets_globaux/Math/cos", "Math.cos(x)")}} + - : Retourne le cosinus d'un nombre. +- {{jsxref("Objets_globaux/Math/cosh", "Math.cosh(x)")}} + - : Renvoie le cosinus hyperbolique d'un nombre. +- {{jsxref("Objets_globaux/Math/exp", "Math.exp(x)")}} + - : Renvoie l'exponentielle d'un nombre (soit E^nombre) avec E la constante d'Euler (2,718...). +- {{jsxref("Objets_globaux/Math/expm1", "Math.expm1(x)")}} + - : Renvoie le résultat de 1 moins l'exponentielle d'un nombre. +- {{jsxref("Objets_globaux/Math/floor", "Math.floor(x)")}} + - : Retourne le plus grand entier inférieur ou égal à la valeur passée en paramètre. +- {{jsxref("Objets_globaux/Math/fround", "Math.fround(x)")}} + - : Renvoie le nombre flottant exprimé sur 32 bits le plus proche de l'argument. +- {{jsxref("Objets_globaux/Math/hypot", "Math.hypot([x[,y[,…]]])")}} + - : Retourne la racine carré de la somme des carrés des arguments. +- {{jsxref("Objets_globaux/Math/imul", "Math.imul(x, y)")}} + - : Retourne le résultat de la multiplication d'entiers sur 32 bits. +- {{jsxref("Objets_globaux/Math/log", "Math.log(x)")}} + + - : Retourne le logarithme naturel (log + + e + + ) d'un nombre. + +- {{jsxref("Objets_globaux/Math/log1p", "Math.log1p(x)")}} + - : Retourne le logarithme naturel de 1 + un nombre. +- {{jsxref("Objets_globaux/Math/log10", "Math.log10(x)")}} + - : Retourne le logarithme en base 10 d'un nombre. +- {{jsxref("Objets_globaux/Math/log2", "Math.log2(x)")}} + - : Retourne le logarithme en base 2 d'un nombre. +- {{jsxref("Objets_globaux/Math/max", "Math.max([x[,y[,…]]])")}} + - : Retourne la plus grande valeur d'une liste de nombres. +- {{jsxref("Objets_globaux/Math/min", "Math.min([x[,y[,…]]])")}} + - : Retourne la plus petite valeur d'une liste de nombres. +- {{jsxref("Objets_globaux/Math/pow", "Math.pow(x,y)")}} + - : Retourne le calcul de x à la puissance y (x correspond à la base et y à l'exposant). +- {{jsxref("Objets_globaux/Math/random", "Math.random()")}} + - : Retourne un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu). +- {{jsxref("Objets_globaux/Math/round", "Math.round(x)")}} + - : Retourne l'arrondi d'un nombre. +- {{jsxref("Objets_globaux/Math/sign", "Math.sign(x)")}} + - : Retourne le signe d'un nombre, indiquant s'il est positif, négatif ou égal à zéro. +- {{jsxref("Objets_globaux/Math/sin", "Math.sin(x)")}} + - : Retourne le sinus d'un nombre. +- {{jsxref("Objets_globaux/Math/sinh", "Math.sinh(x)")}} + - : Retourne le sinus hyperbolique d'un nombre. +- {{jsxref("Objets_globaux/Math/sqrt", "Math.sqrt(x)")}} + - : Retourne la racine carrée d'un nombre. +- {{jsxref("Objets_globaux/Math/tan", "Math.tan(x)")}} + - : Retourne la tangente d'un nombre. +- {{jsxref("Objets_globaux/Math/tanh", "Math.tanh(x)")}} + - : Retourne la tangente hyperbolique d'un nombre +- `Math.toSource()` {{Non-standard_inline}} + - : Renvoie la chaîne de caractères `"Math"`. +- {{jsxref("Objets_globaux/Math/trunc", "Math.trunc(x)")}} + - : Retourne la partie entière d'un nombre (la partie décimale est retirée). + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.1 | +| {{SpecName('ES5.1', '#sec-15.8', 'Math')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math-object', 'Math')}} | {{Spec2('ES6')}} | Nouvelles méthodes ajoutées : {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} et {{jsxref("Math.clz32()", "clz32()")}}. | +| {{SpecName('ESDraft', '#sec-math-object', 'Math')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math")}} + +## Voir aussi + +- {{jsxref("Number")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/ln10/index.md b/files/fr/web/javascript/reference/global_objects/math/ln10/index.md index f3818a3665..2dc07d7187 100644 --- a/files/fr/web/javascript/reference/global_objects/math/ln10/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/ln10/index.md @@ -9,74 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LN10 --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.LN10 représente la valeur du logarithme naturel de 10, environ 2.302 :

+La propriété **`Math.LN10`** représente la valeur du logarithme naturel de 10, environ 2.302 : -

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

+Math.LN10=ln(10)≈2.302\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302 -
{{EmbedInteractiveExample("pages/js/math-ln10.html")}}
+{{EmbedInteractiveExample("pages/js/math-ln10.html")}}{{js_property_attributes(0,0,0)}} +## Description +`LN10` est une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LN10`, et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.LN10` -

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

+La fonction suivante renvoie le logarithme naturel de 10 : -

Exemples

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

Utiliser Math.LN10

+getNatLog10(); // 2.302585092994046 +``` -

La fonction suivante renvoie le logarithme naturel de 10 :

+## Spécifications -
function getNatLog10() {
-   return Math.LN10;
-}
+| Spécification                                                            | Statut                       | Commentaires                                          |
+| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                 | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LN10")}}
+
+## Voir aussi
 
-getNatLog10(); // 2.302585092994046
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.LN10")}}

- -

Voir aussi

- - +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/ln2/index.md b/files/fr/web/javascript/reference/global_objects/math/ln2/index.md index 0a7fc56029..25019b09ca 100644 --- a/files/fr/web/javascript/reference/global_objects/math/ln2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/ln2/index.md @@ -9,74 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LN2 --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.LN2 représente le logarithme naturel de 2, environ 0.693:

+La propriété **`Math.LN2`** représente le logarithme naturel de 2, environ 0.693: -

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

+Math.LN2=ln(2)≈0.693\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693 -
{{EmbedInteractiveExample("pages/js/math-ln2.html")}}
+{{EmbedInteractiveExample("pages/js/math-ln2.html")}}{{js_property_attributes(0,0,0)}} +## Description +`LN2` est une propriété statique de l'objet `Math`, il doit toujours être utilisé avec la syntaxe `Math.LN2`, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.LN2` -

LN2 est une propriété statique de l'objet Math, il doit toujours être utilisé avec la syntaxe Math.LN2, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (Math n'est pas un constructeur).

+La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de `Math.LN2` : -

Exemples

+```js +function getLog2(x) { + return Math.log(x) / Math.LN2; +} -

Utiliser Math.LN2

+getLog2(256); // 8 +``` -

La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de Math.LN2 :

+## Spécifications -
function getLog2(x) {
-  return Math.log(x) / Math.LN2;
-}
+| Spécification                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}} | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LN2")}}
+
+## Voir aussi
 
-getLog2(256); // 8
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.LN2")}}

- -

Voir aussi

- - +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log2()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log/index.md b/files/fr/web/javascript/reference/global_objects/math/log/index.md index 25d7a48e8b..14c55bd91d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log/index.md @@ -9,96 +9,73 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/log original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.log() renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par :

+La fonction **`Math.log()`** renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par : -

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

+∀x>0,Math.log(x)=ln(x)=le seul ytel queey=x\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x -
{{EmbedInteractiveExample("pages/js/math-log.html")}}
+{{EmbedInteractiveExample("pages/js/math-log.html")}} -

Syntaxe

+## Syntaxe -
Math.log(x)
+ Math.log(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui est renvoyé.

+Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui est renvoyé. -

Description

+## Description -

Si la valeur de l'argument est négative, la valeur renvoyée sera {{jsxref("NaN")}}. Si la valeur de l'argument est 0, la valeur de retour sera {{jsxref("Number.NEGATIVE_INFINITY", "-Infinity")}}.

+Si la valeur de l'argument est négative, la valeur renvoyée sera {{jsxref("NaN")}}. Si la valeur de l'argument est `0`, la valeur de retour sera {{jsxref("Number.NEGATIVE_INFINITY", "-Infinity")}}. -

log() est une méthode statique de Math, elle doit toujours être utilisée avec la syntaxe Math.log(), elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (Math n'est pas un constructeur). Si on veut utiliser les constantes données par les logarithmes naturels de 2 ou 10, on pourra utiliser les constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}}. De même pour les logarithmes en base 2 ou en base 10, on pourra utiliser {{jsxref("Math.log2()")}} or {{jsxref("Math.log10()")}}.

+`log()` est une méthode statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.log()`, elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Si on veut utiliser les constantes données par les logarithmes naturels de 2 ou 10, on pourra utiliser les constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}}. De même pour les logarithmes en base 2 ou en base 10, on pourra utiliser {{jsxref("Math.log2()")}} or {{jsxref("Math.log10()")}}. -

Exemples

+## Exemples -

Utiliser Math.log()

+### Utiliser `Math.log()` -
Math.log(-1); // NaN, valeur en dehors de l'intervalle de définition
+```js
+Math.log(-1); // NaN, valeur en dehors de l'intervalle de définition
 Math.log(0);  // -Infinity
 Math.log(1);  // 0
-Math.log(10); // 2.302585092994046
+Math.log(10); // 2.302585092994046 +``` -

Utiliser Math.log pour construire un logarithme sur une autre base

+### Utiliser `Math.log` pour construire un logarithme sur une autre base -

La fonction suivante renvoie le logarithme de y en base x (c'est-à-dire logx y):

+La fonction suivante renvoie le logarithme de `y` en base `x` (c'est-à-dire logx y): -
function getBaseLog(x, y) {
+```js
+function getBaseLog(x, y) {
     return Math.log(y) / Math.log(x);
-}
- -

Si on exécute getBaseLog(10, 1000), on obtiendra 2.9999999999999996 en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3).

- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.log', 'Math.log')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.log")}}

- -

Voir aussi

- - +} +``` + +Si on exécute `getBaseLog(10, 1000)`, on obtiendra `2.9999999999999996` en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3). + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.log', 'Math.log')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.log', 'Math.log')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.log")}} + +## Voir aussi + +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log1p()")}} +- {{jsxref("Math.log10()")}} +- {{jsxref("Math.log2()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log10/index.md b/files/fr/web/javascript/reference/global_objects/math/log10/index.md index d0e65dca47..763738f700 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log10/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log10/index.md @@ -11,87 +11,70 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log10 --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.log10() renvoie le logarithme en base 10 d'un nombre, donné par la formule :

+La fonction **`Math.log10()`** renvoie le logarithme en base 10 d'un nombre, donné par la formule : -

∀x>0,Math.log10(x)=log10(x)=l'unique  ytel que10y=x\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x

+∀x>0,Math.log10(x)=log10(x)=l'unique  ytel que10y=x\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x -
{{EmbedInteractiveExample("pages/js/math-log10.html")}}
+{{EmbedInteractiveExample("pages/js/math-log10.html")}} -

Syntaxe

+## Syntaxe -
Math.log10(x)
+ Math.log10(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui sera renvoyé.

+Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui sera renvoyé. -

Description

+## Description -

Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à {{jsxref("NaN")}}.

+Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à {{jsxref("NaN")}}. -

log10() étant une méthode statique de Math, il faut utiliser Math.log10()et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par Math.log(x) / Math.log(10).

+`log10()` étant une méthode statique de `Math`, il faut utiliser `Math.log10()`et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par `Math.log(x) / Math.log(10)`. -

Exemple

+## Exemple -

Utiliser Math.log10()

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

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Il est possible d'avoir un résultat approximatif avec la fonction suivante :

+Il est possible d'avoir un résultat approximatif avec la fonction suivante : -
Math.log10 = Math.log10 || function(x) {
+```js
+Math.log10 = Math.log10 || function(x) {
   return Math.log(x) * Math.LOG10E;
 };
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.log10', 'Math.log10')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.log10")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.log10', 'Math.log10')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.log10")}} + +## Voir aussi + +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log1p()")}} +- {{jsxref("Math.log2()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md index 175018cc26..05f9f01a3a 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log10e/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log10e/index.md @@ -9,74 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG10E --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.LOG10E fournit la valeur du logarithme en base 10 de e, environ 0.434 :

+La propriété **`Math.LOG10E`** fournit la valeur du logarithme en base 10 de e, environ 0.434 : -

Math.LOG10E=log10(e)≈0.434\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434

+Math.LOG10E=log10(e)≈0.434\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434 -
{{EmbedInteractiveExample("pages/js/math-log10e.html")}}
+{{EmbedInteractiveExample("pages/js/math-log10e.html")}}{{js_property_attributes(0,0,0)}} +## Description +`LOG10E` étant une propriété statique de `Math`, elle doit toujours être utilisée avec la syntaxe `Math.LOG10E` et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.LOG10E` -

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

+La fonction suivante renvoie le logarithme en base 10 de e : -

Exemples

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

Utiliser Math.LOG10E

+getLog10e(); // 0.4342944819032518 +``` -

La fonction suivante renvoie le logarithme en base 10 de e :

+## Spécifications -
function getLog10e() {
-   return Math.LOG10E;
-}
+| Spécification                                                                | État                         | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}     | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LOG10E")}}
+
+## Voir aussi
 
-getLog10e(); // 0.4342944819032518
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.LOG10E")}}

- -

Voir aussi

- - +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md index 04913b856c..1ca30ae91d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log1p/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log1p/index.md @@ -11,86 +11,69 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log1p --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.log1p() renvoie le logarithme népérien (en base {{jsxref("Math/E","e")}}) d'un nombre +1, donné par la formule :

+La fonction **`Math.log1p()`** renvoie le logarithme népérien (en base {{jsxref("Math/E","e")}}) d'un nombre +1, donné par la formule : -

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

+∀x>-1,Math.log1p(x)=ln(1+x)\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x) -
{{EmbedInteractiveExample("pages/js/math-log1p.html")}}
+{{EmbedInteractiveExample("pages/js/math-log1p.html")}} -

Syntaxe

+## Syntaxe -
Math.log1p(x)
+ Math.log1p(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La valeur du logarithme naturel de 1 plus l'argument (log(1 + x)). Si l'argument est inférieur à -1, {{jsxref("NaN")}} est renvoyée.

+La valeur du logarithme naturel de 1 plus l'argument (`log(1 + x`)). Si l'argument est inférieur à `-1`, {{jsxref("NaN")}} est renvoyée. -

Description

+## Description -

Si x est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN")}}.

+Si `x` est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN")}}. -

log1p étant une méthode statique de Math, il faut utiliser Math.log1p() et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+`log1p` étant une méthode statique de `Math`, il faut utiliser `Math.log1p()` et non pas la méthode d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -

Exemple

+## Exemple -

Utiliser Math.log1p()

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

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant :

+Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant : -
Math.log1p = Math.log1p || function(x) {
+```js
+Math.log1p = Math.log1p || function(x) {
   return Math.log(1 + x);
 };
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.log1p', 'Math.log1p')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.log1p")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.log1p', 'Math.log1p')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.log1p")}} + +## Voir aussi + +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} +- {{jsxref("Math.log2()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log2/index.md b/files/fr/web/javascript/reference/global_objects/math/log2/index.md index c1700ae5c1..8d9d91c64b 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log2/index.md @@ -11,79 +11,61 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/log2 --- -
{{JSRef}}
+{{JSRef}} -

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

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

∀x>0,Math.log2(x)=log2(x)=l'unique ytel que2y=x\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x

+∀x>0,Math.log2(x)=log2(x)=l'unique ytel que2y=x\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x -
{{EmbedInteractiveExample("pages/js/math-log2.html")}}
+{{EmbedInteractiveExample("pages/js/math-log2.html")}} -

Syntaxe

+## Syntaxe -
Math.log2(x)
+ Math.log2(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.

+Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé. -

Description

+## Description -

Si x est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN")}}.

+Si `x` est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("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 {{jsxref("Math.LOG2E")}} ou {{jsxref("Math.LN2")}}.

+`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 {{jsxref("Math.LOG2E")}} ou {{jsxref("Math.LN2")}}. -

Exemples

+## Exemples -

Utiliser Math.log2()

+### Utiliser `Math.log2()` -
Math.log2(3);    // 1.584962500721156
+```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

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.log2")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.log2")}} + +## Voir aussi + +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log10()")}} +- {{jsxref("Math.log1p()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md index ef33a48cf1..6f986e4bf3 100644 --- a/files/fr/web/javascript/reference/global_objects/math/log2e/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/log2e/index.md @@ -9,74 +9,47 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E original_slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG2E --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.LOG2E représente la valeur du logarithme en base 2 de e, environ 1.442 :

+La propriété **`Math.LOG2E`** représente la valeur du logarithme en base 2 de e, environ 1.442 : -

Math.LOG2E=log2(e)≈1.442\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442

+Math.LOG2E=log2(e)≈1.442\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442 -
{{EmbedInteractiveExample("pages/js/math-log2e.html")}}
+{{EmbedInteractiveExample("pages/js/math-log2e.html")}}{{js_property_attributes(0,0,0)}} +## Description +`LOG2E` est une propriété statique de l'objet `Math` et doit toujours être utilisé avec la syntaxe `Math.LOG2E` plutôt que comme la propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.LOG2E` -

LOG2E est une propriété statique de l'objet Math et doit toujours être utilisé avec la syntaxe Math.LOG2E plutôt que comme la propriété d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+La fonction suivante renvoie la valeur du logarithme en base 2 de e : -

Exemples

+```js +function getLog2e() { + return Math.LOG2E; +} -

Utiliser Math.LOG2E

+getLog2e(); // 1.4426950408889634 +``` -

La fonction suivante renvoie la valeur du logarithme en base 2 de e :

+## Spécifications -
function getLog2e() {
-   return Math.LOG2E;
-}
+| Spécification                                                                | Statut                       | Commentaires                                          |
+| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                                     | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}         | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.LOG2E")}}
+
+## Voir aussi
 
-getLog2e(); // 1.4426950408889634
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.LOG2E")}}

- -

Voir aussi

- - +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.log2()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/max/index.md b/files/fr/web/javascript/reference/global_objects/math/max/index.md index 78e3810bca..ceae8a1e98 100644 --- a/files/fr/web/javascript/reference/global_objects/math/max/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/max/index.md @@ -9,104 +9,84 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/max original_slug: Web/JavaScript/Reference/Objets_globaux/Math/max --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.max() renvoie le plus grand nombre d'une série de 0 ou plusieurs nombres.

+La fonction **`Math.max()`** renvoie le plus grand nombre d'une série de 0 ou plusieurs nombres. -
{{EmbedInteractiveExample("pages/js/math-max.html")}}
+{{EmbedInteractiveExample("pages/js/math-max.html")}} -

Syntaxe

+## Syntaxe -
Math.max([valeur1[,valeur2, ...]])
+ Math.max([valeur1[,valeur2, ...]]) -

Paramètres

+### Paramètres -
-
valeur1, valeur2, ...
-
Des nombres.
-
+- `valeur1, valeur2, ...` + - : Des nombres. -

Valeur de retour

+### 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 {{jsxref("NaN")}} qui sera renvoyé.

+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 {{jsxref("NaN")}} qui sera renvoyé. -

Description

+## 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).

+`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). -

Si aucun argument n'est fourni, le résultat sera -{{jsxref("Infinity")}}.

+Si aucun argument n'est fourni, le résultat sera -{{jsxref("Infinity")}}. -

Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.

+Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}. -

Exemple

+## Exemple -

Utiliser Math.max()

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

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

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

La méthode {{jsxref("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 :

+La méthode {{jsxref("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 : -
var arr = [1, 2, 3];
+```js
+var arr = [1, 2, 3];
 var max = arr.reduce(function(a,b) {
   return Math.max(a, b);
-});
+}); +``` -

On peut également utiliser {{jsxref("Function.prototype.apply()")}} afin de trouver le maximum parmi un tableau de nombres. getMaxTableau([1,2,3]) sera équivalent à Math.max(1, 2, 3), mais getMaxTableau pourra être utilisé sur des tableaux de n'importe quelle taille.

+On peut également utiliser {{jsxref("Function.prototype.apply()")}} afin de trouver le maximum parmi un tableau de nombres. `getMaxTableau([1,2,3])` sera équivalent à `Math.max(1, 2, 3)`, mais `getMaxTableau` pourra être utilisé sur des tableaux de n'importe quelle taille. -
function getMaxTableau(tableauNumérique) {
+```js
+function getMaxTableau(tableauNumérique) {
     return Math.max.apply(null, tableauNumérique);
-}
- -

Avec le nouvel {{jsxref("Opérateurs/Affecter_par_décomposition","opérateur de décomposition","","1")}}, on pourra également utiliser cette syntaxe, plus concise et plus simple :

- -
var arr = [1, 2, 3];
-var max = Math.max(...arr);
- -

Attention avec la décomposition et apply() qui pourront é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

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.max', 'Math.max')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.max")}}

- -

Voir aussi

- - +} +``` + +Avec le nouvel {{jsxref("Opérateurs/Affecter_par_décomposition","opérateur de décomposition","","1")}}, on pourra également utiliser cette syntaxe, plus concise et plus simple : + +```js +var arr = [1, 2, 3]; +var max = Math.max(...arr); +``` + +Attention avec la décomposition et `apply()` qui pourront é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](/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply#Utiliser_apply_et_des_fonctions_natives). La méthode proposée avec `reduce()` n'a pas cette contrainte. + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.max', 'Math.max')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.max', 'Math.max')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.max")}} + +## Voir aussi + +- {{jsxref("Math.min()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/min/index.md b/files/fr/web/javascript/reference/global_objects/math/min/index.md index 39cd2d8567..0fa9c67c58 100644 --- a/files/fr/web/javascript/reference/global_objects/math/min/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/min/index.md @@ -9,100 +9,77 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/min original_slug: Web/JavaScript/Reference/Objets_globaux/Math/min --- -
{{JSRef}}
+{{JSRef}} -

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

+La fonction **`Math.min()`** renvoie le plus petit nombre d'une série de 0 ou plusieurs nombres ou bien {{jsxref("NaN")}} si au moins un des arguments fourni n'est pas un nombre ou ne peut pas être converti en nombre. -
{{EmbedInteractiveExample("pages/js/math-min.html")}}
+{{EmbedInteractiveExample("pages/js/math-min.html")}} -

Syntaxe

+## Syntaxe -
Math.min([valeur1[,valeur2, ...]])
+ Math.min([valeur1[,valeur2, ...]]) -

Paramètres

+### Paramètres -
-
valeur1, valeur2, ...
-
Des nombres.
-
+- `valeur1, valeur2, ...` + - : Des nombres. -

Valeur de retour

+### 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 {{jsxref("NaN")}} qui sera renvoyé. Le résultat sera {{jsxref("Infinity")}} si aucun paramètre n'est fourni.

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

Description

+## 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).

+`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 {{jsxref("Infinity")}}.

+Si aucun argument n'est fourni, le résultat renvoyé par la fonction sera {{jsxref("Infinity")}}. -

Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.

+Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}. -

Exemples

+## Exemples -

Utiliser Math.min()

+### Utiliser `Math.min()` -

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

+Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z : -
var x = 10, y = -20;
+```js
+var x = 10, y = -20;
 var z = Math.min(x, y);
-
+``` -

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

+### 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 :

+`Math.min()` est souvent utilisée afin de ramener une certaine valeur dans un intervalle donné. Par exemple : -
var x = f(toto);
+```js
+var x = f(toto);
 
-if (x > limite) {
+if (x > limite) {
   x = limite;
 }
-
- -

peut s'écrire

- -
var x = Math.min(f(toto), limite);
- -
{{jsxref("Math.max()")}} peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné.
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.min', 'Math.min')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.min")}}

- -

Voir aussi

- - +``` + +peut s'écrire + +```js +var x = Math.min(f(toto), limite); +``` + +{{jsxref("Math.max()")}} peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné. + +## Spécifications + +| Spécification | Statut | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.min', 'Math.min')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.min', 'Math.min')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.min")}} + +## Voir aussi + +- {{jsxref("Math.max()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/pi/index.md b/files/fr/web/javascript/reference/global_objects/math/pi/index.md index d9aa0848db..d8f6d65a4a 100644 --- a/files/fr/web/javascript/reference/global_objects/math/pi/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/pi/index.md @@ -9,72 +9,45 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI original_slug: Web/JavaScript/Reference/Objets_globaux/Math/PI --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.PI représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159:

+La propriété **`Math.PI`** représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159: -

Math.PI=π≈3.14159\mathtt{\mi{Math.PI}} = \pi \approx 3.14159

+Math.PI=π≈3.14159\mathtt{\mi{Math.PI}} = \pi \approx 3.14159 -
{{EmbedInteractiveExample("pages/js/math-pi.html")}}
+{{EmbedInteractiveExample("pages/js/math-pi.html")}}{{js_property_attributes(0,0,0)}} +## Description +`PI` est une propriété statique de l'objet `Math` et doit toujours être utilisée avec la syntaxe `Math.PI` plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+### Utiliser `Math.PI` -

PI est une propriété statique de l'objet Math et doit toujours être utilisée avec la syntaxe Math.PI plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (Math n'est pas un constructeur).

+La fonction suivante utilise `Math.PI` afin de calculer le périmètre d'un cercle à partir du rayon passé en argument. -

Exemples

+```js +function calculPérimètre(rayon) { + return 2 * Math.PI * rayon; +} -

Utiliser Math.PI

+calculPérimètre(1); // 6.283185307179586 +``` -

La fonction suivante utilise Math.PI afin de calculer le périmètre d'un cercle à partir du rayon passé en argument.

+## Spécifications -
function calculPérimètre(rayon) {
-  return 2 * Math.PI * rayon;
-}
+| Spécification                                                        | Statut                       | Commentaires                                          |
+| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- |
+| {{SpecName('ES1')}}                                             | {{Spec2('ES1')}}         | Définition initiale. Implémentée avec JavaScript 1.0. |
+| {{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}     | {{Spec2('ES5.1')}}     |                                                       |
+| {{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}         | {{Spec2('ES6')}}         |                                                       |
+| {{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}} | {{Spec2('ESDraft')}} |                                                       |
+
+## Compatibilité des navigateurs
+
+{{Compat("javascript.builtins.Math.PI")}}
+
+## Voir aussi
 
-calculPérimètre(1);  // 6.283185307179586
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.PI")}}

- -

Voir aussi

- - +- {{jsxref("Math")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/pow/index.md b/files/fr/web/javascript/reference/global_objects/math/pow/index.md index b12f348e80..e85580ec3d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/pow/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/pow/index.md @@ -9,38 +9,37 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow original_slug: Web/JavaScript/Reference/Objets_globaux/Math/pow --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.pow() renvoie un nombre à une certaine puissance, c'est-à-dire base^exposant.

+La fonction **`Math.pow()`** renvoie un nombre à une certaine puissance, c'est-à-dire `base^exposant`. -
{{EmbedInteractiveExample("pages/js/math-pow.html")}}
+{{EmbedInteractiveExample("pages/js/math-pow.html")}} -

Syntaxe

+## Syntaxe -
Math.pow(base, exposant);
+ Math.pow(base, exposant); -

Paramètres

+### Paramètres -
-
base
-
Le nombre correspondant à la base.
-
exponent
-
L'exposant auquel on élève le paramètre précédent.
-
+- `base` + - : Le nombre correspondant à la base. +- `exponent` + - : L'exposant auquel on élève le paramètre précédent. -

Valeur de retour

+### Valeur de retour -

Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument).

+Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument). -

Description

+## Description -

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

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

Exemple

+## Exemple -

Utiliser Math.pow()

+### Utiliser `Math.pow()` -
// Utilisation simple
+```js
+// Utilisation simple
 Math.pow(7, 2); // 49
 
 // Exposants négatifs
@@ -54,50 +53,25 @@ Math.pow(-7, 0.5); // NaN
 // (les nombres négatifs n'ont pas de racine carrée)
 Math.pow(-7, 1/3); // NaN
 // Nombre négatif avec une base décimale
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.pow")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.pow', 'Math.pow')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.pow")}} + +## Voir aussi + +- {{jsxref("Math.cbrt()")}} +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.sqrt()")}} +- [Opérateur d'exponentiation]() {{experimental_inline}} diff --git a/files/fr/web/javascript/reference/global_objects/math/random/index.md b/files/fr/web/javascript/reference/global_objects/math/random/index.md index c5b3df93df..e0ae51c992 100644 --- a/files/fr/web/javascript/reference/global_objects/math/random/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/random/index.md @@ -9,46 +9,49 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/random original_slug: Web/JavaScript/Reference/Objets_globaux/Math/random --- -
{{JSRef}}
+{{JSRef}} -

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.

+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. -
{{EmbedInteractiveExample("pages/js/math-random.html")}}
+{{EmbedInteractiveExample("pages/js/math-random.html")}} -
-

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 {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.

-
+> **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 {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}. -

Syntaxe

+## Syntaxe -
Math.random()
+ Math.random() -

Valeur de retour

+### Valeur de retour -

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

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

Exemples

+## 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.

+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

+### Obtenir un nombre aléatoire entre 0 et 1 -
// On renvoie un nombre aléatoire entre 0 (inclus) et 1 (exclus)
+```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

+### Obtenir un nombre aléatoire dans un intervalle -
// On renvoie un nombre aléatoire entre une valeur min (incluse)
+```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

+### Obtenir un entier aléatoire dans un intervalle ouvert à droite -
// On renvoie un entier aléatoire entre une valeur min (incluse)
+```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 !
@@ -57,15 +60,14 @@ function getRandomInt(min, max) {
   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.

-
+> **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é

+### Obtenir un entier aléatoire dans un intervalle fermé -
// On renvoie un entier aléatoire entre une valeur min (incluse)
+```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 !
@@ -74,40 +76,17 @@ function getRandomIntInclusive(min, max) {
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min +1)) + min;
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0 (UNIX) et 1.1 (toutes plateformes).
{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.random', 'Math.random')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.random")}}

+``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0 (UNIX) et 1.1 (toutes plateformes). | +| {{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.random', 'Math.random')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.random', 'Math.random')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.random")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/round/index.md b/files/fr/web/javascript/reference/global_objects/math/round/index.md index fb671af237..f43dc4f6c5 100644 --- a/files/fr/web/javascript/reference/global_objects/math/round/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/round/index.md @@ -9,86 +9,60 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/round original_slug: Web/JavaScript/Reference/Objets_globaux/Math/round --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.round() retourne la valeur d'un nombre arrondi à l'entier le plus proche.

+La fonction **`Math.round()`** retourne la valeur d'un nombre arrondi à l'entier le plus proche. -
{{EmbedInteractiveExample("pages/js/math-round.html")}}
+{{EmbedInteractiveExample("pages/js/math-round.html")}} -

Syntaxe

+## Syntaxe -
Math.round(x)
+ Math.round(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La valeur de l'entier le plus proche du nombre passé en argument.

+La valeur de l'entier le plus proche du nombre passé en argument. -

Description

+## Description -

Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus grande. Si elle est plus petite que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus petite. Si la partie décimale du nombre vaut exactement 0.5, l'argument est arrondi à l'entier le plus proche en direction de l'infini positif (attention, pour la plupart des langages de programmation, c'est le nombre avec la plus grande valeur absolue qui est renvoyé ; on a donc une différence de comportement pour les nombres négatifs dont la partie décimale vaut exactement 0.5).

+Si la partie décimale du nombre est plus grande que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus grande. Si elle est plus petite que 0.5, l'argument est arrondi à l'entier le plus proche dont la valeur absolue est plus petite. Si la partie décimale du nombre vaut exactement 0.5, l'argument est arrondi à l'entier le plus proche en direction de l'infini positif (attention, pour la plupart des langages de programmation, c'est le nombre avec la plus grande valeur absolue qui est renvoyé ; on a donc une différence de comportement pour les nombres négatifs dont la partie décimale vaut exactement 0.5). -

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

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

Exemples

+## Exemples -
Math.round(20.49); //  20
+```js
+Math.round(20.49); //  20
 Math.round(20.5);  //  21
 Math.round(42);    //  42
 Math.round(-20.5); // -20
 Math.round(-20.51);// -21
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}{{Spec2('ES5.1')}}
{{SpecName('ES6', '#sec-math.round', 'Math.round')}}{{Spec2('ES6')}}
{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.round")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}} | {{Spec2('ES5.1')}} | | +| {{SpecName('ES6', '#sec-math.round', 'Math.round')}} | {{Spec2('ES6')}} | | +| {{SpecName('ESDraft', '#sec-math.round', 'Math.round')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.round")}} + +## Voir aussi + +- {{jsxref("Number.toPrecision()")}} +- {{jsxref("Number.toFixed()")}} +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.ceil()")}} +- {{jsxref("Math.floor()")}} +- {{jsxref("Math.sign()")}} +- {{jsxref("Math.trunc()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sign/index.md b/files/fr/web/javascript/reference/global_objects/math/sign/index.md index c27e808527..44a438171e 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sign/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sign/index.md @@ -11,38 +11,37 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sign --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.sign() renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul.

+La fonction **`Math.sign()`** renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul. -
{{EmbedInteractiveExample("pages/js/math-sign.html")}}
+{{EmbedInteractiveExample("pages/js/math-sign.html")}} -

Syntaxe

+## Syntaxe -
Math.sign(x)
+ Math.sign(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

Un nombre qui représente le signe de l'argument. Si l'argument est un nombre positif, négatif, un zéro positif ou un zéro négatif, la fonction renverra respectivement 1, -1, 0, -0. Sinon, ce sera {{jsxref("NaN")}} qui sera renvoyé.

+Un nombre qui représente le signe de l'argument. Si l'argument est un nombre positif, négatif, un zéro positif ou un zéro négatif, la fonction renverra respectivement `1`, `-1`, `0`, `-0`. Sinon, ce sera {{jsxref("NaN")}} qui sera renvoyé. -

Description

+## Description -

sign() étant une méthode statique de Math, il faut utiliser Math.sign() et non pas la méthode d'un autre objet qui aurait été créé (Math n'est pas un constructeur).

+`sign()` étant une méthode statique de `Math`, il faut utiliser `Math.sign()` et non pas la méthode d'un autre objet qui aurait été créé (`Math `n'est pas un constructeur). -

Cette fonction peut renvoyer 5 valeurs : 1, -1, 0, -0, NaN, qui indiquent respectivement que x est un nombre positif, un nombre négatif, zéro, la limite négative de zéro, et n'est pas un nombre pour {{jsxref("NaN")}}.

+Cette fonction peut renvoyer 5 valeurs : `1, -1, 0, -0, NaN,` qui indiquent respectivement que `x` est un nombre positif, un nombre négatif, zéro, la limite négative de zéro, et n'est pas un nombre pour {{jsxref("NaN")}}. -

L'argument passé à cette fonction sera implicitement converti au type number.

+L'argument passé à cette fonction sera implicitement converti au type `number`. -

Exemples

+## Exemples -
Math.sign(3)     //  1
+```js
+Math.sign(3)     //  1
 Math.sign(-3)    // -1
 Math.sign("-3")  // -1
 Math.sign(0)     //  0
@@ -50,40 +49,23 @@ Math.sign(-0)    // -0
 Math.sign(NaN)   // NaN
 Math.sign("foo") // NaN
 Math.sign()      // NaN
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}{{Spec2('ES6')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.sign")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES6', '#sec-math.sign', 'Math.sign')}} | {{Spec2('ES6')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.sign")}} + +## Voir aussi + +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.ceil()")}} +- {{jsxref("Math.floor()")}} +- {{jsxref("Math.round()")}} +- {{jsxref("Math.trunc()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sin/index.md b/files/fr/web/javascript/reference/global_objects/math/sin/index.md index 3f3ea2afe8..35bb474eef 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sin/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sin/index.md @@ -9,83 +9,58 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sin --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.sin() renvoie le sinus d'un nombre.

+La fonction **`Math.sin()`** renvoie le sinus d'un nombre. -
{{EmbedInteractiveExample("pages/js/math-sin.html")}}
+{{EmbedInteractiveExample("pages/js/math-sin.html")}} -

Syntaxe

+## Syntaxe -
Math.sin(x)
+ Math.sin(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre (qui exprime un angle en radians).
-
+- `x` + - : Un nombre (qui exprime un angle en radians). -

Valeur de retour

+### Valeur de retour -

Le sinus de la valeur passée en argument (qui correspond à un angle en radians).

+Le sinus de la valeur passée en argument (qui correspond à un angle en radians). -

Description

+## Description -

La méthode sin() renvoie une valeur numérique comprise (au sens large) entre 1 et -1 et qui représente le sinus d'un angle donné en radians.

+La méthode `sin()` renvoie une valeur numérique comprise (au sens large) entre 1 et -1 et qui représente le sinus d'un angle donné en radians. -

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

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

Exemples

+## Exemples -
Math.sin(0);           // 0
+```js
+Math.sin(0);           // 0
 Math.sin(1);           // 0.8414709848078965
 
-Math.sin(Math.PI / 2); // 1
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.sin")}}

- -

Voir aussi

- - +Math.sin(Math.PI / 2); // 1 +``` + +## Spécifications + +| Spécification | Statut | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.sin', 'Math.sin')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.sin")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.tan()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sinh/index.md b/files/fr/web/javascript/reference/global_objects/math/sinh/index.md index 4edf3a2ad5..9a74084918 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sinh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sinh/index.md @@ -11,85 +11,72 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sinh --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.sinh() renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante {{jsxref("Math.E","e")}}, est :

+La fonction **`Math.sinh()`** renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante {{jsxref("Math.E","e")}}, est : -

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

+Math.sinh(x)=ex-e-x2\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2} -
{{EmbedInteractiveExample("pages/js/math-sinh.html")}}
+{{EmbedInteractiveExample("pages/js/math-sinh.html")}} -

Syntaxe

+## Syntaxe -
Math.sinh(x)
+ Math.sinh(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

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

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

Description

+## 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).

+`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

+## Exemples -
Math.sinh(0) // 0
-Math.sinh(1) // 1.1752011936438014
+```js +Math.sinh(0) // 0 +Math.sinh(1) // 1.1752011936438014 +``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

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

+Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}` :` -
Math.sinh = Math.sinh || function(x){
+```js
+Math.sinh = Math.sinh || function(x){
     return (Math.exp(x) - Math.exp(-x)) / 2;
-};
+}; +``` -

ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec :

+ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec : -
Math.sinh = Math.sinh || function(x){
+```js
+Math.sinh = Math.sinh || function(x){
     var y = Math.exp(x);
     return (y - 1/y) / 2;
-};
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.sinh', 'Math.sinh')}}{{Spec2('ES2015')}}Définition initiale
{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.sinh")}}

- -

Voir aussi

- - +}; +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ------------------- | +| {{SpecName('ES2015', '#sec-math.sinh', 'Math.sinh')}} | {{Spec2('ES2015')}} | Définition initiale | +| {{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.sinh")}} + +## Voir aussi + +- {{jsxref("Math.acosh()")}} +- {{jsxref("Math.asinh()")}} +- {{jsxref("Math.atanh()")}} +- {{jsxref("Math.cosh()")}} +- {{jsxref("Math.tanh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md index 6b309e4d01..8af569dd19 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt/index.md @@ -9,86 +9,61 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt original_slug: Web/JavaScript/Reference/Objets_globaux/Math/sqrt --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.sqrt() renvoie la racine carrée d'un nombre. Cette fonction est définie par :

+La fonction **`Math.sqrt()`** renvoie la racine carrée d'un nombre. Cette fonction est définie par : -

∀x≥0,Math.sqrt(x)=x=l'uniquey≥0tel quey2=x\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x

+∀x≥0,Math.sqrt(x)=x=l'uniquey≥0tel quey2=x\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x -
{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}
+{{EmbedInteractiveExample("pages/js/math-sqrt.html")}} -

Syntaxe

+## Syntaxe -
Math.sqrt(x)
+ Math.sqrt(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.

+La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé. -

Description

+## Description -

Si la valeur de x est négative, sqrt renverra {{jsxref("NaN")}}.

+Si la valeur de `x` est négative, `sqrt` renverra {{jsxref("NaN")}}. -

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

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

Exemples

+## Exemples -
Math.sqrt(9);  // 3
+```js
+Math.sqrt(9);  // 3
 Math.sqrt(2);  // 1.414213562373095
 
 Math.sqrt(1);  // 1
 Math.sqrt(0);  // 0
 Math.sqrt(-1); // NaN
-Math.sqrt(-0); // -0
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.sqrt")}}

- -

Voir aussi

- - +Math.sqrt(-0); // -0 +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.sqrt")}} + +## Voir aussi + +- {{jsxref("Math.cbrt()")}} +- {{jsxref("Math.exp()")}} +- {{jsxref("Math.log()")}} +- {{jsxref("Math.pow()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md index 7a1037786c..2af49cd3ca 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt1_2/index.md @@ -9,71 +9,44 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT1_2 --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.SQRT1_2 représente la racine carrée d'1/2 et vaut environ 0.707 :

+La propriété **`Math.SQRT1_2`** représente la racine carrée d'1/2 et vaut environ 0.707 : -

Math.SQRT1_2=12=12≈0.707\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707

+Math.SQRT1_2=12=12≈0.707\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707 -
{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}
+{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}{{js_property_attributes(0,0,0)}} +## 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). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+La fonction suivante renvoie la valeur de cette constante : -

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 :

- -
function getRoot1_2() {
+```js
+function getRoot1_2() {
    return Math.SQRT1_2;
 }
 
-getRoot1_2(); // 0.7071067811865476
+getRoot1_2(); // 0.7071067811865476 +``` -

Spécifications

+## Spécifications - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}{{Spec2('ESDraft')}} 
+| Spécification | Statut | Commentaires | +| -------------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}} | {{Spec2('ESDraft')}} |   | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Math.SQRT1_2")}}

+{{Compat("javascript.builtins.Math.SQRT1_2")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Math.pow()")}} +- {{jsxref("Math.sqrt()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md index 964c355404..a9ba6b6994 100644 --- a/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/sqrt2/index.md @@ -9,71 +9,44 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 original_slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT2 --- -
{{JSRef}}
+{{JSRef}} -

La propriété Math.SQRT2 représente la racine carrée de 2 et vaut environ 1.414 :

+La propriété **`Math.SQRT2`** représente la racine carrée de 2 et vaut environ 1.414 : -

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

+Math.SQRT2=2≈1.414\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414 -
{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}
+{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}{{js_property_attributes(0,0,0)}} +## Description +`SQRT2` est une propriété statique de `Math` et doit toujours être utilisée avec la syntaxe `Math.SQRT2`, elle ne doit pas être appelée comme propriété d'un autre objet qui aurait été créé (`Math` n'est pas un constructeur). -
{{js_property_attributes(0,0,0)}}
+## Exemples -

Description

+La fonction suivante renvoie la valeur de la racine carrée de 2 : -

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

- -

Exemples

- -

La fonction suivante renvoie la valeur de la racine carrée de 2 :

- -
function getRoot2() {
+```js
+function getRoot2() {
    return Math.SQRT2;
 }
 
-getRoot2(); // 1.4142135623730951
+getRoot2(); // 1.4142135623730951 +``` -

Spécifications

+## Spécifications - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationStatutCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}{{Spec2('ESDraft')}} 
+| Spécification | Statut | Commentaires | +| ---------------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}} | {{Spec2('ESDraft')}} |   | -

Compatibilité des navigateurs

+## Compatibilité des navigateurs -

{{Compat("javascript.builtins.Math.SQRT2")}}

+{{Compat("javascript.builtins.Math.SQRT2")}} -

Voir aussi

+## Voir aussi - +- {{jsxref("Math.pow()")}} +- {{jsxref("Math.sqrt()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/tan/index.md b/files/fr/web/javascript/reference/global_objects/math/tan/index.md index 17d938acab..12b35857d3 100644 --- a/files/fr/web/javascript/reference/global_objects/math/tan/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/tan/index.md @@ -9,90 +9,66 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan original_slug: Web/JavaScript/Reference/Objets_globaux/Math/tan --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.tan() renvoie la tangente d'un nombre exprimant un angle en radians.

+La fonction **`Math.tan()`** renvoie la tangente d'un nombre exprimant un angle en radians. -
{{EmbedInteractiveExample("pages/js/math-tan.html")}}
+{{EmbedInteractiveExample("pages/js/math-tan.html")}} -

Syntaxe

+## Syntaxe -
Math.tan(x)
+ Math.tan(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre qui représente un angle en radians.
-
+- `x` + - : Un nombre qui représente un angle en radians. -

Valeur de retour

+### Valeur de retour -

La tangente de l'angle fourni en argument (exprimé en radians).

+La tangente de l'angle fourni en argument (exprimé en radians). -

Description

+## Description -

La méthode Math.tan() renvoie une valeur numérique qui représente la tangente d'un angle.

+La méthode `Math.tan()` renvoie une valeur numérique qui représente la tangente d'un angle. -

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

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

Exemples

+## Exemples -

Utiliser Math.tan()

+### Utiliser `Math.tan()` -
Math.tan(1); // 1.5574077246549023
+```js +Math.tan(1); // 1.5574077246549023 +``` -

Math.tan() considère un argument exprimé en radians. Cependant, on peut vouloir travailler avec des valeurs en degrés. Pour cela, on pourra utiliser la fonction suivante qui calcule la tangente après avoir converti l'argument en radians :

+`Math.tan()` considère un argument exprimé en radians. Cependant, on peut vouloir travailler avec des valeurs en degrés. Pour cela, on pourra utiliser la fonction suivante qui calcule la tangente après avoir converti l'argument en radians : -
function getTanDeg(deg) {
+```js
+function getTanDeg(deg) {
    var rad = deg * Math.PI/180;
    return Math.tan(rad);
 }
-
- -

Spécifications

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES1')}}{{Spec2('ES1')}}Définition initiale. Implémentée avec JavaScript 1.0.
{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}{{Spec2('ES5.1')}} 
{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}{{Spec2('ES6')}} 
{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.tan")}}

- -

Voir aussi

- - +``` + +## Spécifications + +| Spécification | État | Commentaires | +| -------------------------------------------------------------------- | ---------------------------- | ----------------------------------------------------- | +| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Définition initiale. Implémentée avec JavaScript 1.0. | +| {{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}} | {{Spec2('ES5.1')}} |   | +| {{SpecName('ES6', '#sec-math.tan', 'Math.tan')}} | {{Spec2('ES6')}} |   | +| {{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.tan")}} + +## Voir aussi + +- {{jsxref("Math.acos()")}} +- {{jsxref("Math.asin()")}} +- {{jsxref("Math.atan()")}} +- {{jsxref("Math.atan2()")}} +- {{jsxref("Math.cos()")}} +- {{jsxref("Math.sin()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/tanh/index.md b/files/fr/web/javascript/reference/global_objects/math/tanh/index.md index be6fc10fd0..88505bc59d 100644 --- a/files/fr/web/javascript/reference/global_objects/math/tanh/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/tanh/index.md @@ -11,53 +11,56 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh original_slug: Web/JavaScript/Reference/Objets_globaux/Math/tanh --- -
{{JSRef}}
+{{JSRef}} -

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

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

tanhx=sinhxcoshx=ex-e-xex+e-x=e2x-1e2x+1\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}

+tanhx=sinhxcoshx=ex-e-xex+e-x=e2x-1e2x+1\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1} -
{{EmbedInteractiveExample("pages/js/math-tanh.html")}}
+{{EmbedInteractiveExample("pages/js/math-tanh.html")}} -

Syntaxe

+## Syntaxe -
Math.tanh(x)
+ Math.tanh(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La tangente hyperbolique du nombre fourni en argument.

+La tangente hyperbolique du nombre fourni en argument. -

Description

+## 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).

+`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

+## Exemples -

Utiliser Math.tanh()

+### Utiliser `Math.tanh()` -
Math.tanh(0);        // 0
+```js
+Math.tanh(0);        // 0
 Math.tanh(Infinity); // 1
-Math.tanh(1);        // 0.7615941559557649
+Math.tanh(1); // 0.7615941559557649 +``` -

Prothèse d'émulation (polyfill)

+## Prothèse d'émulation (_polyfill_) -

Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :

+Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} : -
Math.tanh = Math.tanh || function(x){
+```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 à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :

+et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}` :` -
Math.tanhx = Math.tanhx || function(x) {
+```js
+Math.tanhx = Math.tanhx || function(x) {
   if(x === Infinity) {
     return 1;
   } else if(x === -Infinity) {
@@ -66,40 +69,24 @@ Math.tanh(1);        // 0.7615941559557649
var y = Math.exp(2 * x); return (y - 1) / (y + 1); } -}; - -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaires
{{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}}{{Spec2('ES2015')}}Définition initiale.
{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}{{Spec2('ESDraft')}} 
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.tanh")}}

- -

Voir aussi

- - +}; +``` + +## Spécifications + +| Spécification | État | Commentaires | +| ------------------------------------------------------------------------ | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}} | {{Spec2('ES2015')}} | Définition initiale. | +| {{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}} | {{Spec2('ESDraft')}} |   | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.tanh")}} + +## Voir aussi + +- {{jsxref("Math.acosh()")}} +- {{jsxref("Math.asinh()")}} +- {{jsxref("Math.atanh()")}} +- {{jsxref("Math.cosh()")}} +- {{jsxref("Math.sinh()")}} diff --git a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md index c78b0cb6ec..64c918039a 100644 --- a/files/fr/web/javascript/reference/global_objects/math/trunc/index.md +++ b/files/fr/web/javascript/reference/global_objects/math/trunc/index.md @@ -11,84 +11,67 @@ tags: translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc original_slug: Web/JavaScript/Reference/Objets_globaux/Math/trunc --- -
{{JSRef}}
+{{JSRef}} -

La fonction Math.trunc() retourne la troncature entière d'un nombre en retirant sa partie décimale.

+La fonction **`Math.trunc()`** retourne la troncature entière d'un nombre en retirant sa partie décimale. -

Math.trunc(x)={⌊x⌋six≥0⌈x⌉six<0\mathtt{\operatorname{Math.trunc}(x)} = \begin{cases} \left\lfloor x \right\rfloor & \text{if} & x \geq 0 \\ \left\lceil x \right\rceil & \text{if} &x < 0 \end{cases}

+Math.trunc(x)={⌊x⌋six≥0⌈x⌉six<0\mathtt{\operatorname{Math.trunc}(x)} = \begin{cases} \left\lfloor x \right\rfloor & \text{if} & x \geq 0 \\ \left\lceil x \right\rceil & \text{if} &x < 0 \end{cases} -
{{EmbedInteractiveExample("pages/js/math-trunc.html")}}
+{{EmbedInteractiveExample("pages/js/math-trunc.html")}} -

Syntaxe

+## Syntaxe -
Math.trunc(x)
+ Math.trunc(x) -

Paramètres

+### Paramètres -
-
x
-
Un nombre.
-
+- `x` + - : Un nombre. -

Valeur de retour

+### Valeur de retour -

La partie entière du nombre passé en argument.

+La partie entière du nombre passé en argument. -

Description

+## Description -

Contrairement aux autres méthodes {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} et {{jsxref("Math.round()")}}, Math.trunc() fonctionne de façon très simple : la partie décimale du nombre est retirée et on conserve la partie entière (que le nombre soit positif ou négatif).
-
- Ainsi, si l'argument est un nombre positif, Math.trunc() sera équivalent à Math.floor(), sinon Math.trunc() sera équivalent à Math.ceil().

+Contrairement aux autres méthodes {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} et {{jsxref("Math.round()")}}, `Math.trunc()` fonctionne de façon très simple : la partie décimale du nombre est retirée et on conserve la partie entière (que le nombre soit positif ou négatif). -

On notera que l'argument passé à la méthode est converti en nombre de façon implicite.

+Ainsi, si l'argument est un nombre positif, `Math.trunc()` sera équivalent à `Math.floor()`, sinon `Math.trunc()` sera équivalent à `Math.ceil()`. -

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

+On notera que l'argument passé à la méthode est converti en nombre de façon implicite. -

Exemples

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

Utiliser Math.trunc()

+## Exemples -
Math.trunc(13.37);   // 13
+### Utiliser `Math.trunc()`
+
+```js
+Math.trunc(13.37);   // 13
 Math.trunc(42.84);   // 42
 Math.trunc(0.123);   //  0
 Math.trunc(-0.123);  // -0
 Math.trunc("-1.123");// -1
 Math.trunc(NaN);     // NaN
 Math.trunc("toto");  // NaN
-Math.trunc();        // NaN
- -

Spécifications

- - - - - - - - - - - - - - - - - - - -
SpécificationÉtatCommentaire
{{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ES2015')}}Première définition.
{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}{{Spec2('ESDraft')}}
- -

Compatibilité des navigateurs

- -

{{Compat("javascript.builtins.Math.trunc")}}

- -

Voir aussi

- - +Math.trunc(); // NaN +``` + +## Spécifications + +| Spécification | État | Commentaire | +| ---------------------------------------------------------------------------- | ---------------------------- | -------------------- | +| {{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}} | {{Spec2('ES2015')}} | Première définition. | +| {{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}} | {{Spec2('ESDraft')}} | | + +## Compatibilité des navigateurs + +{{Compat("javascript.builtins.Math.trunc")}} + +## Voir aussi + +- {{jsxref("Math.abs()")}} +- {{jsxref("Math.ceil()")}} +- {{jsxref("Math.floor()")}} +- {{jsxref("Math.round()")}} +- {{jsxref("Math.sign()")}} -- cgit v1.2.3-54-g00ecf