* Bug #14390 fixed - double() help page had irrelevant syntaxes and was poor
[scilab.git] / scilab / modules / elementary_functions / help / fr_FR / floating_point / double.xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!--
3  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
4  * Copyright (C) 2008 - INRIA
5  * Copyright (C) 2016 - Samuel GOUGEON
6  * Copyright (C) 2012 - 2016 - Scilab Enterprises
7  *
8  * This file is hereby licensed under the terms of the GNU GPL v2.0,
9  * pursuant to article 5.3.4 of the CeCILL v.2.1.
10  * This file was originally licensed under the terms of the CeCILL v2.1,
11  * and continues to be available under such terms.
12  * For more information, see the COPYING file which you should have received
13  * along with this program.
14  *
15  -->
16 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="double" xml:lang="fr">
17     <refnamediv>
18         <refname>double</refname>
19         <refpurpose>convertit des entiers inttype ou des booléens en encodage décimal
20         </refpurpose>
21     </refnamediv>
22     <refsynopsisdiv>
23         <title>Syntaxe</title>
24         <synopsis>y = double(X)
25         </synopsis>
26     </refsynopsisdiv>
27     <refsection role="parameters">
28         <title>Paramètres</title>
29         <variablelist>
30             <varlistentry>
31                 <term>X</term>
32                 <listitem>
33                     <para>matrice d'entiers encodés ou de booléens</para>
34                 </listitem>
35             </varlistentry>
36             <varlistentry>
37                 <term>y</term>
38                 <listitem>
39                     <para>matrice de nombres en notation décimale</para>
40                 </listitem>
41             </varlistentry>
42         </variablelist>
43     </refsection>
44     <refsection role="description">
45         <title>Description</title>
46         <para>Convertit des nombres entiers encodés sur 1, 2, 4 ou 8 octets
47             en nombres décimaux encodés sur 8 octets.
48             Si <literal>X</literal> est déjà encodée en notation décimale,
49               <function>double()</function> ne fait rien.
50           <note><function>double()</function> et <literal>iconvert(..,0)</literal>
51           sont équivalentes et ont la même vitesse.
52           </note>
53           <note><function>double()</function> peut aussi convertir des booléens.
54           Cependant, la fonction dédiée <literal>bool2s()</literal> est environ
55           2 fois plus rapide.
56           </note>
57           <important>La mantisse des nombres entiers <literal>uint64</literal> est
58           encodée sur 64 bits, alors que la mantisse des nombres en notation
59           décimale (<literal>double</literal> precision) est encodée sur 52 bits
60           seulement. La précision relative des entiers <literal>uint64</literal>
61           supérieurs à 2<superscript>52</superscript> peut donc être jusqu'à 2<superscript>12</superscript>
62           ~4000 fois meilleure
63           que celle de leur équivalent décimal "<literal>double</literal>".
64           En conséquence, l'utilisation de
65           <function>double()</function> sur des entiers <literal>int64</literal> ou
66           <literal>uint64</literal> supérieurs à 2<superscript>52</superscript> peut tronquer
67           leurs valeurs
68           par arrondi, et ainsi diminuer leur précision relative. Quelques
69           exemples donnés ci-dessous illustrent cet effet.
70           </important>
71         </para>
72     </refsection>
73
74     <refsection role="examples">
75         <title>Exemples</title>
76         <programlisting role="example"><![CDATA[
77 x = int8([0 12 140])
78 double(x)
79
80 // double() arrondit et tronque les nombres int64() or uint64() supérieurs à 2^52
81 // ------------------------------------------------------------------------------
82 i = int64(2)^52        // 52 bits, comme pour la mantisse des décimaux
83 i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
84 err = i - double(i)    // pas de différence, pour les |entiers|<= 2^52
85 i = int64(2)^53        // valeur sur 53 bits => mantisse + précise que celle des décimaux
86 i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
87 err = i - double(i)    // Des erreurs d'arrondi dues à double() apparaissent
88 i = int64(2)^55
89 i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
90 err = i - double(i)
91 i = int64(2)^62        // L'amplitude des erreurs est ~ 2^(n-52)
92 i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
93 err = i - double(i)
94 ]]></programlisting>
95     <screen>
96 <![CDATA[--> i = int64(2)^52     // 52 bits, comme pour la mantisse des décimaux
97  i  =
98   4503599627370496
99
100 --> i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
101  i  =
102   4503599627370496  4503599627370499  4503599627370526
103   4503599627370499  4503599627370529  4503599627370826
104   4503599627370502  4503599627370559  4503599627371126
105   4503599627370505  4503599627370589  4503599627371426
106
107 --> err = i - double(i)   // pas de différence, pour les |entiers|<= 2^52
108  err  =
109   0  0  0
110   0  0  0
111   0  0  0
112   0  0  0
113
114 --> i = int64(2)^53      // valeur sur 53 bits => mantisse + précise que celle des décimaux
115  i  =
116   9007199254740992
117
118 --> i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
119  i  =
120   9007199254740992  9007199254740995  9007199254741022
121   9007199254740995  9007199254741025  9007199254741322
122   9007199254740998  9007199254741055  9007199254741622
123   9007199254741001  9007199254741085  9007199254741922
124
125 --> err = i - double(i)     // Des erreurs d'arrondi dues à double() apparaissent
126  err  =
127   0 -1  0
128  -1  1  0
129   0 -1  0
130   1  1  0
131
132 --> i = int64(2)^55
133  i  =
134   36028797018963968
135
136 --> i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
137  i  =
138   36028797018963968  36028797018963971  36028797018963998
139   36028797018963971  36028797018964001  36028797018964298
140   36028797018963974  36028797018964031  36028797018964598
141   36028797018963977  36028797018964061  36028797018964898
142
143 --> err = i - double(i)
144  err  =
145   0  3 -2
146   3  1  2
147  -2 -1 -2
148   1 -3  2
149
150 --> i = int64(2)^62        // L'amplitude des erreurs est ~ 2^(n-52)
151  i  =
152   4611686018427387904
153
154 --> i = [i+(0:3:9)'  i+(3:30:93)'  i+(30:300:930)']
155  i  =
156   4611686018427387904  4611686018427387907  4611686018427387934
157   4611686018427387907  4611686018427387937  4611686018427388234
158   4611686018427387910  4611686018427387967  4611686018427388534
159   4611686018427387913  4611686018427387997  4611686018427388834
160
161 --> err = i - double(i)
162  err  =
163   0  3  30
164   3  33  330
165   6  63 -394
166   9  93 -94
167 ]]></screen>
168         <para></para>
169         <programlisting role="example"><![CDATA[
170 // Vitesses comparées de double(), bool2s() et iconvert(,0) sur des booléens
171 // -------------------------------------------------------------------------
172 b = (rand(1000,1000)<0.5);
173 tic(),for i=1:100, bool2s(b); end, toc()
174 tic(),for i=1:100, double(b); end, toc()
175 tic(),for i=1:100, iconvert(b,0); end, toc()
176  ]]></programlisting>
177     <screen>
178 <![CDATA[--> b = (rand(1000,1000)<0.5);
179 --> tic(),for i=1:100, bool2s(b); end, toc()
180  ans  =
181    1.1680533
182
183 --> tic(),for i=1:100, double(b); end, toc()
184  ans  =
185    2.9003021
186
187 --> tic(),for i=1:100, iconvert(b,0); end, toc()
188  ans  =
189    2.1867567
190 ]]></screen>
191         <para></para>
192       <programlisting role="example"><![CDATA[
193 // Vitesses comparées de double() et iconvert(..,0) sur des entiers int32
194 // ----------------------------------------------------------------------
195 i = int32((rand(1000,1000)-0.5)*1000);
196 tic(),for j=1:100, double(i); end, toc()
197 tic(),for j=1:100, iconvert(i,0); end, toc()
198  ]]></programlisting>
199       <screen>
200 <![CDATA[--> i = int32((rand(1000,1000)-0.5)*10000);
201 --> tic(),for j=1:100, double(i); end, toc()
202  ans  =
203    2.2464656
204
205 --> tic(),for j=1:100, iconvert(i,0); end, toc()
206  ans  =
207    2.2771408
208 ]]></screen>
209     </refsection>
210
211     <refsection role="see also">
212         <title>Voir aussi</title>
213         <simplelist type="inline">
214             <member>
215                 <link linkend="iconvert">iconvert</link>
216             </member>
217             <member>
218                 <link linkend="bool2s">bool2s</link>
219             </member>
220             <member>
221                 <link linkend="int8">int8</link>
222             </member>
223             <member>
224                 <link linkend="inttype">inttype</link>
225             </member>
226             <member>
227                 <link linkend="type">type</link>
228             </member>
229             <member>
230                 <link linkend="bin2dec">bin2dec</link>
231             </member>
232             <member>
233                 <link linkend="oct2dec">oct2dec</link>
234             </member>
235             <member>
236                 <link linkend="hex2dec">hex2dec</link>
237             </member>
238             <member>
239                 <link linkend="base2dec">base2dec</link>
240             </member>
241         </simplelist>
242     </refsection>
243       <refsection role="history">
244         <title>Historique</title>
245         <revhistory>
246             <revision>
247                 <revnumber>6.0</revnumber>
248                 <revdescription>
249                     Les nouveaux types d'entiers int64 and uint64
250                     sont maintenant convertibles.
251                 </revdescription>
252             </revision>
253         </revhistory>
254     </refsection>
255 </refentry>