diff options
Diffstat (limited to 'files/fr/web/javascript/reference/objets_globaux/math')
44 files changed, 4440 insertions, 0 deletions
diff --git a/files/fr/web/javascript/reference/objets_globaux/math/abs/index.html b/files/fr/web/javascript/reference/objets_globaux/math/abs/index.html new file mode 100644 index 0000000000..925364b1ca --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/abs/index.html @@ -0,0 +1,103 @@ +--- +title: Math.abs() +slug: Web/JavaScript/Reference/Objets_globaux/Math/abs +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.abs()</strong></code> retourne la valeur absolue d'un nombre, c'est-à-dire</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>si</mtext><mspace width="1em"></mspace><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x & \text{si} \quad x \geq 0 \\ -x & \text{si} \quad x < 0 \end{cases} </annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-abs.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.abs(<em>x</em>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_absolue">Valeur absolue</h3> + +<p>La valeur absolue du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>abs</code> est une méthode statique de l'objet <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.abs()</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.abs()">Utiliser <code>Math.abs()</code></h3> + +<p>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.</p> + +<pre class="brush:js">Math.abs('-1'); // 1 +Math.abs(-2); // 2 +Math.abs(null); // 0 +Math.abs(''); // 0 +Math.abs([]); // 0 +Math.abs([2]); // 2 +Math.abs([1,2]); // NaN +Math.abs({}); // NaN +Math.abs("string"); // NaN +Math.abs(); // NaN</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.abs")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/acos/index.html b/files/fr/web/javascript/reference/objets_globaux/math/acos/index.html new file mode 100644 index 0000000000..b0de810d35 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/acos/index.html @@ -0,0 +1,103 @@ +--- +title: Math.acos() +slug: Web/JavaScript/Reference/Objets_globaux/Math/acos +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.acos()</strong></code> renvoie l'arc cosinus d'une valeur exprimée en radians. Cela est défini par :</p> + +<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\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</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-acos.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.acos(<em>x</em>) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre (représentant un angle exprimé en radians).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'arc cosinus du nombre passé en argument si celui est compris entre -1 et 1. La méthode renvoie {{jsxref("NaN")}} sinon.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>acos</code> renvoie une valeur numérique comprise entre 0 et Pi pour x compris entre -1 et 1. Si la valeur de <code>x</code> est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.</p> + +<p><code>acos</code> est une méhode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.acos()</code>, elle ne doit pas être appelée depuis un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.acos()">Utiliser <code>Math.acos()</code></h3> + +<pre class="brush: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 +</pre> + +<p>Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, <code>Math.acos</code> renvoie <code>NaN</code>.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.acos")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/acosh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/acosh/index.html new file mode 100644 index 0000000000..3598039002 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/acosh/index.html @@ -0,0 +1,100 @@ +--- +title: Math.acosh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/acosh +tags: + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.acosh()</strong></code> renvoie l'arc cosinus hyperbolique d'un nombre.Elle est définie par :</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-acosh.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.acosh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'arc cosinus hyperbolique du nombre en argument. Si le nombre est inférieur à 1, la valeur renvoyée sera {{jsxref("NaN")}}.</p> + +<h2 id="Description">Description</h2> + +<p><code>acos</code>h étant une méthode statique de <code>Math</code>, il faut l'utiliser avec <code>Math.acosh()</code>, plutôt qu'en faisant appel à une méthode d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.acosh()">Utiliser <code>Math.acosh()</code></h3> + +<pre class="brush:js">Math.acosh(-1); // NaN +Math.acosh(0); // NaN +Math.acosh(0.5); // NaN +Math.acosh(1); // 0 +Math.acosh(2); // 1.3169578969248166</pre> + +<p>Pour les valeurs strictement inférieures à 1 <code>Math.acosh</code> renvoie {{jsxref("NaN")}}.</p> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Pour tout <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>, on peut donc émuler cette fonction avec le code suivant :</p> + +<pre class="brush: js">function acosh(x) { + return Math.log(x + Math.sqrt(x * x - 1)); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.acosh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/asin/index.html b/files/fr/web/javascript/reference/objets_globaux/math/asin/index.html new file mode 100644 index 0000000000..c830fc7b11 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/asin/index.html @@ -0,0 +1,102 @@ +--- +title: Math.asin() +slug: Web/JavaScript/Reference/Objets_globaux/Math/asin +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.asin()</strong></code> renvoie l'arc sinus d'un nombre (en radians). Elle est définie par :</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\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</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-asin.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.asin(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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")}}.</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Math.asin()</code> renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> pour <code>x</code> compris entre -1 et 1. Si <code>x</code> est hors de cet intervalle, la méthode renverra {{jsxref("NaN")}}.</p> + +<p><code>Math.asin()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.asin()</code>, elle ne doit pas être appelée à partir d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.asin()">Utiliser <code>Math.asin()</code></h3> + +<pre class="brush: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</pre> + +<p>Pour les valeurs (strictement) inférieures à -1 ou supérieures à 1, <code>Math.asin()</code> renvoie {{jsxref("NaN")}}.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<div>{{Compat("javascript.builtins.Math.asin")}}</div> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/asinh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/asinh/index.html new file mode 100644 index 0000000000..3d0d55ecad --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/asinh/index.html @@ -0,0 +1,91 @@ +--- +title: Math.asinh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/asinh +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.asinh()</strong></code> renvoie l'arc sinus hyperbolique d'un nombre :</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{ the unique } \; y \; \text{such that} \; \sinh(y) = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-asinh.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.asinh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'arc sinus hyperbolique du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>asinh()</code> étant une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.asinh()</code> et ne doit pas être appelée depuis un autre objet qui aurait été créé (Math n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.asinh()">Utiliser <code>Math.asinh()</code></h3> + +<pre class="brush: js">Math.asinh = Math.asinh || function(x) { + if (x === -Infinity) { + return x; + } else { + return Math.log(x + Math.sqrt(x * x + 1)); + } +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.asinh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/atan/index.html b/files/fr/web/javascript/reference/objets_globaux/math/atan/index.html new file mode 100644 index 0000000000..e7392525ab --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/atan/index.html @@ -0,0 +1,105 @@ +--- +title: Math.atan() +slug: Web/JavaScript/Reference/Objets_globaux/Math/atan +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.atan()</strong></code> renvoie l'arc tangente d'un nombre exprimée en radians. Elle est définie par :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo>le seul<mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\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</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-atan.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.atan(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'arc tangente du nombre passé en argument (exprimé en radians).</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Math.atan()</code> renvoie une valeur numérique comprise entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> et <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math>.</p> + +<p><code>atan()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.atan()</code>, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.atan()">Utiliser <code>Math.atan()</code></h3> + +<pre class="brush:js">Math.atan(1); // 0.7853981633974483 +Math.atan(0); // 0 +Math.atan(-0); // -0 + +Math.atan(Infinity); // 1.5707963267948966 +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); +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<div>{{Compat("javascript.builtins.Math.atan")}}</div> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/atan2/index.html b/files/fr/web/javascript/reference/objets_globaux/math/atan2/index.html new file mode 100644 index 0000000000..3c49ff6ba5 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/atan2/index.html @@ -0,0 +1,113 @@ +--- +title: Math.atan2() +slug: Web/JavaScript/Reference/Objets_globaux/Math/atan2 +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2 +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.atan2()</strong></code> renvoie l'arc tangente du quotient de ses arguments.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-atan2.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.atan2(<var>y</var>, <var>x</var>) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>La coordonnée en abscisse du point.</dd> + <dt><code>y</code></dt> + <dd>La coordonnée en ordonnée du point.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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).</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Math.atan2()</code> 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 (<code>x,y</code>). Attention, le premier argument de la fonction est l'ordonnée (y) et le second est l'abscisse (x).</p> + +<p><img alt="Graphique explicitant l'angle donné par un point de coordonnées X/Y" src="https://mdn.mozillademos.org/files/11565/atan2.png" style="height: 300px; width: 300px;"></p> + +<p><code>Math.atan2()</code> utilise deux arguments <code>x</code> et <code>y</code>, alors que la méthode <code>Math.atan()</code> utilise le ratio de deux nombres comme un seul argument.</p> + +<p><code>atan2()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.atan2()</code>, elle ne doit pas être utilisée comme la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.atan2()">Utiliser <code>Math.atan2()</code></h3> + +<pre class="brush:js">Math.atan2(90, 15); // 1.4056476493802699 +Math.atan2(15, 90); // 0.16514867741462683 + +Math.atan2( ±0, -0 ); // ±PI. +Math.atan2( ±0, +0 ); // ±0. +Math.atan2( ±0, -x ); // ±PI pour x > 0. +Math.atan2( ±0, x ); // ±0 pour x > 0. +Math.atan2( -y, ±0 ); // -PI/2 pour y > 0. +Math.atan2( y, ±0 ); // PI/2 pour y > 0. +Math.atan2( ±y, -Infinity ); // ±PI pour y qui est un nombre fini > 0. +Math.atan2( ±y, +Infinity ); // ±0 pour y qui est un nombre fini > 0. +Math.atan2( ±Infinity, x ); // ±PI/2 pour x qui est un nombre fini. +Math.atan2( ±Infinity, -Infinity ); // ±3*PI/4. +Math.atan2( ±Infinity, +Infinity ); // ±PI/4. +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.atan2")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/atanh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/atanh/index.html new file mode 100644 index 0000000000..ef350947af --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/atanh/index.html @@ -0,0 +1,102 @@ +--- +title: Math.atanh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/atanh +tags: + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.atanh()</strong></code> renvoie l'arc tangente hyperbolique d'un nombre :</p> + +<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mtext> tel que</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\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</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-atanh.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.atanh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'arc tangente hyperbolique du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>atanh()</code> est une méthode statique de <code>Math</code>, il faut utiliser la syntaxe <code>Math.atanh()</code>, et non pas une méthode d'un objet <code>Math</code> créé sur mesure (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.atanh()">Utiliser <code>Math.atanh()</code></h3> + +<pre class="brush: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 +</pre> + +<p>Pour les valeurs strictement inférieures à -1 ou strictement supérieures à 1, {{jsxref("NaN")}} sera renvoyé.</p> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Pour <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo><</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| < 1</annotation></semantics></math>, on a la formule suivante : <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>et on peut donc émuler la fonction avec :</p> + +<pre class="brush: js">Math.atanh = Math.atanh || function(x) { + return Math.log((1+x)/(1-x)) / 2; +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.atanh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/cbrt/index.html b/files/fr/web/javascript/reference/objets_globaux/math/cbrt/index.html new file mode 100644 index 0000000000..fe6c19aa04 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/cbrt/index.html @@ -0,0 +1,91 @@ +--- +title: Math.cbrt() +slug: Web/JavaScript/Reference/Objets_globaux/Math/cbrt +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.cbrt()</strong></code> renvoie la racine cubique (le nom anglais étant <em>cubic root</em>) d'un nombre :</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><mtext>le seul</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cbrt.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.cbrt(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La racine cubique du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>cbrt()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.cbrt()</code>, et non pas la méthode d'un autre objet créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.cbrt()">Utiliser <code>Math.cbrt()</code></h3> + +<pre class="brush:js">Math.cbrt(NaN); // NaN +Math.cbrt(-1); // -1 +Math.cbrt(-0); // -0 +Math.cbrt(-Infinity); // -Infinity +Math.cbrt(0); // 0 +Math.cbrt(1); // 1 +Math.cbrt(Infinity); // Infinity +Math.cbrt(null); // 0 +Math.cbrt(2); // 1.2599210498948732</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES6', '#sec-math.cbrt', 'Math.cbrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.cbrt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/ceil/index.html b/files/fr/web/javascript/reference/objets_globaux/math/ceil/index.html new file mode 100644 index 0000000000..47e1bde9e2 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/ceil/index.html @@ -0,0 +1,177 @@ +--- +title: Math.ceil() +slug: Web/JavaScript/Reference/Objets_globaux/Math/ceil +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.ceil()</strong></code> retourne le plus petit entier supérieur ou égal au nombre donné.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-ceil.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.ceil(<var>x</var>) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le plus petit entier qui est supérieur ou égal au nombre donné.</p> + +<h2 id="Description">Description</h2> + +<p><code>ceil()</code> est une méthode statique de <code>Math</code>. Elle doit être utilisée avec la syntaxe <code>Math.ceil()</code>, plutôt que comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> <code>Math.ceil(null)</code> renverra <code>0</code> et pas {{jsxref("NaN")}}.</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.ceil()">Utiliser <code>Math.ceil()</code></h3> + +<p>Voici un exemple d'utilisation de <code>Math.ceil()</code>.</p> + +<pre class="brush: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</pre> + +<h3 id="Arrondi_décimal">Arrondi décimal</h3> + +<pre class="brush:js">// Fermeture +(function(){ + + /** + * Fonction pour arrondir un nombre. + * + * @param {String} type Le type d'arrondi. + * @param {Number} value Le nombre à arrondir. + * @param {Integer} exp L'exposant (le logarithme en base 10 de la base pour l'arrondi). + * @returns {Number} La valeur arrondie. + */ + function decimalAdjust(type, value, exp) { + // Si l'exposant vaut undefined ou zero... + if (typeof exp === 'undefined' || +exp === 0) { + return Math[type](value); + } + value = +value; + 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)) { + return NaN; + } + // Décalage + value = value.toString().split('e'); + value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp))); + // Re "calage" + value = value.toString().split('e'); + return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)); + } + + // Arrondi décimal + if (!Math.round10) { + Math.round10 = function(value, exp) { + return decimalAdjust('round', value, exp); + }; + } + // Arrondi décimal inférieur + if (!Math.floor10) { + Math.floor10 = function(value, exp) { + return decimalAdjust('floor', value, exp); + }; + } + // Arrondi décimal supérieur + if (!Math.ceil10) { + Math.ceil10 = function(value, exp) { + return decimalAdjust('ceil', value, exp); + }; + } + +})(); + +// Arrondi décimal +Math.round10(55.55, -1); // 55.6 +Math.round10(55.549, -1); // 55.5 +Math.round10(55, 1); // 60 +Math.round10(54.9, 1); // 50 +Math.round10(-55.55, -1); // -55.5 +Math.round10(-55.551, -1); // -55.6 +Math.round10(-55, 1); // -50 +Math.round10(-55.1, 1); // -60 +// Arrondi décimal inférieur +Math.floor10(55.59, -1); // 55.5 +Math.floor10(59, 1); // 50 +Math.floor10(-55.51, -1); // -55.6 +Math.floor10(-51, 1); // -60 +// Arrondi décimal supérieur +Math.ceil10(55.51, -1); // 55.6 +Math.ceil10(51, 1); // 60 +Math.ceil10(-55.59, -1); // -55.5 +Math.ceil10(-59, 1); // -50 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.ceil")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}{</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/clz32/index.html b/files/fr/web/javascript/reference/objets_globaux/math/clz32/index.html new file mode 100644 index 0000000000..e7c28a3865 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/clz32/index.html @@ -0,0 +1,95 @@ +--- +title: Math.clz32() +slug: Web/JavaScript/Reference/Objets_globaux/Math/clz32 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32 +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.clz32()</strong></code> renvoie le nombre de zéros de tête dans la représentation binaire sur 32 bits d'un nombre.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-clz32.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.clz32(<var>x</var>) +</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_retournée">Valeur retournée</h3> + +<p>Le nombre de bits à zéro en tête de la représentation binaire sur 32 bits du nombre donné.</p> + +<h2 id="Description">Description</h2> + +<p>"<code>clz32</code>" est un raccourci pour CountLeadingZeroes32 (en français, « compter les zéros de tête »).</p> + +<p>Si <code>x</code> n'est pas un nombre, il sera d'abord converti en nombre puis converti en un entier non signé sur 32 bits.</p> + +<p>Si l'entier non signé sur 32 bits résultant vaut <code>0</code>, la fonction renverra <code>32</code>, car tous les bits valent <code>0</code>.</p> + +<p>Cette fonction est particulièrement utile aux systèmes qui compilent du code JavaScript, comme <a href="/fr/docs/Emscripten">Emscripten</a>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: js">Math.clz32(1) // 31 +Math.clz32(1000) // 22 +Math.clz32() // 32 + +var liste = [NaN, Infinity, -Infinity, 0, -0, null, undefined, 'machin', {}, []]; +liste.every(n => Math.clz32(n) == 32); // true + +Math.clz32(true) // 31 +Math.clz32(3.5) // 30 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <thead> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaire</th> + </tr> + </thead> + <tbody> + <tr> + <td>{{SpecName('ES2015', '#sec-math.clz32', 'Math.clz32')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.clz32")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math")}}</li> + <li>{{jsxref("Math.imul")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/cos/index.html b/files/fr/web/javascript/reference/objets_globaux/math/cos/index.html new file mode 100644 index 0000000000..3c28ee7fb4 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/cos/index.html @@ -0,0 +1,98 @@ +--- +title: Math.cos() +slug: Web/JavaScript/Reference/Objets_globaux/Math/cos +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.cos()</strong></code> retourne le <a href="https://fr.wikipedia.org/wiki/Cosinus">cosinus</a> d'un angle dont la valeur est exprimée en <a href="https://fr.wikipedia.org/wiki/Radian">radians</a>.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-cos.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.cos(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Une valeur numérique (exprimée en radians).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le cosinus de l'angle fourni en argument (exprimé en radians).</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Math.cos()</code> renvoie une valeur numérique comprise entre -1 et 1. Cela représente la valeur du cosinus de l'angle correspondant à cette valeur.</p> + +<p><code>cos</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.cos()</code>, ne pas utiliser une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.cos()">Utiliser <code>Math.cos()</code></h3> + +<pre class="brush:js">Math.cos(0); // 1 +Math.cos(1); // 0.5403023058681398 + +Math.cos(Math.PI); // -1 +Math.cos(2 * Math.PI); // 1 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.cos")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/cosh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/cosh/index.html new file mode 100644 index 0000000000..99d12d6cf0 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/cosh/index.html @@ -0,0 +1,104 @@ +--- +title: Math.cosh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/cosh +tags: + - ECMAScript6 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.cosh()</strong></code> renvoie le cosinus hyperbolique d'un nombre, défini par :</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-cosh.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<p>(Voir la page sur {{jsxref("Objets_globaux/Math/E","e","",1)}})</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.cosh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le cosinus hyperbolique du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>cosh()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.cosh()</code> et non pas la méthode d'un objet <code>Math</code> créé sur mesure (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.cosh()">Utiliser <code>Math.cosh()</code></h3> + +<pre class="brush:js">Math.cosh(0); // 1 +Math.cosh(1); // 1.5430806348152437 +Math.cosh(-1); // 1.5430806348152437 +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Cette fonction peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + return (Math.exp(x) + Math.exp(-x)) / 2; +}</pre> + +<p>On peut également utiliser un unique appel à {{jsxref("Objets_globaux/Math/exp", "exp()")}} :</p> + +<pre class="brush: js">Math.cosh = Math.cosh || function(x) { + var y = Math.exp(x); + return (y + 1 / y) / 2; +}</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.cosh', 'Math.cosh')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.cosh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/e/index.html b/files/fr/web/javascript/reference/objets_globaux/math/e/index.html new file mode 100644 index 0000000000..0ffd4fff7d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.E +slug: Web/JavaScript/Reference/Objets_globaux/Math/E +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/E +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.E</strong></code> représente la base du logarithme naturel, e, et vaut environ 2.718.</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-e.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>E</code> étant une propriété statique de <code>Math</code>, il doit toujours être utilisé avec la syntaxe <code>Math.E</code>, et non pas être appelé comme propriété d'un autre objet <code>Math</code> qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.E">Utiliser <code>Math.E</code></h3> + +<p>La fonction suivante renvoie la valeur de e :</p> + +<pre class="brush:js">function getNapier() { + return Math.E; +} + +getNapier(); // 2.718281828459045</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.E")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/exp/index.html b/files/fr/web/javascript/reference/objets_globaux/math/exp/index.html new file mode 100644 index 0000000000..62974cdddf --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/exp/index.html @@ -0,0 +1,96 @@ +--- +title: Math.exp() +slug: Web/JavaScript/Reference/Objets_globaux/Math/exp +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.exp()</strong></code> renvoie l'exponentielle d'un nombre (donnée par <code>e<sup>x</sup></code>, où <code>x</code> est la valeur passée en argument et <code>e</code> la valeur du {{jsxref("Objets_globaux/Math/E","nombre d'Euler (parfois appelé constante de Napier)","",1)}}.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-exp.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.exp(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd> + <p>Un nombre.</p> + </dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>L'exponentielle du nombre passé en argument (<code>e<sup>x</sup></code>).</p> + +<h2 id="Description">Description</h2> + +<p><code>exp()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.exp()</code>, elle ne doit pas être utilisée avec un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.exp()">Utiliser <code>Math.exp()</code></h3> + +<pre class="brush:js">Math.exp(-1); // 0.36787944117144233 +Math.exp(0); // 1 +Math.exp(1); // 2.718281828459045</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.exp', 'Math.exp')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.exp")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.expm1()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/expm1/index.html b/files/fr/web/javascript/reference/objets_globaux/math/expm1/index.html new file mode 100644 index 0000000000..daff456379 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/expm1/index.html @@ -0,0 +1,94 @@ +--- +title: Math.expm1() +slug: Web/JavaScript/Reference/Objets_globaux/Math/expm1 +tags: + - ECMAScript6 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1 +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.expm1()</strong></code> renvoie<code> e<sup>x</sup></code> - 1, avec <code>x</code> l'argument donné et {{jsxref("Objets_globaux/Math/E","e")}} la base du logarithme nepérien.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-expm1.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.expm1(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente <code>e<sup>x</sup>- 1</code> où <code>x</code> est la valeur passée en argument et <code>e<sup>x</sup></code> l'exponentielle du nombre.</p> + +<h2 id="Description">Description</h2> + +<p><code>expm1()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.expm1()</code>et non pas la méthode d'un autre objet qui aurait été créé sur mesure (<code>Math </code>n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.expm1()">Utiliser <code>Math.expm1()</code></h3> + +<pre class="brush:js">Math.expm1(-1); // -0.6321205588285577 +Math.expm1(0); // 0 +Math.expm1(1); // 1.718281828459045</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Cette fonction peut être émulée en utilisant la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p> + +<pre class="brush: js">Math.expm1 = Math.expm1 || function(x) { + return Math.exp(x) - 1; +};</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.expm1', 'Math.expm1')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.expm1")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.E")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/floor/index.html b/files/fr/web/javascript/reference/objets_globaux/math/floor/index.html new file mode 100644 index 0000000000..0058ccfe84 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/floor/index.html @@ -0,0 +1,100 @@ +--- +title: Math.floor() +slug: Web/JavaScript/Reference/Objets_globaux/Math/floor +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.floor(x)</strong></code> renvoie le plus grand entier qui est inférieur ou égal à un nombre <code>x</code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-floor.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.floor(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente le plus grand entier inférieur ou égal à la valeur passée en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>floor()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.floor()</code>, elle ne doit pas être utilisée avec un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<div class="blockIndicator note"> +<p><strong>Note :</strong> <code>Math.floor(null)</code> renvoie <code>0</code> et pas {{jsxref("NaN")}}.</p> +</div> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.floor">Utiliser <code>Math.floor</code></h3> + +<pre class="brush: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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.floor', 'Math.floor')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.floor")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/fround/index.html b/files/fr/web/javascript/reference/objets_globaux/math/fround/index.html new file mode 100644 index 0000000000..59ca437b06 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/fround/index.html @@ -0,0 +1,89 @@ +--- +title: Math.fround() +slug: Web/JavaScript/Reference/Objets_globaux/Math/fround +tags: + - ECMAScript6 + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/fround +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.fround()</strong></code> renvoie le nombre flottant à <a class="external" href="https://en.wikipedia.org/wiki/Single_precision" title="link to the wikipedia page on single precision">précision simple</a> sur 32 bits qui est le plus proche du nombre fourni.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-fround.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.fround(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le nombre flottant à précision simple sur 32 bits qui est le plus proche de la valeur fournie en argument.</p> + +<h2 id="Description">Description</h2> + +<p>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.</p> + +<p>Pour résoudre ce problème, on peut utiliser <code>Math.fround()</code> 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 <code>-Infinity</code>.</p> + +<p><code>fround </code>étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>fround</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.fround()">Utiliser <code>Math.fround()</code></h3> + +<pre class="brush: js">Math.fround(0); // 0 +Math.fround(1); // 1 + +// 1.337 ne peut pas être représenté correctement +// sur 32 bits +Math.fround(1.337); // 1.3370000123977661 + +Math.fround(1.5); // 1.5 +Math.fround(NaN); // NaN</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.fround', 'Math.fround')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.fround', 'Math.fround')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.fround")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.round()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/hypot/index.html b/files/fr/web/javascript/reference/objets_globaux/math/hypot/index.html new file mode 100644 index 0000000000..90c6ec6690 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/hypot/index.html @@ -0,0 +1,129 @@ +--- +title: Math.hypot() +slug: Web/JavaScript/Reference/Objets_globaux/Math/hypot +tags: + - ECMAScript6 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.hypot()</strong></code> renvoie la racine carrée de la somme des carrés de ses arguments. On peut également la définir avec la formule suivante :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\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}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-hypot.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.hypot([valeur<var>1</var>[,<var>valeur2</var>, ...]]) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur1, valeur2, ...</code></dt> + <dd>Des nombres.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p><code>hypot()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>hypot</code>()</code>et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<p>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 : <code>Math.hypot(x)</code> sera équivalente à <code>Math.abs(x)</code>.</p> + +<p>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.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.hypot()">Utiliser <code>Math.hypot()</code></h3> + +<pre class="brush: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) // 3, the same as Math.abs(-3) +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :</p> + +<pre class="brush: js">Math.hypot = Math.hypot || function() { + var y = 0; + var length = arguments.length; + + for (var i = 0; i < length; i++) { + if(arguments[i] === Infinity || arguments[i] === -Infinity) { + return Infinity; + } + y += arguments[i] * arguments[i]; + } + return Math.sqrt(y); +}; +</pre> + +<p>Voici une seconde version qui évite les dépassements :</p> + +<pre class="brush: 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) { + var arg = Math.abs(Number(arguments[i])); + if (arg > max) { + s *= (max / arg) * (max / arg); + max = arg; + } + s += arg === 0 && max === 0 ? 0 : (arg / max) * (arg / max); + } + return max === 1 / 0 ? 1 / 0 : max * Math.sqrt(s); +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.hypot")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/imul/index.html b/files/fr/web/javascript/reference/objets_globaux/math/imul/index.html new file mode 100644 index 0000000000..3eb75d949d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/imul/index.html @@ -0,0 +1,93 @@ +--- +title: Math.imul() +slug: Web/JavaScript/Reference/Objets_globaux/Math/imul +tags: + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/imul +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.imul()</strong></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-imul.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.imul(<var>a</var>, <var>b</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>a</code></dt> + <dd>Le premier nombre.</dd> + <dt><code>b</code></dt> + <dd>Le second nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le résultat de la multiplication sur 32 bits des valeurs passées en argument (comme en C).</p> + +<h2 id="Description">Description</h2> + +<p><code>Math.imul()</code> 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 <a href="/fr/docs/Mozilla/Projects/Emscripten">Emscripten</a>. <code>imul() </code>étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>imul</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur). Attention à l'utilisation de nombres flottants avec <code>Math.imul()</code> 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, <code>Math</code><code>.imul()</code> est notamment pertinent pour asm.js.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.imul()">Utiliser <code>Math.imul()</code></h3> + +<pre class="brush: 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 +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Si elle n'est pas disponible, cette fonction peut être émulée de la façon suivante :</p> + +<pre class="brush: 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); +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.imul', 'Math.imul')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.imul', 'Math.imul')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.imul")}}</p> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/index.html b/files/fr/web/javascript/reference/objets_globaux/math/index.html new file mode 100644 index 0000000000..231f165879 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/index.html @@ -0,0 +1,173 @@ +--- +title: Math +slug: Web/JavaScript/Reference/Objets_globaux/Math +tags: + - JavaScript + - Math + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math +--- +<div>{{JSRef}}</div> + +<p>L'objet <strong><code>Math</code></strong> 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.</p> + +<div class="blockIndicator warning"> +<p><strong>Attention !</strong> <code>Math</code> fonctionne avec le type {{jsxref("Number")}}. Il ne fonctionne pas avec les grands entiers/{{jsxref("BigInt")}}.</p> +</div> + +<h2 id="Description">Description</h2> + +<p>Contrairement aux autres objets globaux, <code>Math</code> n'est pas un constructeur. Toutes les propriétés et les méthodes de <code>Math</code> sont statiques (pour éventuellement étendre cette API, ce qui est fortement déconseillé, on n'utilisera donc pas <code>Math.prototype</code>).</p> + +<p>Pour accéder à la constante PI, on utilise <code>Math.PI</code>.<br> + Pour accéder à la fonction <em>sinus</em>, on utilise <code>Math.sin(x)</code> où <code>x</code> est l'argument de cette méthode.</p> + +<p>Les constantes sont définies avec la précision des nombres réels en JavaScript.</p> + +<h2 id="Propriétés">Propriétés</h2> + +<dl> + <dt>{{jsxref("Math.E")}}</dt> + <dd>Nombre d'Euler, la base des logarithmes naturels, environ 2,718.</dd> + <dt>{{jsxref("Math.LN2")}}</dt> + <dd>Logarithme naturel de 2, environ 0,693.</dd> + <dt>{{jsxref("Math.LN10")}}</dt> + <dd>Logarithme naturel de 10, environ 2,302.</dd> + <dt>{{jsxref("Math.LOG2E")}}</dt> + <dd>Logarithme de base 2 de E, environ 1,442.</dd> + <dt>{{jsxref("Math.LOG10E")}}</dt> + <dd>Logarithme de base 10 de E, environ 0,434.</dd> + <dt>{{jsxref("Math.PI")}}</dt> + <dd>Quotient de la circonférence d'un cercle par son diamètre, environ 3,14159.</dd> + <dt>{{jsxref("Math.SQRT1_2")}}</dt> + <dd>Racine carrée de 1/2 ; équivalent de 1 sur la racine carrée de 2, environ 0,707.</dd> + <dt>{{jsxref("Math.SQRT2")}}</dt> + <dd>Racine carrée de 2, environ 1,414.</dd> +</dl> + +<h2 id="Méthodes">Méthodes</h2> + +<div class="note">Les fonctions trigonométriques (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code>, <code>atan2()</code>) acceptent ou retournent des angles en radians.<br> +Pour convertir des degrés en radians, multipliez la valeur en degrés par (<code>Math.PI / 180</code>).<br> +Pour passer des radians en degrés, divisez la valeur en radians par (<code>Math.PI / 180</code>).</div> + +<div class="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.</div> + +<dl> + <dt>{{jsxref("Objets_globaux/Math/abs", "Math.abs(x)")}}</dt> + <dd>Retourne la valeur absolue d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/acos", "Math.acos(x)")}}</dt> + <dd>Retourne l'arc cosinus d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/acosh", "Math.acosh(x)")}}</dt> + <dd>Retourne l'arc cosinus hyperbolique d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/asin", "Math.asin(x)")}}</dt> + <dd>Retourne l'arc sinus d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/asinh", "Math.asinh(x)")}}</dt> + <dd>Retourne l'arc sinus hyperbolique d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/atan", "Math.atan(x)")}}</dt> + <dd>Retourne l'arc tangente d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/atanh", "Math.atanh(x)")}}</dt> + <dd>Retourne l'arc tangente hyperbolique d'un nombre</dd> + <dt>{{jsxref("Objets_globaux/Math/atan2", "Math.atan2(y, x)")}}</dt> + <dd>Retourne l'arc tangente du quotient de ses arguments.</dd> + <dt>{{jsxref("Objets_globaux/Math/cbrt", "Math.cbrt(x)")}}</dt> + <dd>Renvoie la racine cubique d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/ceil", "Math.ceil(x)")}}</dt> + <dd>Retourne le plus petit entier supérieur ou égal à la valeur passée en paramètre.</dd> + <dt>{{jsxref("Objets_globaux/Math/clz32", "Math.clz32(x)")}}</dt> + <dd>Renvoie le nombre de zéros qui préfixent un entier sur 32 bits.</dd> + <dt>{{jsxref("Objets_globaux/Math/cos", "Math.cos(x)")}}</dt> + <dd>Retourne le cosinus d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/cosh", "Math.cosh(x)")}}</dt> + <dd>Renvoie le cosinus hyperbolique d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/exp", "Math.exp(x)")}}</dt> + <dd>Renvoie l'exponentielle d'un nombre (soit E<sup>nombre</sup>) avec E la constante d'Euler (2,718...).</dd> + <dt>{{jsxref("Objets_globaux/Math/expm1", "Math.expm1(x)")}}</dt> + <dd>Renvoie le résultat de 1 moins l'exponentielle d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/floor", "Math.floor(x)")}}</dt> + <dd>Retourne le plus grand entier inférieur ou égal à la valeur passée en paramètre.</dd> + <dt>{{jsxref("Objets_globaux/Math/fround", "Math.fround(x)")}}</dt> + <dd>Renvoie le nombre flottant exprimé sur 32 bits le plus proche de l'argument.</dd> + <dt>{{jsxref("Objets_globaux/Math/hypot", "Math.hypot([x[,y[,…]]])")}}</dt> + <dd>Retourne la racine carré de la somme des carrés des arguments.</dd> + <dt>{{jsxref("Objets_globaux/Math/imul", "Math.imul(x, y)")}}</dt> + <dd>Retourne le résultat de la multiplication d'entiers sur 32 bits.</dd> + <dt>{{jsxref("Objets_globaux/Math/log", "Math.log(x)")}}</dt> + <dd>Retourne le logarithme naturel (log<sub>e</sub>) d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/log1p", "Math.log1p(x)")}}</dt> + <dd>Retourne le logarithme naturel de 1 + un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/log10", "Math.log10(x)")}}</dt> + <dd>Retourne le logarithme en base 10 d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/log2", "Math.log2(x)")}}</dt> + <dd>Retourne le logarithme en base 2 d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/max", "Math.max([x[,y[,…]]])")}}</dt> + <dd>Retourne la plus grande valeur d'une liste de nombres.</dd> + <dt>{{jsxref("Objets_globaux/Math/min", "Math.min([x[,y[,…]]])")}}</dt> + <dd>Retourne la plus petite valeur d'une liste de nombres.</dd> + <dt>{{jsxref("Objets_globaux/Math/pow", "Math.pow(x,y)")}}</dt> + <dd>Retourne le calcul de x à la puissance y (x correspond à la base et y à l'exposant).</dd> + <dt>{{jsxref("Objets_globaux/Math/random", "Math.random()")}}</dt> + <dd>Retourne un nombre pseudo-aléatoire compris entre 0 (inclus) et 1 (exclu).</dd> + <dt>{{jsxref("Objets_globaux/Math/round", "Math.round(x)")}}</dt> + <dd>Retourne l'arrondi d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/sign", "Math.sign(x)")}}</dt> + <dd>Retourne le signe d'un nombre, indiquant s'il est positif, négatif ou égal à zéro.</dd> + <dt>{{jsxref("Objets_globaux/Math/sin", "Math.sin(x)")}}</dt> + <dd>Retourne le sinus d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/sinh", "Math.sinh(x)")}}</dt> + <dd>Retourne le sinus hyperbolique d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/sqrt", "Math.sqrt(x)")}}</dt> + <dd>Retourne la racine carrée d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/tan", "Math.tan(x)")}}</dt> + <dd>Retourne la tangente d'un nombre.</dd> + <dt>{{jsxref("Objets_globaux/Math/tanh", "Math.tanh(x)")}}</dt> + <dd>Retourne la tangente hyperbolique d'un nombre</dd> + <dt><code>Math.toSource()</code> {{Non-standard_inline}}</dt> + <dd>Renvoie la chaîne de caractères <code>"Math"</code>.</dd> + <dt>{{jsxref("Objets_globaux/Math/trunc", "Math.trunc(x)")}}</dt> + <dd>Retourne la partie entière d'un nombre (la partie décimale est retirée).</dd> +</dl> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.1</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8', 'Math')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>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()")}}.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math-object', 'Math')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/ln10/index.html b/files/fr/web/javascript/reference/objets_globaux/math/ln10/index.html new file mode 100644 index 0000000000..e9eae9acc2 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/ln10/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN10 +slug: Web/JavaScript/Reference/Objets_globaux/Math/LN10 +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10 +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.LN10</strong></code> représente la valeur du logarithme naturel de 10, environ 2.302 :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-ln10.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>LN10</code> est une propriété statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.LN10</code>, et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.LN10">Utiliser <code>Math.LN10</code></h3> + +<p>La fonction suivante renvoie le logarithme naturel de 10 :</p> + +<pre class="brush:js">function getNatLog10() { + return Math.LN10; +} + +getNatLog10(); // 2.302585092994046</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.LN10")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/ln2/index.html b/files/fr/web/javascript/reference/objets_globaux/math/ln2/index.html new file mode 100644 index 0000000000..89db2712fd --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/ln2/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LN2 +slug: Web/JavaScript/Reference/Objets_globaux/Math/LN2 +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2 +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.LN2</strong></code> représente le logarithme naturel de 2, environ 0.693:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-ln2.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>LN2</code> est une propriété statique de l'objet <code>Math</code>, il doit toujours être utilisé avec la syntaxe <code>Math.LN2</code>, et non pas être utilisé comme la propriété d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.LN2">Utiliser <code>Math.LN2</code></h3> + +<p>La fonction suivante renvoie le logarithme en base 2 d'un nombre en utilisant la valeur de <code>Math.LN2</code> :</p> + +<pre class="brush:js">function getLog2(x) { + return Math.log(x) / Math.LN2; +} + +getLog2(256); // 8</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.LN2")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log/index.html new file mode 100644 index 0000000000..177215b74b --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log/index.html @@ -0,0 +1,107 @@ +--- +title: Math.log() +slug: Web/JavaScript/Reference/Objets_globaux/Math/log +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.log()</strong></code> renvoie le logarithme naturel (aussi appelé logarithme népérien) d'un nombre, défini par :</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>le seul </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.log(<em>x</em>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le logarithme naturelle de la valeur passée en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui est renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p>Si la valeur de l'argument est négative, la valeur renvoyée sera {{jsxref("NaN")}}. Si la valeur de l'argument est <code>0</code>, la valeur de retour sera {{jsxref("Number.NEGATIVE_INFINITY", "-Infinity")}}.</p> + +<p><code>log()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.log()</code>, elle ne doit pas être utilisée à partir d'un autre objet qui aurait été créé (<code>Math</code> 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()")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.log()">Utiliser <code>Math.log()</code></h3> + +<pre class="brush: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</pre> + +<h3 id="Utiliser_Math.log_pour_construire_un_logarithme_sur_une_autre_base">Utiliser <code>Math.log</code> pour construire un logarithme sur une autre base</h3> + +<p>La fonction suivante renvoie le logarithme de <code>y</code> en base <code>x</code> (c'est-à-dire log<sub>x</sub> y):</p> + +<pre class="brush:js">function getBaseLog(x, y) { + return Math.log(y) / Math.log(x); +}</pre> + +<p>Si on exécute <code>getBaseLog(10, 1000)</code>, on obtiendra <code>2.9999999999999996</code> en raison de l'arrondi du à la représentation en nombre flottant (le résultat exact étant 3).</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.log")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log10/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log10/index.html new file mode 100644 index 0000000000..724247091b --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log10/index.html @@ -0,0 +1,100 @@ +--- +title: Math.log10() +slug: Web/JavaScript/Reference/Objets_globaux/Math/log10 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10 +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.log10()</strong></code> renvoie le logarithme en base 10 d'un nombre, donné par la formule :</p> + +<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique </mtext><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log10.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.log10(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le logarithme en base 10 du nombre passé en argument. Si cette valeur est négative, c'est {{jsxref("NaN")}} qui sera renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p>Si la valeur de l'argument est strictement inférieure à 0, la valeur renvoyée à {{jsxref("NaN")}}.</p> + +<p><code>log10()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log10</code>()</code>et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur). Cette fonction est équivalente à la fonction donnée par <code>Math.log(x) / Math.log(10)</code>.</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.log10()">Utiliser <code>Math.log10()</code></h3> + +<pre class="brush:js">Math.log10(2); // 0.3010299956639812 +Math.log10(1); // 0 +Math.log10(0); // -Infinity +Math.log10(-2); // NaN +Math.log10(100000); // 5 +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Il est possible d'avoir un résultat approximatif avec la fonction suivante :</p> + +<pre class="brush: js">Math.log10 = Math.log10 || function(x) { + return Math.log(x) * Math.LOG10E; +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.log10', 'Math.log10')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.log10")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log10e/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log10e/index.html new file mode 100644 index 0000000000..7ea27eefbc --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log10e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LOG10E +slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG10E +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.LOG10E</strong></code> fournit la valeur du logarithme en base 10 de e, environ 0.434 :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log10e.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>LOG10E</code> étant une propriété statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.LOG10E</code> et ne pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.LOG10E">Utiliser <code>Math.LOG10E</code></h3> + +<p>La fonction suivante renvoie le logarithme en base 10 de e :</p> + +<pre class="brush:js">function getLog10e() { + return Math.LOG10E; +} + +getLog10e(); // 0.4342944819032518</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.LOG10E")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log1p/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log1p/index.html new file mode 100644 index 0000000000..b209a76043 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log1p/index.html @@ -0,0 +1,99 @@ +--- +title: Math.log1p() +slug: Web/JavaScript/Reference/Objets_globaux/Math/log1p +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.log1p()</strong></code> renvoie le logarithme népérien (en base {{jsxref("Math/E","e")}}) d'un nombre +1, donné par la formule :</p> + +<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x > -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log1p.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.log1p(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur du logarithme naturel de 1 plus l'argument (<code>log(1 + x</code>)). Si l'argument est inférieur à <code>-1</code>, {{jsxref("NaN")}} est renvoyée.</p> + +<h2 id="Description">Description</h2> + +<p>Si <code>x</code> est strictement inférieur à -1, la valeur renvoyée est {{jsxref("NaN")}}.</p> + +<p><code>log1p</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log1p</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.log1p()">Utiliser <code>Math.log1p()</code></h3> + +<pre class="brush:js">Math.log1p(1); // 0.6931471805599453 +Math.log1p(0); // 0 +Math.log1p(-1); // -Infinity +Math.log1p(-2); // NaN +</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Si cette fonction n'est pas disponible, elle peut être définie grâce au code suivant :</p> + +<pre class="brush: js">Math.log1p = Math.log1p || function(x) { + return Math.log(1 + x); +}; +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.log1p', 'Math.log1p')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.log1p")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log2/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log2/index.html new file mode 100644 index 0000000000..0b11603a85 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log2/index.html @@ -0,0 +1,92 @@ +--- +title: Math.log2() +slug: Web/JavaScript/Reference/Objets_globaux/Math/log2 +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2 +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.log2()</strong></code> renvoie le logarithme en base 2 d'un nombre :</p> + +<p><math><semantics><mrow><mo>∀</mo><mi>x</mi><mo>></mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>l'unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x > 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log2.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.log2(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le logarithme en base 2 du nombre passé en argument. Si ce nombre est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p>Si <code>x</code> est strictement inférieur à 0, la valeur renvoyée sera {{jsxref("NaN")}}.</p> + +<p><code>log2()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>log2</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur). Si on souhaite utiliser des constantes, on pourra employer {{jsxref("Math.LOG2E")}} ou {{jsxref("Math.LN2")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.log2()">Utiliser <code>Math.log2()</code></h3> + +<pre class="brush: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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.log2', 'Math.log2')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.log2")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log10()")}}</li> + <li>{{jsxref("Math.log1p()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/log2e/index.html b/files/fr/web/javascript/reference/objets_globaux/math/log2e/index.html new file mode 100644 index 0000000000..dffc8423da --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/log2e/index.html @@ -0,0 +1,83 @@ +--- +title: Math.LOG2E +slug: Web/JavaScript/Reference/Objets_globaux/Math/LOG2E +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.LOG2E</strong></code> représente la valeur du logarithme en base 2 de e, environ 1.442 :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-log2e.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>LOG2E</code> est une propriété statique de l'objet <code>Math</code> et doit toujours être utilisé avec la syntaxe <code>Math.LOG2E</code> plutôt que comme la propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.LOG2E">Utiliser <code>Math.LOG2E</code></h3> + +<p>La fonction suivante renvoie la valeur du logarithme en base 2 de e :</p> + +<pre class="brush:js">function getLog2e() { + return Math.LOG2E; +} + +getLog2e(); // 1.4426950408889634</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.LOG2E")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.log2()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/max/index.html b/files/fr/web/javascript/reference/objets_globaux/math/max/index.html new file mode 100644 index 0000000000..1964058b9b --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/max/index.html @@ -0,0 +1,115 @@ +--- +title: Math.max() +slug: Web/JavaScript/Reference/Objets_globaux/Math/max +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/max +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.max()</strong></code> renvoie le plus grand nombre d'une série de 0 ou plusieurs nombres.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-max.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.max([<var>valeur1</var>[,<var>valeur2</var>, ...]]) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur1, valeur2, ...</code></dt> + <dd>Des nombres.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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é.</p> + +<h2 id="Description">Description</h2> + +<p><code>max()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.max()</code>, elle ne doit pas être appelée comme la méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<p>Si aucun argument n'est fourni, le résultat sera -{{jsxref("Infinity")}}.</p> + +<p>Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.max()">Utiliser <code>Math.max()</code></h3> + +<pre class="brush: js">Math.max(10, 20); // 20 +Math.max(-10, -20); // -10 +Math.max(-10, 20); // 20 +</pre> + +<h3 id="Obtenir_l'élément_maximum_d'un_tableau">Obtenir l'élément maximum d'un tableau</h3> + +<p>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 :</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = arr.reduce(function(a,b) { + return Math.max(a, b); +});</pre> + +<p>On peut également utiliser {{jsxref("Function.prototype.apply()")}} afin de trouver le maximum parmi un tableau de nombres. <code>getMaxTableau([1,2,3])</code> sera équivalent à <code>Math.max(1, 2, 3)</code>, mais <code>getMaxTableau</code> pourra être utilisé sur des tableaux de n'importe quelle taille.</p> + +<pre class="brush:js">function getMaxTableau(tableauNumérique) { + return Math.max.apply(null, tableauNumérique); +}</pre> + +<p>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 :</p> + +<pre class="brush: js">var arr = [1, 2, 3]; +var max = Math.max(...arr);</pre> + +<p>Attention avec la décomposition et <code>apply()</code> 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 <a href="/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply#Utiliser_apply_et_des_fonctions_natives">Utiliser apply() et les fonctions natives</a>. La méthode proposée avec <code>reduce()</code> n'a pas cette contrainte.</p> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.11', 'Math.max')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.max', 'Math.max')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.max")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.min()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/min/index.html b/files/fr/web/javascript/reference/objets_globaux/math/min/index.html new file mode 100644 index 0000000000..321548364d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/min/index.html @@ -0,0 +1,111 @@ +--- +title: Math.min() +slug: Web/JavaScript/Reference/Objets_globaux/Math/min +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/min +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.min()</strong></code> 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.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-min.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.min([<var>valeur1</var>[,<var>valeur2</var>, ...]]) </pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>valeur1, valeur2, ...</code></dt> + <dd>Des nombres.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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.</p> + +<h2 id="Description">Description</h2> + +<p><code>min()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.min()</code> et ne doit pas être utilisée comme la méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<p>Si aucun argument n'est fourni, le résultat renvoyé par la fonction sera {{jsxref("Infinity")}}.</p> + +<p>Si au moins un des arguments ne peut pas être converti en un nombre, le résultat sera {{jsxref("NaN")}}.</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.min()">Utiliser <code>Math.min()</code></h3> + +<p>Dans cet exemple, on trouve le minimum de x et y et on affecte cette valeur à z :</p> + +<pre class="brush:js">var x = 10, y = -20; +var z = Math.min(x, y); +</pre> + +<h3 id="Ramener_une_valeur_dans_un_intervalle_(clipping)_avec_Math.min()">Ramener une valeur dans un intervalle (<em>clipping</em>) avec <code>Math.min()</code></h3> + +<p><code>Math.min()</code> est souvent utilisée afin de ramener une certaine valeur dans un intervalle donné. Par exemple :</p> + +<pre class="brush:js">var x = f(toto); + +if (x > limite) { + x = limite; +} +</pre> + +<p>peut s'écrire</p> + +<pre class="brush:js">var x = Math.min(f(toto), limite);</pre> + +<div>{{jsxref("Math.max()")}} peut être utilisée de façon semblable pour ramener une valeur vers un minimum d'un intervalle donné.</div> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.min")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.max()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/pi/index.html b/files/fr/web/javascript/reference/objets_globaux/math/pi/index.html new file mode 100644 index 0000000000..1afe5afc3a --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/pi/index.html @@ -0,0 +1,81 @@ +--- +title: Math.PI +slug: Web/JavaScript/Reference/Objets_globaux/Math/PI +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.PI</strong></code> représente le ratio entre le périmètre d'un cercle et son diamètre. Elle vaut environ 3.14159:</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-pi.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>PI</code> est une propriété statique de l'objet <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.PI</code> plutôt que d'être appelée comme la propriété d'un autre objet qui aurait été crée (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.PI">Utiliser <code>Math.PI</code></h3> + +<p>La fonction suivante utilise <code>Math.PI</code> afin de calculer le périmètre d'un cercle à partir du rayon passé en argument.</p> + +<pre class="brush:js">function calculPérimètre(rayon) { + return 2 * Math.PI * rayon; +} + +calculPérimètre(1); // 6.283185307179586</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.PI")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/pow/index.html b/files/fr/web/javascript/reference/objets_globaux/math/pow/index.html new file mode 100644 index 0000000000..c7d08031b1 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/pow/index.html @@ -0,0 +1,106 @@ +--- +title: Math.pow() +slug: Web/JavaScript/Reference/Objets_globaux/Math/pow +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.pow()</strong></code> renvoie un nombre à une certaine puissance, c'est-à-dire <code>base<sup>exposant</sup></code>.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-pow.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.pow(<var>base</var>, <var>exposant</var>);</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>base</code></dt> + <dd>Le nombre correspondant à la base.</dd> + <dt><code>exponent</code></dt> + <dd>L'exposant auquel on élève le paramètre précédent.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre qui représente un nombre (premier argument) élevé à une puissance donné (second argument).</p> + +<h2 id="Description">Description</h2> + +<p><code>pow()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.pow()</code>, elle ne doit pas être utilisée comme une méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemple">Exemple</h2> + +<h3 id="Utiliser_Math.pow()">Utiliser <code>Math.pow()</code></h3> + +<pre class="brush:js">// Utilisation simple +Math.pow(7, 2); // 49 + +// Exposants négatifs +Math.pow(7, -2); // 0.02040816326530612 (1/49) + +// Exposants fractionnaires +Math.pow(2, 1/2); // 1.4142135623730951 (racine carrée de 2) + +// Cas aux limites +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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.pow', 'Math.pow')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.pow")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> + <li><a href="/fr/docs/Web/JavaScript/Reference/Opérateurs/Opérateurs_arithmétiques#Exponentiation_(**)">Opérateur d'exponentiation</a> {{experimental_inline}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/random/index.html b/files/fr/web/javascript/reference/objets_globaux/math/random/index.html new file mode 100644 index 0000000000..880f6ee69e --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/random/index.html @@ -0,0 +1,114 @@ +--- +title: Math.random() +slug: Web/JavaScript/Reference/Objets_globaux/Math/random +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/random +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.random()</strong></code> renvoie un nombre flottant pseudo-aléatoire compris dans l'intervalle <code>[0, 1[</code> (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 (<em>seed</em>) du générateur est choisie par l'algorithme et ne peut pas être choisie ou réinitialisée par l'utilisateur.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-random.html")}}</div> + +<div class="note"> +<p><strong>Note :</strong> <code>Math.random()</code> <strong>ne fournit pas</strong> 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()")}}.</p> +</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox notranslate">Math.random()</pre> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Un nombre flottant pseudo-aléatoire, généré entre 0 (inclus) et 1 (exclu)</p> + +<h2 id="Exemples">Exemples</h2> + +<p>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 <code>Math.random()</code>) ne sont pas théoriquement et précisément exacts. Si on utilise des bornes supérieures très grande (2<sup>53</sup> 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.</p> + +<h3 id="Obtenir_un_nombre_aléatoire_entre_0_et_1">Obtenir un nombre aléatoire entre 0 et 1</h3> + +<pre class="brush: js notranslate">// On renvoie un nombre aléatoire entre 0 (inclus) et 1 (exclus) +function getRandom() { + return Math.random(); +}</pre> + +<h3 id="Obtenir_un_nombre_aléatoire_dans_un_intervalle">Obtenir un nombre aléatoire dans un intervalle</h3> + +<pre class="brush: js notranslate">// 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; +}</pre> + +<h3 id="Obtenir_un_entier_aléatoire_dans_un_intervalle_ouvert_à_droite">Obtenir un entier aléatoire dans un intervalle ouvert à droite</h3> + +<pre class="brush: js notranslate">// On renvoie un entier aléatoire entre une valeur min (incluse) +// et une valeur max (exclue). +// Attention : si on utilisait Math.round(), on aurait une distribution +// non uniforme ! +function getRandomInt(min, max) { + min = Math.ceil(min); + max = Math.floor(max); + return Math.floor(Math.random() * (max - min)) + min; +} +</pre> + +<div class="warning"> +<p><strong>Attention !</strong> Utiliser <code>Math.round()</code> entraînerait une distribution non-uniforme et réduirait le caractère aléatoire de la méthode.</p> +</div> + +<h3 id="Obtenir_un_entier_aléatoire_dans_un_intervalle_fermé">Obtenir un entier aléatoire dans un intervalle fermé</h3> + +<pre class="brush: js notranslate">// On renvoie un entier aléatoire entre une valeur min (incluse) +// et une valeur max (incluse). +// Attention : si on utilisait Math.round(), on aurait une distribution +// non uniforme ! +function getRandomIntInclusive(min, max) { + min = Math.ceil(min); + max = Math.floor(max); + return Math.floor(Math.random() * (max - min +1)) + min; +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0 (UNIX) et 1.1 (toutes plateformes).</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.random', 'Math.random')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.random")}}</p> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/round/index.html b/files/fr/web/javascript/reference/objets_globaux/math/round/index.html new file mode 100644 index 0000000000..981e6cb665 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/round/index.html @@ -0,0 +1,97 @@ +--- +title: Math.round() +slug: Web/JavaScript/Reference/Objets_globaux/Math/round +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/round +--- +<div>{{JSRef}}</div> + +<p>La fonction <strong><code>Math.round()</code></strong> retourne la valeur d'un nombre arrondi à l'entier le plus proche.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-round.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.round(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La valeur de l'entier le plus proche du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p>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).</p> + +<p><code>round()</code> étant une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.round()</code>, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: 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 +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</td> + <td>{{Spec2('ES6')}}</td> + <td></td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.round', 'Math.round')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.round")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Number.toPrecision()")}}</li> + <li>{{jsxref("Number.toFixed()")}}</li> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sign/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sign/index.html new file mode 100644 index 0000000000..8a1c941e66 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sign/index.html @@ -0,0 +1,92 @@ +--- +title: Math.sign() +slug: Web/JavaScript/Reference/Objets_globaux/Math/sign +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.sign()</strong></code> renvoie le signe d'un nombre et permet de savoir si un nombre est positif, négatif ou nul.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-sign.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.sign(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>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 <code>1</code>, <code>-1</code>, <code>0</code>, <code>-0</code>. Sinon, ce sera {{jsxref("NaN")}} qui sera renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p><code>sign()</code> étant une méthode statique de <code>Math</code>, il faut utiliser <code>Math.<code>sign</code>()</code> et non pas la méthode d'un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur).</p> + +<p>Cette fonction peut renvoyer 5 valeurs : <code>1, -1, 0, -0, NaN,</code> qui indiquent respectivement que <code>x</code> 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")}}.</p> + +<p>L'argument passé à cette fonction sera implicitement converti au type <code>number</code>.</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">Math.sign(3) // 1 +Math.sign(-3) // -1 +Math.sign("-3") // -1 +Math.sign(0) // 0 +Math.sign(-0) // -0 +Math.sign(NaN) // NaN +Math.sign("foo") // NaN +Math.sign() // NaN +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ES6')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.sign")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.trunc()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sin/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sin/index.html new file mode 100644 index 0000000000..c9ea4850ac --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sin/index.html @@ -0,0 +1,94 @@ +--- +title: Math.sin() +slug: Web/JavaScript/Reference/Objets_globaux/Math/sin +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.sin()</strong></code> renvoie le sinus d'un nombre.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-sin.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.sin(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre (qui exprime un angle en radians).</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le sinus de la valeur passée en argument (qui correspond à un angle en radians).</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>sin()</code> 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.</p> + +<p><code>sin()</code> est une méthode statique de <code>Math</code>, elle doit être utilisée avec la syntaxe <code>Math.sin()</code>, elle ne doit pas être utilisée comme une méthode d'un objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">Math.sin(0); // 0 +Math.sin(1); // 0.8414709848078965 + +Math.sin(Math.PI / 2); // 1</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.sin")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.tan()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sinh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sinh/index.html new file mode 100644 index 0000000000..33c5813d67 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sinh/index.html @@ -0,0 +1,98 @@ +--- +title: Math.sinh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/sinh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.sinh()</strong></code> renvoie le sinus hyperbolique d'un nombre, dont la formule, utilisant la constante {{jsxref("Math.E","e")}}, est :</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sinh.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.sinh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>Le sinus hyperbolique de la valeur passée en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>sinh()</code> est une méthode statique de <code>Math</code>, il faut utiliser la syntaxe <code>Math.<code>sinh</code>()</code>. Cette méthode ne doit pas être appelée depuis un autre objet qui aurait été créé (<code>Math </code>n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush:js">Math.sinh(0) // 0 +Math.sinh(1) // 1.1752011936438014</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Si cette fonction n'est pas disponible, elle peut être émulée en utilisant la fonction {{jsxref("Math.exp()")}}<code> :</code></p> + +<pre class="brush: js language-js">Math.sinh = Math.sinh || function(x){ + return (Math.exp(x) - Math.exp(-x)) / 2; +};</pre> + +<p>ou encore, si on n'utilise qu'une fois {{jsxref("Math.exp()")}}, avec :</p> + +<pre class="brush: js">Math.sinh = Math.sinh || function(x){ + var y = Math.exp(x); + return (y - 1/y) / 2; +};</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.sinh', 'Math.sinh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.sinh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.tanh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sqrt/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sqrt/index.html new file mode 100644 index 0000000000..1a95e53caa --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sqrt/index.html @@ -0,0 +1,97 @@ +--- +title: Math.sqrt() +slug: Web/JavaScript/Reference/Objets_globaux/Math/sqrt +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.sqrt()</strong></code> renvoie la racine carrée d'un nombre. Cette fonction est définie par :</p> + +<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>s</mi><mi>q</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mi>x</mi></msqrt><mo>=</mo><mtext>l'unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>tel que</mtext><mspace width="thickmathspace"></mspace><msup><mi>y</mi><mn>2</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 0, \mathtt{Math.sqrt(x)} = \sqrt{x} = \text{the unique} \; y \geq 0 \; \text{such that} \; y^2 = x</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.sqrt(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La racine carrée du nombre passé en argument. Si le nombre fourni est négatif, c'est {{jsxref("NaN")}} qui sera renvoyé.</p> + +<h2 id="Description">Description</h2> + +<p>Si la valeur de <code>x</code> est négative, <code>sqrt</code> renverra {{jsxref("NaN")}}.</p> + +<p><code>sqrt()</code> est une méthode statique de <code>Math</code>, elle doit être utilisée avec la syntaxe <code>Math.sqrt()</code>, elle ne doit pas être appelée comme méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<pre class="brush: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</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt', 'Math.sqrt')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.sqrt")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.cbrt()")}}</li> + <li>{{jsxref("Math.exp()")}}</li> + <li>{{jsxref("Math.log()")}}</li> + <li>{{jsxref("Math.pow()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sqrt1_2/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sqrt1_2/index.html new file mode 100644 index 0000000000..b845ac3389 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sqrt1_2/index.html @@ -0,0 +1,80 @@ +--- +title: Math.SQRT1_2 +slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT1_2 +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2 +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.SQRT1_2</strong></code> représente la racine carrée d'1/2 et vaut environ 0.707 :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt1_2.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>SQRT1_2</code> est une propriété statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.SQRT1_2</code>. Elle ne doit pas être obtenue à partir d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La fonction suivante renvoie la valeur de cette constante :</p> + +<pre class="brush:js">function getRoot1_2() { + return Math.SQRT1_2; +} + +getRoot1_2(); // 0.7071067811865476</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.SQRT1_2")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/sqrt2/index.html b/files/fr/web/javascript/reference/objets_globaux/math/sqrt2/index.html new file mode 100644 index 0000000000..7a02b16e2d --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/sqrt2/index.html @@ -0,0 +1,80 @@ +--- +title: Math.SQRT2 +slug: Web/JavaScript/Reference/Objets_globaux/Math/SQRT2 +tags: + - JavaScript + - Math + - Propriété + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2 +--- +<div>{{JSRef}}</div> + +<p>La propriété <code><strong>Math.SQRT2</strong></code> représente la racine carrée de 2 et vaut environ 1.414 :</p> + +<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-sqrt2.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<div>{{js_property_attributes(0,0,0)}}</div> + +<h2 id="Description">Description</h2> + +<p><code>SQRT2</code> est une propriété statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.SQRT2</code>, elle ne doit pas être appelée comme propriété d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<p>La fonction suivante renvoie la valeur de la racine carrée de 2 :</p> + +<pre class="brush:js">function getRoot2() { + return Math.SQRT2; +} + +getRoot2(); // 1.4142135623730951</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">Statut</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.SQRT2")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.pow()")}}</li> + <li>{{jsxref("Math.sqrt()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/tan/index.html b/files/fr/web/javascript/reference/objets_globaux/math/tan/index.html new file mode 100644 index 0000000000..948ea10a14 --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/tan/index.html @@ -0,0 +1,101 @@ +--- +title: Math.tan() +slug: Web/JavaScript/Reference/Objets_globaux/Math/tan +tags: + - JavaScript + - Math + - Méthode + - Reference +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.tan()</strong></code> renvoie la tangente d'un nombre exprimant un angle en radians.</p> + +<div>{{EmbedInteractiveExample("pages/js/math-tan.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.tan(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre qui représente un angle en radians.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La tangente de l'angle fourni en argument (exprimé en radians).</p> + +<h2 id="Description">Description</h2> + +<p>La méthode <code>Math.tan()</code> renvoie une valeur numérique qui représente la tangente d'un angle.</p> + +<p><code>tan()</code> est une méthode statique de <code>Math</code> et doit toujours être utilisée avec la syntaxe <code>Math.tan()</code>, elle ne doit pas être utilisée comme méthode d'un autre objet qui aurait été créé (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.tan()">Utiliser <code>Math.tan()</code></h3> + +<pre class="brush:js">Math.tan(1); // 1.5574077246549023</pre> + +<p><code>Math.tan()</code> 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 :</p> + +<pre class="brush:js">function getTanDeg(deg) { + var rad = deg * Math.PI/180; + return Math.tan(rad); +} +</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES1')}}</td> + <td>{{Spec2('ES1')}}</td> + <td>Définition initiale. Implémentée avec JavaScript 1.0.</td> + </tr> + <tr> + <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td> + <td>{{Spec2('ES5.1')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</td> + <td>{{Spec2('ES6')}}</td> + <td> </td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.tan', 'Math.tan')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.tan")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acos()")}}</li> + <li>{{jsxref("Math.asin()")}}</li> + <li>{{jsxref("Math.atan()")}}</li> + <li>{{jsxref("Math.atan2()")}}</li> + <li>{{jsxref("Math.cos()")}}</li> + <li>{{jsxref("Math.sin()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/tanh/index.html b/files/fr/web/javascript/reference/objets_globaux/math/tanh/index.html new file mode 100644 index 0000000000..0567a5430c --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/tanh/index.html @@ -0,0 +1,106 @@ +--- +title: Math.tanh() +slug: Web/JavaScript/Reference/Objets_globaux/Math/tanh +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.tanh()</strong></code> renvoie la tangente hyperbolique d'un nombre définie par :</p> + +<p><math><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-tanh.html")}}</div> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.tanh(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La tangente hyperbolique du nombre fourni en argument.</p> + +<h2 id="Description">Description</h2> + +<p><code>tanh()</code> est une méthode statique de l'objet <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.tanh()</code>, elle ne doit pas être utilisée comme une méthode d'un objet <code>Math</code> qui aurait été instancié (<code>Math</code> n'est pas une constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.tanh()">Utiliser <code>Math.tanh()</code></h3> + +<pre class="brush:js">Math.tanh(0); // 0 +Math.tanh(Infinity); // 1 +Math.tanh(1); // 0.7615941559557649</pre> + +<h2 id="Prothèse_d'émulation_(polyfill)">Prothèse d'émulation (<em>polyfill</em>)</h2> + +<p>Cette méthode peut être émulée grâce à la fonction {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}} :</p> + +<pre class="brush: 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); +}</pre> + +<p>et si on souhaite n'utiliser qu'un seul appel à {{jsxref("Objets_globaux/Math/exp", "Math.exp()")}}<code> :</code></p> + +<pre class="brush: js">Math.tanhx = Math.tanhx || function(x) { + if(x === Infinity) { + return 1; + } else if(x === -Infinity) { + return -1; + } else { + var y = Math.exp(2 * x); + return (y - 1) / (y + 1); + } +};</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaires</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Définition initiale.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td> </td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.tanh")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.acosh()")}}</li> + <li>{{jsxref("Math.asinh()")}}</li> + <li>{{jsxref("Math.atanh()")}}</li> + <li>{{jsxref("Math.cosh()")}}</li> + <li>{{jsxref("Math.sinh()")}}</li> +</ul> diff --git a/files/fr/web/javascript/reference/objets_globaux/math/trunc/index.html b/files/fr/web/javascript/reference/objets_globaux/math/trunc/index.html new file mode 100644 index 0000000000..beb1f33d0b --- /dev/null +++ b/files/fr/web/javascript/reference/objets_globaux/math/trunc/index.html @@ -0,0 +1,97 @@ +--- +title: Math.trunc() +slug: Web/JavaScript/Reference/Objets_globaux/Math/trunc +tags: + - ECMAScript 2015 + - JavaScript + - Math + - Méthode + - Reference + - polyfill +translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc +--- +<div>{{JSRef}}</div> + +<p>La fonction <code><strong>Math.trunc()</strong></code> retourne la troncature entière d'un nombre en retirant sa partie décimale.</p> + +<p><math><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.trunc</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mrow><mo>⌊</mo><mi>x</mi><mo>⌋</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo>≥</mo><mn>0</mn></mtd></mtr><mtr><mtd><mrow><mo>⌈</mo><mi>x</mi><mo>⌉</mo></mrow></mtd><mtd><mtext>si</mtext></mtd><mtd><mi>x</mi><mo><</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">\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}</annotation></semantics></math></p> + +<div>{{EmbedInteractiveExample("pages/js/math-trunc.html")}}</div> + +<p class="hidden">Le code source de cet exemple interactif est disponible dans un dépôt GitHub. Si vous souhaitez contribuez à ces exemples, n'hésitez pas à cloner <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> et à envoyer une <em>pull request</em> !</p> + +<h2 id="Syntaxe">Syntaxe</h2> + +<pre class="syntaxbox">Math.trunc(<var>x</var>)</pre> + +<h3 id="Paramètres">Paramètres</h3> + +<dl> + <dt><code>x</code></dt> + <dd>Un nombre.</dd> +</dl> + +<h3 id="Valeur_de_retour">Valeur de retour</h3> + +<p>La partie entière du nombre passé en argument.</p> + +<h2 id="Description">Description</h2> + +<p>Contrairement aux autres méthodes {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} et {{jsxref("Math.round()")}}, <code>Math.trunc()</code> 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).<br> + <br> + Ainsi, si l'argument est un nombre positif, <code>Math.trunc()</code> sera équivalent à <code>Math.floor()</code>, sinon <code>Math.trunc()</code> sera équivalent à <code>Math.ceil()</code>.</p> + +<p>On notera que l'argument passé à la méthode est converti en nombre de façon implicite.</p> + +<p><code>trunc()</code> est une méthode statique de <code>Math</code>, elle doit toujours être utilisée avec la syntaxe <code>Math.trunc()</code>, elle ne doit pas être utilisée comme la méthode d'un objet qui aurait été instancié (<code>Math</code> n'est pas un constructeur).</p> + +<h2 id="Exemples">Exemples</h2> + +<h3 id="Utiliser_Math.trunc()">Utiliser <code>Math.trunc()</code></h3> + +<pre class="brush: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</pre> + +<h2 id="Spécifications">Spécifications</h2> + +<table class="standard-table"> + <tbody> + <tr> + <th scope="col">Spécification</th> + <th scope="col">État</th> + <th scope="col">Commentaire</th> + </tr> + <tr> + <td>{{SpecName('ES2015', '#sec-math.trunc', 'Math.trunc')}}</td> + <td>{{Spec2('ES2015')}}</td> + <td>Première définition.</td> + </tr> + <tr> + <td>{{SpecName('ESDraft', '#sec-math.trunc', 'Math.trunc')}}</td> + <td>{{Spec2('ESDraft')}}</td> + <td></td> + </tr> + </tbody> +</table> + +<h2 id="Compatibilité_des_navigateurs">Compatibilité des navigateurs</h2> + +<p class="hidden">Le tableau de compatibilité de cette page a été généré à partir de données structurées. Si vous souhaitez contribuer à ces données, n'hésitez pas à envoyer une <em>pull request</em> sur <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p> + +<p>{{Compat("javascript.builtins.Math.trunc")}}</p> + +<h2 id="Voir_aussi">Voir aussi</h2> + +<ul> + <li>{{jsxref("Math.abs()")}}</li> + <li>{{jsxref("Math.ceil()")}}</li> + <li>{{jsxref("Math.floor()")}}</li> + <li>{{jsxref("Math.round()")}}</li> + <li>{{jsxref("Math.sign()")}}</li> +</ul> |