* Bug 15431 fixed [doc]: empty [] better documented
[scilab.git] / scilab / modules / integer / help / fr_FR / int8.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) 2018 - Samuel GOUGEON
6  *
7  * Copyright (C) 2012 - 2016 - Scilab Enterprises
8  *
9  * This file is hereby licensed under the terms of the GNU GPL v2.0,
10  * pursuant to article 5.3.4 of the CeCILL v.2.1.
11  * This file was originally licensed under the terms of the CeCILL v2.1,
12  * and continues to be available under such terms.
13  * For more information, see the COPYING file which you should have received
14  * along with this program.
15  *
16  -->
17 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
18         xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
19         xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
20         xml:lang="fr" xml:id="int8">
21     <refnamediv>
22         <refname>int8 </refname>
23         <refpurpose>conversion au codage entier à 1 octet  </refpurpose>
24     </refnamediv>
25     <refnamediv xml:id="int16">
26         <refname>int16</refname>
27         <refpurpose>conversion au codage entier à 2 octets  </refpurpose>
28     </refnamediv>
29     <refnamediv xml:id="int32">
30         <refname>int32</refname>
31         <refpurpose>conversion au codage entier à 4 octets  </refpurpose>
32     </refnamediv>
33     <refnamediv xml:id="int64">
34         <refname>int64</refname>
35         <refpurpose>conversion au codage entier à 8 octets  </refpurpose>
36     </refnamediv>
37     <refnamediv xml:id="uint8">
38         <refname>uint8 </refname>
39         <refpurpose>conversion au codage entier non signé à 1 octet  </refpurpose>
40     </refnamediv>
41     <refnamediv xml:id="uint16">
42         <refname>uint16</refname>
43         <refpurpose>conversion au codage entier non signé à 2 octets  </refpurpose>
44     </refnamediv>
45     <refnamediv xml:id="uint32">
46         <refname>uint32</refname>
47         <refpurpose>conversion au codage entier non signé à 4 octets  </refpurpose>
48     </refnamediv>
49     <refnamediv xml:id="uint64">
50         <refname>uint64</refname>
51         <refpurpose>conversion au codage entier non signé à 8 octets  </refpurpose>
52     </refnamediv>
53     <refsynopsisdiv>
54         <title>Séquence d'appel</title>
55         <synopsis>
56             y = int8(X)
57             y = int16(X)
58             y = int32(X)
59             y = int64(X)
60             y = uint8(X)
61             y = uint16(X)
62             y = uint32(X)
63             y = uint64(X)
64         </synopsis>
65     </refsynopsisdiv>
66     <refsection>
67         <title>Arguments</title>
68         <variablelist>
69             <varlistentry>
70                 <term>X  </term>
71                 <listitem>
72                     <para>
73                         matrice de booléens, d'entiers encodés, ou de nombres décimaux réels ou complexes.
74                     </para>
75                 </listitem>
76             </varlistentry>
77             <varlistentry>
78                 <term>y  </term>
79                 <listitem>
80                     <para>matrice d'entiers encodés sur 1, 2, 4 ou 8 octets. size(y) == size(X).
81                     </para>
82                 </listitem>
83             </varlistentry>
84         </variablelist>
85     </refsection>
86     <refsection>
87         <title>Description</title>
88         <para>
89             Convertit et stocke sous forme d'entiers. Ces types de données sont particulièrement
90             intéressants pour stocker des images, de longs signaux, ...
91         </para>
92         <warning>
93             <para>
94                 Lorsque des éléments de <varname>X</varname> ont une partie décimale non nulle,
95                 celle-ci est toujours tronquée (arrondie vers 0).<table></table>
96                 Exemple:
97                 <literal>int8([-3.6, -2.5, -1.4, 1.3, 3.5, 6.7]) // = [-3, -2, -1, 1, 3, 6]</literal>.
98             </para>
99             <para>
100                 Les valeurs de <varname>X</varname> hors de l'intervalle cible sont modulotées
101                 (non saturées). Exemples:
102                 <itemizedlist>
103                     <listitem>
104                         <literal>int8([127 128 129 130])  // = [127 -128 -127 -126]</literal>.
105                     </listitem>
106                     <listitem>
107                         <literal>uint8([254 255 256 257]) // = [254 255 0 1]</literal>.
108                     </listitem>
109                 </itemizedlist>
110             </para>
111             <para>
112                 -%inf est toujours converti en la borne inférieure de l'intervalle des valeurs
113                 possibles (voir ci-dessous).
114             </para>
115             <para>
116                 %inf est toujours converti en la borne supérieure de l'intervalle des valeurs
117                 possibles.
118             </para>
119             <para>%nan est toujours converti en 0.</para>
120             <para>
121                 Si <varname>X</varname> est encodé en nombres complexes, les parties imaginaires
122                 de ses éléments sont ignorées. Seules les parties réelles converties sont retournées.
123             </para>
124             <para>[%f %t] est toujours converti en [0 1].</para>
125             <para>
126             Convertir en nombres décimaux de grands entiers encodés en int64 or uint64
127             peut changer leur valeur et diminuer leur précision relative. En effet, la valeur
128             des entiers int64 | uint64 est encodée sur 63|64 bits, alors que la mantisse des
129             nombres décimaux est encodée sur 53 bits seulement. Pour plus de détails, voir la page
130             de la fonction <link linkend="double">double()</link> et un exemple ci-dessous.
131             </para>
132         </warning>
133         <warning>
134             La conversion de <literal>[]</literal> ne change rien : son type 1 est toujours
135             conservé (type numérique décimal).
136         </warning>
137         <para>
138             <table>
139                 <tr><th>Fonction</th><th>y dans</th><th align="left">=</th></tr>
140                 <tr><th>int8(X)</th>
141                     <td>[- 2<superscript>7</superscript>,  2<superscript>7</superscript>-1]</td>
142                     <td>[-128, 127]</td>
143                 </tr>
144                 <tr><th>int16(X)</th>
145                     <td>[- 2<superscript>15</superscript>,  2<superscript>15</superscript>-1]</td>
146                     <td>[-32768, 32767]</td>
147                 </tr>
148                 <tr><th>int32(X)</th>
149                     <td>[- 2<superscript>31</superscript>,  2<superscript>31</superscript>-1]</td>
150                     <td>[-2147483648, 2147483647]</td>
151                 </tr>
152                 <tr><th>int64(X)</th>
153                     <td>[- 2<superscript>63</superscript>,  2<superscript>63</superscript>-1]</td>
154                     <td>[-9223372036854775808, 9223372036854775807]</td>
155                 </tr>
156                 <tr><th>uint8(X)</th>
157                     <td>[0, 2<superscript>8</superscript>-1]</td>
158                     <td>[0, 255]</td>
159                 </tr>
160                 <tr><th>uint16(X)</th>
161                     <td>[0, 2<superscript>16</superscript>-1]</td>
162                     <td>[0, 65535]</td>
163                 </tr>
164                 <tr><th>uint32(X)</th>
165                     <td>[0, 2<superscript>32</superscript>-1]</td>
166                     <td>[0, 4294967295]</td>
167                 </tr>
168                 <tr><th>uint64(X)</th>
169                     <td>[0, 2<superscript>64</superscript>-1]</td>
170                     <td>[0, 18446744073709551615]</td>
171                 </tr>
172             </table>
173         </para>
174     </refsection>
175     <refsection role="examples">
176         <title>Exemples</title>
177         <para>
178             Arrondis vers 0 et congruences ; valeurs spéciales :
179         </para>
180         <programlisting role="example"><![CDATA[
181 int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
182 int8([-130 -129 -128 -127 126 127 128 129])
183 a = -129 + 256*(-3:3)
184 int8(a)
185 int8([-%inf %inf %nan])
186  ]]></programlisting>
187     <screen><![CDATA[
188 --> int8([-11.7 -8.5 -6.4  6.4 8.5 11.7])
189  ans  =
190  -11 -8 -6  6  8  11
191
192 --> int8([-130 -129 -128 -127 126 127 128 129])
193  ans  =
194   126  127 -128 -127  126  127 -128 -127
195
196 --> a = -129 + 256*(-3:3)
197  a  =
198   -897.  -641.  -385.  -129.   127.   383.   639.
199
200 --> int8(a)
201  ans  =
202   127  127  127  127  127  127  127
203
204 --> int8([-%inf %inf %nan])
205  ans  =
206  -128  127  0
207 ]]></screen>
208     <para>
209         À propos des effets de congruence (modulo) et des limites supérieures des encodages entiers
210         non signés :
211     </para>
212     <programlisting role="example"><![CDATA[
213 uint8([-1 %inf])
214 uint16([-1 %inf])
215 uint32([-1 %inf])
216 uint64([-1 %inf])
217  ]]></programlisting>
218     <screen><![CDATA[
219 --> uint8([-1 %inf])
220  ans  =
221   255  255
222
223 --> uint16([-1 %inf])
224  ans  =
225   65535  65535
226
227 --> uint32([-1 %inf])
228  ans  =
229   4294967295  4294967295
230
231 --> uint64([-1 %inf])
232  ans  =
233   18446744073709551615  18446744073709551615
234 ]]></screen>
235     <para>
236         Convertir de grands entiers encodés sur 64 bits en nombres décimaux altère leur valeur et
237         dégrade leur précision relative :
238     </para>
239         <programlisting role="example"><![CDATA[
240 i = uint64(2)^63 - 600
241 i - uint64(double(i))
242  ]]></programlisting>
243     <screen><![CDATA[
244 --> i = uint64(2)^63 - 600
245  i  =
246   9223372036854775208
247
248 --> i - uint64(double(i))
249  ans  =
250   424
251 ]]></screen>
252     <para>
253         Conversion de booléens et de nombres complexes :
254     </para>
255     <programlisting role="example"><![CDATA[
256 int8([%f %t])
257
258 int8(-10.2 + 3.4*%i)
259 uint8(-10.2 + 3.4*%i)
260  ]]></programlisting>
261     <screen><![CDATA[
262 --> int8([%f %t])
263  ans  =
264   0  1
265
266 --> int8(-10.2 + 3.4*%i)
267  ans  =
268  -10
269
270 --> uint8(-10.2 + 3.4*%i)
271  ans  =
272   246
273 ]]></screen>
274     <para>
275         [] n'est pas convertible:
276     </para>
277     <programlisting role="example"><![CDATA[
278 i = uint16(3);
279 i(1,2) = 5.6
280 typeof(i)
281
282 i = uint16([])
283 i(1,2) = 2.3
284 typeof(i)
285  ]]></programlisting>
286     <screen><![CDATA[
287 --> i = uint16(3);
288 --> i(1,2) = 5.6
289  i  =
290   3  5
291
292 --> typeof(i)
293  ans  =
294  uint16
295
296
297 --> i = uint16([])
298  i  =
299     []
300
301 --> i(1,2) = 2.3
302  i  =
303    0.   2.3
304
305 --> typeof(i)
306  ans  =
307  constant
308 ]]></screen>
309     </refsection>
310     <refsection role="see also">
311         <title>Voir aussi</title>
312         <simplelist type="inline">
313             <member>
314                 <link linkend="iconvert">iconvert</link>
315             </member>
316             <member>
317                 <link linkend="inttype">inttype</link>
318             </member>
319             <member>
320                 <link linkend="double">double</link>
321             </member>
322             <member>
323                 <link linkend="dec2bin">dec2bin</link>
324             </member>
325             <member>
326                 <link linkend="dec2base">dec2base</link>
327             </member>
328         </simplelist>
329     </refsection>
330     <refsection role="history">
331         <title>Historique</title>
332         <revhistory>
333             <revision>
334                 <revnumber>6.0</revnumber>
335                 <revdescription>
336                     <itemizedlist>
337                         <listitem>
338                             int64() et uint64() ajoutées à Scilab.
339                         </listitem>
340                         <listitem>
341                             Les nombres complexes sont désormais acceptés.
342                         </listitem>
343                         <listitem>
344                             <table>
345                                 <tr><th>Ceci</th>               <th>vaut désormais</th><th>au lieu de</th></tr>
346                                 <tr><td>int8([-%inf, %inf])</td><td>[-128, 127]</td><td>[0, 0]</td></tr>
347                                 <tr><td>int16([-%inf, %inf])</td><td>[-32768, 32767]</td><td>[0, 0]</td></tr>
348                                 <tr><td>int32(%inf)</td>        <td>2147483647</td> <td>-2147483648</td></tr>
349                                 <tr><td>uint8(%inf)</td>        <td>255</td>        <td>0</td></tr>
350                                 <tr><td>uint16(%inf)</td>       <td>65535</td>      <td>0</td></tr>
351                                 <tr><td>uint32(%inf)</td>       <td>4294967295</td> <td>0</td></tr>
352                             </table>
353                         </listitem>
354                     </itemizedlist>
355                 </revdescription>
356             </revision>
357         </revhistory>
358     </refsection>
359 </refentry>