archived-doc-fr/language/types/float.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: e587d0655e426f97b3fcb431453da5030e743b23 Maintainer: yannick Status: ready -->
<!-- Reviewed: yes Maintainer: girgias -->
<!-- CREDITS: DavidA -->

<sect1 xml:id="language.types.float" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Nombres à virgule flottante</title>
 
 <para>
  Les nombres à virgule flottante (aussi connus comme <literal>"floats"</literal>,
  <literal>"doubles"</literal>, ou  <literal>"nombres réels"</literal>)
  peuvent être spécifiés en utilisant les syntaxes suivantes :
 </para>
 
 <informalexample>
  <programlisting role="php">
<![CDATA[
<?php
$a = 1.234;
$b = 1.2e3;
$c = 7E-10;
$d = 1_234.567; // à partir de PHP 7.4.0
?>
]]>
  </programlisting>
 </informalexample>
 
 <para>
  Formellement à partir de PHP 7.4.0 (auparavant, les underscores n'étaient
  pas autorisés) :
 </para>
 
 <informalexample>
  <programlisting>
<![CDATA[
LNUM          [0-9]+(_[0-9]+)*
DNUM          ({LNUM}?"."{LNUM}) | ({LNUM}"."{LNUM}?)
EXPONENT_DNUM (({LNUM} | {DNUM}) [eE][+-]? {LNUM})
]]>
  </programlisting>
 </informalexample>
 
 <para>
  La taille d'un &float; est dépendante de la plate-forme, cependant,
  un nombre maximal d'environ 1.8e308 avec une précision sur 14 chiffres est
  une valeur commune (format 64 bits IEEE).
 </para>
 
 <warning xml:id="warn.float-precision">
  <title>Précision des nombres flottants</title>
  
  <para>
   Les nombres flottants ont une précision limitée. Même s'ils dépendent du système,
   PHP utilise le format de précision des décimaux IEEE 754, qui donnera une erreur
   maximale relative de l'ordre de 1.11e-16 (due aux arrondis). Les opérations
   arithmétiques non-élémentaires peuvent donner des erreurs plus importantes et
   bien sûr les erreurs doivent être prises en compte lorsque plusieurs opérations
   sont liées.
  </para>
  
  <para>
   Aussi, les nombres rationnels exactement représentables sous forme de nombre à virgule
   flottante en base 10, comme <literal>0.1</literal> ou <literal>0.7</literal>, n'ont pas
   de représentation exacte comme nombres à virgule flottante en base 2, utilisée en
   interne, et ce quelle que soit la taille de la mantisse. De ce fait, ils ne peuvent
   être convertis sans une petite perte de précision. Ceci peut mener à des résultats
   confus: par exemple, <literal>floor((0.1+0.7)*10)</literal> retournera normalement
   <literal>7</literal> au lieu de <literal>8</literal> attendu, car la représentation
   interne sera quelque chose comme <literal>7.9999999999999991118...</literal>.
  </para>
  
  <para>
   Ainsi, ne faites jamais confiance aux derniers chiffres d'un nombre
   flottant, mais aussi, ne comparez pas l'égalité de 2 nombres flottants
   directement. Si une plus grande précision est nécessaire, les
   <link linkend="ref.bc">fonctions mathématiques de précision arbitraire</link>
   et les fonctions <link linkend="ref.gmp">gmp</link> sont disponibles.
  </para>
  
  <para>
   Pour une explication "simple", voir le
   <link xlink:href="&url.floating.point.guide;">guide relatif aux nombres
    à virgule flottante</link> qui est aussi intitulé
   "Why don't my numbers add up?"
  </para>
  
 </warning>

 <sect2 xml:id="language.types.float.casting">
  <title>Convertir en un nombre flottant</title>

  <sect3 xml:id="language.types.float.casting.from-string">
   <title>Depuis des chaînes de caractères</title>

   <simpara>
    Si une chaîne est
    <link linkend="language.types.numeric-strings">numérique</link>
    ou numérique de tête alors elle sera transformée en sa valeur flottante
    correspondante, sinon elle sera convertie en zéro (<literal>0</literal>).
   </simpara>
  </sect3>

  <sect3 xml:id="language.types.float.casting.from-other">
   <title>Depuis d'autres types</title>

   <para>
    Pour les valeurs d'autres types, la conversion est effectuée en convertissant
    la valeur d'abord en <type>int</type> puis en <type>float</type>. Voir
    <link linkend="language.types.integer.casting">conversion en entier</link>
    pour plus d'informations.
   </para>

   <note>
    <para>
     Comme certains types ont un comportement indéfini lors de la conversion
     en <type>int</type>, ceci est aussi le cas lors de la conversion en
     <type>float</type>.
    </para>
   </note>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.float.comparison">
  <title>Comparaison de nombres flottants</title>
  
  <para>
   Comme dit dans la note ci-dessus, le test d'égalité des valeurs de
   nombres flottants est problématique, en raison de la façon dont ils
   sont représentés en interne. Cependant, il existe des façons de
   réaliser cette comparaison.
  </para>
  
  <para>
   Pour tester l'égalité de valeurs de nombres flottants, une borne supérieure
   de l'erreur relative à l'arrondi est utilisée. Cette valeur est connue
   comme étant l'epsilon de la machine, ou le <literal>unit roundoff</literal>,
   et est la différence la plus petite acceptable dans les calculs.
  </para>

  <para>
   <varname>$a</varname> et <varname>$b</varname> sont égaux sur 5 nombres
   après la virgule.
  </para>
  
  <example>
   <title>Comparaison de nombres flottants</title>
   <programlisting role="php">
<![CDATA[
<?php
$a = 1.23456789;
$b = 1.23456780;
$epsilon = 0.00001;

if( abs($a - $b) < $epsilon) {
    echo "true";
}
?>
]]>
   </programlisting>
  </example>
 </sect2>
 
 <sect2 xml:id="language.types.float.nan">
  <title>NaN</title>
  <para>
   Quelques opérations numériques peuvent donner comme résultat une valeur
   représentée par la constante <constant>NAN</constant>. Ce résultat représente
   une valeur indéfinie ou non représentable lors de calculs avec des nombres
   à virgule flottante. Toute comparaison, même stricte de cette valeur avec
   une autre valeur, y compris cette constante elle-même, sauf si elle est
   égale à &true;, donnera une valeur de &false;.
  </para>
  <para>
   En raison du fait que <constant>NAN</constant> représente tout nombre de valeurs
   différentes, <constant>NAN</constant> ne doit pas être comparé à d'autres valeurs,
   y compris cette constante elle-même, et à la place, elle doit être vérifiée
   en utilisant la fonction <function>is_nan</function>.
  </para>
 </sect2>
 
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->