*Bug #5207 fixed - grand() can now return a hypermatrix
[scilab.git] / scilab / modules / randlib / help / fr_FR / grand.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) Jean-Philippe Chancelier and Bruno Pincon
5  * Copyright (C) 2011 - DIGITEO - Michael Baudin
6  * Copyright (C) 2013 - Samuel GOUGEON : extension aux hypermatrices
7  *
8  * This file must be used under the terms of the CeCILL.
9  * This source file is licensed as described in the file COPYING, which
10  * you should have received as part of this distribution.  The terms
11  * are also available at    
12  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
13  *
14  -->
15 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"  xml:lang="fr" xml:id="grand">
16     <refnamediv>
17         <refname>grand</refname>
18         <refpurpose>Générateur de nombres pseudo-aléatoires</refpurpose>
19     </refnamediv>
20     <refsynopsisdiv>
21         <title>Séquence d'appel</title>
22         <synopsis>
23             Y = grand(m, n, "bet", A, B)
24             Y = grand(m, n, "bin", N, p)
25             Y = grand(m, n, "nbn", N, p)
26             Y = grand(m, n, "chi", Df)
27             Y = grand(m, n, "nch", Df, Xnon)
28             Y = grand(m, n, "exp", Av)
29             Y = grand(m, n, "f", Dfn, Dfd)
30             Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
31             Y = grand(m, n, "gam", shape, scale)
32             Y = grand(m, n, "nor", Av, Sd)
33             Y = grand(m, n, "geom", p)
34             Y = grand(m, n, "poi", mu)
35             Y = grand(m, n, "def")
36             Y = grand(m, n, "unf", Low, High)
37             Y = grand(m, n, "uin", Low, High)
38             Y = grand(m, n, "lgi")
39             
40             Y = grand(m, n, o,..,"..",...)
41             Y = grand(X,...)
42             
43             Y = grand(n, "mn", Mean, Cov)
44             Y = grand(n, "markov", P, x0)
45             Y = grand(n, "mul", nb, P)
46             Y = grand(n, "prm", vect)
47             
48             S = grand("getgen")
49             grand("setgen", gen)
50             
51             S = grand("phr2sd", phrase)
52             
53             S = grand("getsd")
54             grand("setsd", S)
55             
56             grand("setcgn", G)
57             S = grand("getcgn")
58             
59             grand("initgn", I)
60             
61             grand("setall", s1, s2, s3, s4)
62             
63             grand("advnst", K)
64         </synopsis>
65     </refsynopsisdiv>
66     <refsection>
67         <title>Paramètres</title>
68         <variablelist>
69             <varlistentry>
70                 <term>m, n, o</term>
71                 <listitem>
72                     <para>
73                         entiers, dimensions de la matrice de nombres aléatoires à obtenir <literal>Y</literal>
74                     </para>
75                 </listitem>
76             </varlistentry>
77             <varlistentry>
78                 <term>X </term>
79                 <listitem>
80                     <para>
81                         un vecteur, une matrice ou une hypermatrice dont seules les dimensions (<literal>m</literal> x <literal>n</literal> x ...) sont utilisées
82                     </para>
83                 </listitem>
84             </varlistentry>
85             <varlistentry>
86                 <term>Y</term>
87                 <listitem>
88                     <para>
89                         Vecteur, matrice ou hypermatrice des nombres aléatoires générés, de taille <literal>m</literal> x <literal>n</literal> x ... (encodage décimal)
90                     </para>
91                 </listitem>
92             </varlistentry>
93             <varlistentry>
94                 <term>S</term>
95                 <listitem>
96                     <para>
97                         résultat de l'action (une chaîne ou un vecteur colonne)
98                     </para>
99                 </listitem>
100             </varlistentry>
101         </variablelist>
102     </refsection>
103     <refsection>
104         <title>Description</title>
105         <para>
106             Cette fonction produit des nombres aléatoires selon différentes distributions.
107         </para>
108         <para>
109             Les séquences d'appel :
110         </para>
111         <screen>
112             Y = grand(m, n, "bet", A, B)
113             Y = grand(m, n, "bin", N, p)
114             Y = grand(m, n, "nbn", N, p)
115             Y = grand(m, n, "chi",  Df)
116             Y = grand(m, n, "nch", Df, Xnon)
117             Y = grand(m, n, "exp", Av)
118             Y = grand(m, n, "f", Dfn, Dfd)
119             Y = grand(m, n, "nf", Dfn, Dfd, Xnon)
120             Y = grand(m, n, "gam", shape, scale)
121             Y = grand(m, n, "nor", Av, Sd)
122             Y = grand(m, n, "geom", p)
123             Y = grand(m, n, "poi", mu)
124             Y = grand(m, n, "def")
125             Y = grand(m, n, "unf", Low, High)
126             Y = grand(m, n, "uin", Low, High)
127             Y = grand(m, n, "lgi")
128         </screen>
129         <para>
130             produisent une matrice de taille <literal>m</literal>-par-<literal>n</literal> de nombres aléatoires.
131             
132             Toutes ces séquences peuvent être étendues pour créer une hypermatrice à plus de 2 dimensions, les 
133             tailles (m, n, o,...) étant spécifiées avant le mot ".." indiquant le type de distribution statistique
134             souhaitée :
135         </para>
136         <para>
137             <programlisting role="no-scilab-exec"><![CDATA[
138                 Y = grand(m, n, o, ..., "..", ...)
139             ]]></programlisting>
140         </para>
141         <para>
142             Le format du vecteur ou matrice ou hypermatrice aléatoire attendue peut également être spécifié par
143         </para>
144         <para>
145             <programlisting role="no-scilab-exec"><![CDATA[
146                 Y = grand(X, ...)
147             ]]></programlisting>
148         </para>
149         <para>
150             où <literal>X</literal> de taille <literal>m</literal>-par-<literal>n</literal>... est une matrice 
151             ou une hypermatrice dont seul le format est exploité et sert de modèle.
152         </para>
153         <para>
154             Les séquences d'appel :
155         </para>
156         <screen>
157             Y = grand(n, "mn", Mean, Cov)
158             Y = grand(n, "markov", P, x0)
159             Y = grand(n, "mul", nb, P)
160             Y = grand(n, "prm", vect)
161         </screen>
162         <para>
163             produisent une matrice de taille <literal>m</literal>-par-<literal>n</literal>
164             avec des entrées aléatoires.
165         </para>
166         <para>
167             Les séquences d'appel :
168         </para>
169         <screen>
170             S = grand("getgen")
171             grand("setgen", gen)
172             
173             S = grand("getsd")
174             grand("setsd", S)
175             
176             S = grand("phr2sd", phrase)
177             
178             grand("setcgn", G)
179             S = grand("getcgn")
180             
181             grand("initgn", I)
182             
183             grand("setall", s1, s2, s3, s4)
184             
185             grand("advnst", K)
186         </screen>
187         <para>
188             configurent ou interrogent les générateurs aléatoires.
189         </para>
190     </refsection>
191     <refsection>
192         <title>Générer des nombres aléatoires selon une loi donnée</title>
193         <variablelist>
194             <varlistentry>
195                 <term>beta</term>
196                 <listitem>
197                     <para>
198                         <literal>Y = grand(m, n, "bet", A, B)</literal> génère des nombres aléatoires suivant
199                         la loi beta de paramètres <literal>A</literal> and <literal>B</literal>.
200                         La densité de cette loi est <latex><![CDATA[(0 < x < 1)]]></latex> :
201                     </para>
202                     <para>
203                         <latex>
204                             \dfrac{x^{A-1}(1-x)^{B-1}}{\beta(A,B)}
205                         </latex>
206                     </para>
207                     <para>
208                         <literal>A</literal> et <literal>B</literal> devant être des réels <latex><![CDATA[>10^{-37}]]></latex>.
209                         Fonction(s) associée(s) : <link linkend="cdfbet">cdfbet</link>.
210                     </para>
211                 </listitem>
212             </varlistentry>
213             <varlistentry>
214                 <term>binomiale</term>
215                 <listitem>
216                     <para>
217                         <literal>Y = grand(m, n, "bin", N, p)</literal> génère des nombres aléatoires suivant la loi
218                         binomiale de paramètres <literal>N</literal> (entier str. positif) et <literal>p</literal>
219                         (réel de [0,1]) : nombre de succès au cours de <literal>N</literal> épreuves de Bernouilli
220                         de probabilité de succès <literal>p</literal>.
221                         Fonctions associées : <link linkend="binomial">binomial</link>, <link linkend="cdfbin">cdfbin</link>.
222                     </para>
223                 </listitem>
224             </varlistentry>
225             <varlistentry>
226                 <term>binomiale négative</term>
227                 <listitem>
228                     <para>
229                         <literal>Y = grand(m, n, "nbn", N, p)</literal> génère des nombres aléatoires suivant la loi binomiale
230                         négative de paramètres <literal>N</literal> (entier str. positif) et <literal>p</literal> (réel
231                         de ]0,1[) : nombre d'échecs avant d'obtenir <literal>N</literal> succès dans des épreuves
232                         de Bernouilli de probabilité de succès <literal>p</literal>.
233                         Fonction associée : <link linkend="cdfnbn">cdfnbn</link>.
234                     </para>
235                 </listitem>
236             </varlistentry>
237             <varlistentry>
238                 <term>chi 2</term>
239                 <listitem>
240                     <para>
241                         <literal>Y = grand(m, n, "chi", Df)</literal> génère des nombres aléatoires suivant la loi du chi 2
242                         à <literal>Df</literal> (réel &gt; 0.0) degrés de liberté.
243                         Fonction associée : <link linkend="cdfchi">cdfchi</link>.
244                     </para>
245                 </listitem>
246             </varlistentry>
247             <varlistentry>
248                 <term>chi 2 non centrée</term>
249                 <listitem>
250                     <para>
251                         <literal>Y = grand(m, n, "nch", Df, Xnon)</literal> génère des nombres aléatoires suivant la loi du chi 2
252                         non centrée à <literal>Df</literal> degrés de liberté (réel &gt;= 1.0)
253                         le paramètre de décentrage étant <literal>Xnonc</literal> (réel &gt;= 0.0).
254                         Fonction associée : <link linkend="cdfchn">cdfchn</link>.
255                     </para>
256                 </listitem>
257             </varlistentry>
258             <varlistentry>
259                 <term>exponentielle</term>
260                 <listitem>
261                     <para>
262                         <literal>Y = grand(m, n, "exp", Av)</literal> génère des nombres aléatoires suivant la loi exponentielle
263                         de moyenne <literal>Av</literal> (réel &gt;= 0.0).
264                     </para>
265                 </listitem>
266             </varlistentry>
267             <varlistentry>
268                 <term>F variance ratio</term>
269                 <listitem>
270                     <para>
271                         <literal>Y = grand(m, n, "f", Dfn, Dfd)</literal> génère des nombres aléatoires suivant la loi F
272                         (variance ratio) à <literal>Dfn</literal> (réel &gt; 0.0) degrés de liberté au numérateur et
273                         <literal>Dfd</literal> (réel &gt; 0.0) degrés de liberté au dénominateur.
274                         Fonction associée : <link linkend="cdff">cdff</link>.
275                     </para>
276                 </listitem>
277             </varlistentry>
278             <varlistentry>
279                 <term>non central F variance ratio</term>
280                 <listitem>
281                     <para>
282                         <literal>Y = grand(m, n, "nf", Dfn, Dfd, Xnon)</literal> génère des nombres aléatoires suivant la loi
283                         F (variance ratio) non centrée à <literal>Dfn</literal> (réel &gt;= 1) degrés de liberté
284                         au numérateur, et <literal>Dfd</literal> (réel &gt; 0) degrés de liberté au dénominateur,
285                         <literal>Xnonc</literal> (réel &gt;= 0) étant le paramètre de décentrage.
286                         Fonction associée : <link linkend="cdffnc">cdffnc</link>.
287                     </para>
288                 </listitem>
289             </varlistentry>
290             <varlistentry>
291                 <term>gamma</term>
292                 <listitem>
293                     <para>
294                         <literal>Y = grand(m, n, "gam", shape, scale)</literal> génère des nombres aléatoires suivant la loi
295                         gamma de paramètres <literal>shape</literal> (réel &gt; 0) et <literal>scale</literal>
296                         (réel &gt; 0). La densité est :
297                     </para>
298                     <para>
299                         <latex>
300                             \dfrac{ \textrm{scale}^{\textrm{shape}} x^{\textrm{shape}-1} e^{-\textrm{scale} x}}{\gamma(\textrm{shape}) }
301                         </latex>
302                     </para>
303                     <para>
304                         Fonctions associées : <link linkend="gamma">gamma</link>, <link linkend="cdfgam">cdfgam</link>.
305                     </para>
306                 </listitem>
307             </varlistentry>
308             <varlistentry>
309                 <term>Gauss Laplace (normale)</term>
310                 <listitem>
311                     <para>
312                         <literal>Y = grand(m, n, "nor", Av, Sd)</literal> génère des nombres aléatoires suivant la loi normale
313                         de moyenne <literal>Av</literal> (réel) et d'écart type <literal>Sd</literal>
314                         (réel &gt;= 0).
315                         Fonctions associées : <link linkend="cdfnor">cdfnor</link>, <link linkend="erf">erf</link>.
316                     </para>
317                 </listitem>
318             </varlistentry>
319             <varlistentry>
320                 <term>multi normale</term>
321                 <listitem>
322                     <para>
323                         <literal>Y = grand(n, "mn", Mean, Cov)</literal> génère <literal>n</literal> réalisations indépendantes de la
324                         loi multi-normale ; <literal>Mean</literal> doit être un vecteur <literal>m</literal>-par-<literal>1</literal> et <literal>Cov</literal>
325                         une matrice <literal>m</literal>-par-<literal>m</literal> symétrique et définie positive, (<literal>Y</literal> est alors une
326                         matrice <literal>m</literal>-par-<literal>n</literal>).
327                     </para>
328                 </listitem>
329             </varlistentry>
330             <varlistentry>
331                 <term>geometrique</term>
332                 <listitem>
333                     <para>
334                         <literal>Y = grand(m, n, "geom", p)</literal>
335                         génère des nombres aléatoires suivant la loi
336                         geométrique de paramètre <literal>p</literal> : nombre
337                         d'épreuves de Bernouilli (de probabilité de succès
338                         <literal>p</literal>) jusqu'à obtenir un succès
339                         (<literal>p</literal> doit appartenir à l'intervalle
340                         <latex>[p_{min},1]</latex> (avec <latex> p_{min} = 1{,}3\times 10^{-307} </latex>).
341                     </para>
342                     <para>
343                         <literal>Y</literal> contient des nombres réels
344                         positifs à valeur entière qui sont "le nombre de
345                         tentatives nécessaire pour obtenir un succès" pour
346                         chaque tirage.
347                     </para>
348                 </listitem>
349             </varlistentry>
350             <varlistentry>
351                 <term>markov</term>
352                 <listitem>
353                     <para>
354                         <literal>Y = grand(n, "markov", P, x0)</literal> génère <literal>n</literal> états successifs d'une chaîne 
355                         Markov décrite par la matrice de transition <literal>P</literal>. L'état initial est donné par
356                         <literal>x0</literal>. Si <literal>x0</literal> est une matrice de taille
357                         <literal>m = size(x0, "*")</literal>
358                         alors <literal>Y</literal> est une matrice de taille <literal>m x n</literal>. <literal>Y(i,:)</literal> étant le
359                         chemin à partir de l'état initial <literal>x0(i)</literal>.
360                     </para>
361                 </listitem>
362             </varlistentry>
363             <varlistentry>
364                 <term>multinomiale</term>
365                 <listitem>
366                     <para>
367                         <literal>Y = grand(n, "mul", nb, P)</literal> génère <literal>n</literal> réalisations indépendantes de la loi
368                         Multinomiale :  classer <literal>nb</literal> éventualités dans <literal>m</literal> catégories (mettre
369                         <literal>nb</literal> "boules" dans <literal>m</literal> "boites"). <literal>P(i)</literal>
370                         étant la probabilité qu'une éventualité soit de categorie i. <literal>P</literal> le vecteur des
371                         probabilités est de taille <literal>m-1</literal> (la probabilté de la catégorie <literal>m</literal>
372                         étant <literal>1-sum(P)</literal>). <literal>Y</literal> est alors de dimensions <literal>m x n</literal>,
373                         chaque colonne <literal>Y(:,j)</literal> étant une réalisation de cette loi : <literal>Y(i,j)</literal>
374                         est le nombre d'éventualités classées en catégorie <literal>i</literal> pour la <literal>j</literal> ème
375                         réalisation (<literal>sum(Y(:,j)) = nb</literal>).
376                     </para>
377                 </listitem>
378             </varlistentry>
379             <varlistentry>
380                 <term>Poisson</term>
381                 <listitem>
382                     <para>
383                         <literal>Y = grand(m, n, "poi", mu)</literal> génère des nombres aléatoires suivant la loi de Poisson
384                         de moyenne <literal>mu</literal> (réel &gt;= 0.0).
385                         Fonction associée : <link linkend="cdfpoi">cdfpoi</link>.
386                     </para>
387                 </listitem>
388             </varlistentry>
389             <varlistentry>
390                 <term>permutations aléatoires</term>
391                 <listitem>
392                     <para>
393                         <literal>Y = grand(n, "prm", vect)</literal> génère <literal>n</literal> permutations aléatoire du
394                         vecteur colonne (<literal>m x 1</literal>) <literal>vect</literal>.
395                     </para>
396                 </listitem>
397             </varlistentry>
398             <varlistentry>
399                 <term>uniforme (def)</term>
400                 <listitem>
401                     <para>
402                         <literal>Y = grand(m, n, "def")</literal> génère des nombres aléatoires suivant la loi uniforme
403                         sur <literal>[0,1[</literal> (1 n'est jamais retourné).
404                     </para>
405                 </listitem>
406             </varlistentry>
407             <varlistentry>
408                 <term>uniforme (unf)</term>
409                 <listitem>
410                     <para>
411                         <literal>Y = grand(m, n, "unf", Low, High)</literal> génère des nombres aléatoires suivant la loi
412                         uniforme sur <literal>[Low, High[</literal> (<literal>High</literal> is never return).
413                     </para>
414                 </listitem>
415             </varlistentry>
416             <varlistentry>
417                 <term>uniforme (uin)</term>
418                 <listitem>
419                     <para>
420                         <literal>Y = grand(m, n, "uin", Low, High)</literal> génère des entiers aléatoires suivant la loi uniforme
421                         sur <literal>[Low, High]</literal>. <literal>High</literal>
422                         et <literal>Low</literal> doivent être des entiers tels que <literal>
423                             (High-Low+1)
424                             &lt; 2147483561
425                         </literal>
426                         .
427                     </para>
428                 </listitem>
429             </varlistentry>
430             <varlistentry>
431                 <term>uniforme (lgi)</term>
432                 <listitem>
433                     <para>
434                         <literal>Y = grand(m, n, "lgi")</literal> retourne la sortie du générateur de base courant : des entiers
435                         aléatoires suivant une loi uniforme sur :
436                     </para>
437                     <itemizedlist>
438                         <listitem>
439                             <para>
440                                 <literal>[0, 2^32 - 1]</literal> for mt, kiss and fsultra;
441                             </para>
442                         </listitem>
443                         <listitem>
444                             <para>
445                                 <literal>[0, 2147483561]</literal> for clcg2;
446                             </para>
447                         </listitem>
448                         <listitem>
449                             <para>
450                                 <literal>[0, 2^31 - 2]</literal> for clcg4;
451                             </para>
452                         </listitem>
453                         <listitem>
454                             <para>
455                                 <literal>[0, 2^31 - 1]</literal> for urand.
456                             </para>
457                         </listitem>
458                     </itemizedlist>
459                 </listitem>
460             </varlistentry>
461         </variablelist>
462     </refsection>
463     <refsection>
464         <title>Actions sur le(s) générateur(s) de base</title>
465         <para>
466             Depuis Scilab-2.7 vous avez la possibilité de choisir parmi plusieurs générateurs de base
467             (donnant des entiers aléatoires suivant la loi "lgi") :
468         </para>
469         <variablelist>
470             <varlistentry>
471                 <term>mt</term>
472                 <listitem>
473                     <para>
474                         Le Mersenne-Twister de M. Matsumoto and T. Nishimura, période d'environ <literal>2^19937</literal>,
475                         état interne donné par <literal>624</literal> entiers (plus un index); c'est le générateur
476                         par défaut.
477                     </para>
478                 </listitem>
479             </varlistentry>
480             <varlistentry>
481                 <term>kiss</term>
482                 <listitem>
483                     <para>
484                         Le Keep It Simple Stupid de G. Marsaglia,  période d'environ <literal>2^123</literal>,
485                         état interne donné par <literal>4</literal> entiers.
486                     </para>
487                 </listitem>
488             </varlistentry>
489             <varlistentry>
490                 <term>clcg2</term>
491                 <listitem>
492                     <para>
493                         Une combinaison de 2 générateurs linéaires congruentiels de P. L'Ecuyer,
494                         période d'environ <literal>2^61</literal>, état interne donné par <literal>2</literal> entiers ;
495                         c'était le seul générateur de base utilisé auparavent par grand (cette
496                         version est cependant légèrement différente de l'ancienne).
497                     </para>
498                 </listitem>
499             </varlistentry>
500             <varlistentry>
501                 <term>clcg4</term>
502                 <listitem>
503                     <para>
504                         Une combinaison de 4 générateurs linéaires congruentiels de P. L'Ecuyer,
505                         période d'environ <literal>2^121</literal>, état interne donné par 4 entiers ; ce générateur
506                         peut être partagé en <literal>101</literal> générateur virtuels (en fait la suite de
507                         longueur <literal>2^121</literal> peut être découpée en <literal>101</literal> sous-suites) ce qui peut
508                         être utile dans certains cas (voir 'Actions specifiques à clcg4' et
509                         'Exemple d'utilisation de clcg4').
510                     </para>
511                 </listitem>
512             </varlistentry>
513             <varlistentry>
514                 <term>fsultra</term>
515                 <listitem>
516                     <para>
517                         Un générateur SWB (subtract-with-borrow) mixé avec un générator congruentiel
518                         concu par Arif Zaman et George Marsaglia. Sa période est supérieure à <literal>10^356</literal>,
519                         et son état interne est constitué d'un tableau de 37 entiers, d'un index sur
520                         ce tableau et d'un drapeau (0 ou 1) ainsi qu'un autre entier donnant l'état interne
521                         du générateur congruentiel.
522                     </para>
523                 </listitem>
524             </varlistentry>
525             <varlistentry>
526                 <term>urand</term>
527                 <listitem>
528                     <para>
529                         Le générateur de base utilisé par la fonction
530                         <link linkend="rand">rand</link>, état interne constitué d'un entier, période de
531                         <literal>2^31</literal>.
532                         Ce generateur est fondé sur "Urand, A Universal Random Number Generator" By,
533                         Michael A. Malcolm, Cleve B. Moler, Stan-Cs-73-334, January 1973, Computer
534                         Science Department, School Of Humanities And Sciences, Stanford University.
535                         C'est le plus rapide de cette liste, mais ses qualités statistiques
536                         sont inférieures aux autres générateurs.
537                     </para>
538                 </listitem>
539             </varlistentry>
540         </variablelist>
541     </refsection>
542     <refsection>
543         <title>Actions</title>
544         <variablelist>
545             <varlistentry>
546                 <term>action = "getgen"</term>
547                 <listitem>
548                     <para>
549                         <literal>S = grand("getgen")</literal> retourne le nom du générateur de base actuel (<literal>S</literal> est
550                         l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra").
551                     </para>
552                 </listitem>
553             </varlistentry>
554             <varlistentry>
555                 <term>action = "setgen"</term>
556                 <listitem>
557                     <para>
558                         <literal>grand("setgen", gen)</literal> permet de changer le générateur de base : <literal>gen</literal>
559                         doit être l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra".
560                         En cas de succès la fonction retourne cette même chaîne.
561                     </para>
562                 </listitem>
563             </varlistentry>
564             <varlistentry>
565                 <term>action = "getsd"</term>
566                 <listitem>
567                     <para>
568                         <literal>S = grand("getsd")</literal> retourne l'état interne actuel (les 'germes' dans l'ancienne
569                         appelation quoique ce terme désigne plutôt l'état initial) du générateur de base courant ;
570                         <literal>S</literal> est un vecteur colonne (d'entiers) de dimension <literal>625</literal>
571                         pour mt (la première composante étant un 'index' sur l'état, c-a-d un entier de l'intervalle
572                         <literal>[1,624]</literal>), <literal>4</literal>
573                         pour kiss, <literal>2</literal> pour clcg2 , <literal>40</literal>pour fsultra, <literal>4</literal> pour clcg4
574                         (pour ce dernier vous obtenez l'état interne du générateur virtuel courant), et <literal>1</literal>
575                         pour urand.
576                     </para>
577                 </listitem>
578             </varlistentry>
579             <varlistentry>
580                 <term>action = "setsd"</term>
581                 <listitem>
582                     <para>
583                         <literal>grand("setsd", S), grand("setsd", s1[, s2, s3, s4])</literal> impose l'état interne du générateur de
584                         base courant :
585                     </para>
586                     <variablelist>
587                         <varlistentry>
588                             <term>pour mt</term>
589                             <listitem>
590                                 <para>
591                                     <literal>S</literal> est un vecteur d'entiers de dimension <literal>625</literal> (la première composante
592                                     étant un index sur <literal>[1,624]</literal>), les <literal>624</literal> dernières composantes doivent
593                                     être dans <literal>[0,2^32[</literal>) (mais ne doivent pas être toutes nulles) ; une initialisation
594                                     plus simple est possible (et recommandée) en donnant un seul entier <literal>s1</literal> (<literal>s1</literal> appartenant
595                                     à <literal>[0,2^32[</literal>) ;
596                                 </para>
597                             </listitem>
598                         </varlistentry>
599                         <varlistentry>
600                             <term>pour kiss</term>
601                             <listitem>
602                                 <para>
603                                     <literal>4</literal> entiers <literal>s1, s2, s3, s4</literal> dans <literal>[0,2^32[</literal> doivent être
604                                     fournis ;
605                                 </para>
606                             </listitem>
607                         </varlistentry>
608                         <varlistentry>
609                             <term>pour clcg2</term>
610                             <listitem>
611                                 <para>
612                                     <literal>2</literal> entiers <literal>s1</literal> dans <literal>[1, 2147483562]</literal> et <literal>s2</literal>
613                                     dans <literal>[1, 2147483398]</literal> doivent être fournis ;
614                                 </para>
615                             </listitem>
616                         </varlistentry>
617                         <varlistentry>
618                             <term>pour clcg4</term>
619                             <listitem>
620                                 <para>
621                                     <literal>4</literal> entiers <literal>s1</literal> dans <literal>[1, 2147483646]</literal>, <literal>s2</literal>
622                                     dans <literal>[1, 2147483542]</literal>, <literal>s3</literal> dans <literal>[1, 2147483422]</literal>,
623                                     <literal>s4</literal> dans <literal>[1, 2147483322]</literal> sont requis ;
624                                     <literal>ATTENTION</literal> : avec clcg4 vous positionnez l'état interne du générateur virtuel
625                                     courant mais vous perdez alors la synchronisation avec les autres générateurs virtuels.
626                                     (=&gt; si vous utilisez clcg4 avec différents générateurs virtuels, il faut utiliser
627                                     l'option "setall" qui permet de changer l'état interne (du générateur numéro 0) tout en
628                                     recalculant l'état initial des 100 autres générateurs virtuels).
629                                 </para>
630                             </listitem>
631                         </varlistentry>
632                         <varlistentry>
633                             <term>pour urand</term>
634                             <listitem>
635                                 <para>
636                                     <literal>1</literal> entier <literal>s1</literal> appartenant à
637                                     <literal>[0, 2^31[</literal> est requis.
638                                 </para>
639                             </listitem>
640                         </varlistentry>
641                         <varlistentry>
642                             <term>for fsultra</term>
643                             <listitem>
644                                 <para>
645                                     <literal>S</literal> est un vecteur de <literal>40</literal> entiers (son premier élément doit être dans
646                                     l'intervalle<literal>[0, 37]</literal>, son deuxième (drapeau) doit être 0 ou 1, le troisième un
647                                     entier de <literal>[1, 2^32[</literal> et les 37 composantes suivantes, des entiers de <literal>[0, 2^32[</literal>) ; il est recommandé
648                                     d'utiliser l'autre procédure d'initialisation (plus simple) avec deux entiers <literal>s1</literal> et
649                                     <literal>s2</literal> de <literal>[0, 2^32[</literal>.
650                                 </para>
651                             </listitem>
652                         </varlistentry>
653                     </variablelist>
654                 </listitem>
655             </varlistentry>
656             <varlistentry>
657                 <term>action = "phr2sd"</term>
658                 <listitem>
659                     <para>
660                         <literal>Sd = grand("phr2sd", phrase)</literal> étant donnée une chaîne de caractères <literal>phrase</literal>
661                         cet appel retourne un vecteur <literal>1 x 2</literal> qui peut être utilisé comme
662                         état interne pour un générateur de base (initialement adapté pour clcg2).
663                     </para>
664                 </listitem>
665             </varlistentry>
666         </variablelist>
667     </refsection>
668     <refsection>
669         <title>Options specifiques à clcg4</title>
670         <para>
671             Le générateur clcg4 peut être utilisé comme les autres mais il offre l'avantage de pouvoir être
672             découpé en (<literal>101</literal>) générateurs virtuels différents, c-a-d avec des séquences sans
673             intersection (quand vous utilisez un générateur classique vous pouvez changer l'état initial
674             de façon à obtenir une autre séquence mais vous n'êtes pas complètement sûr d'obtenir une
675             séquence complètement différente). Chaque générateur virtuel correspond à une séquence de
676             longueur <literal>2^72</literal> qui est de plus découpée en <literal>V = 2^31</literal> segments de longueur
677             <literal>W = 2^41</literal>. Pour un générateur virtuel donné vous pouvez retourner au début de la séquence
678             ou au début du segment ou bien au début du segment suivant.
679             Vous pouvez aussi changer l'état initial du générateur <literal>0</literal> avec l'option
680             "setall" qui recalcule l'état initial des autres générateurs virtuels de sorte à obtenir
681             la synchronisation entre les générateurs (c-a-d qu'en fonction du nouvel état initial du générateur
682             <literal>0</literal> l'état initial des générateurs <literal>1..100</literal> sont recalculés de façon à
683             obtenir <literal>101</literal> séquences qui ne s'intersectent pas).
684         </para>
685         <variablelist>
686             <varlistentry>
687                 <term>action = "setcgn"</term>
688                 <listitem>
689                     <para>
690                         <literal>grand("setcgn", G)</literal> sélectionne le générateur virtuel numéro <literal>G</literal> :
691                         lorsque le générateur de base courant est clcg4, c'est le générateur virtuel <literal>G</literal>
692                         qui sera alors utilisé ; les <literal>101</literal> générateurs virtuels sont numérotés
693                         <literal>0,1,...,100</literal> (ainsi <literal>G</literal> doit être un entier de l'intervalle
694                         <literal>[0, 100]</literal>) ; par défaut le générateur virtuel courant est celui de numéro
695                         <literal>0</literal>.
696                     </para>
697                 </listitem>
698             </varlistentry>
699             <varlistentry>
700                 <term>action = "getcgn"</term>
701                 <listitem>
702                     <para>
703                         <literal>S = grand("getcgn")</literal> retourne le numéro du générateur
704                         virtuel courant.
705                     </para>
706                 </listitem>
707             </varlistentry>
708             <varlistentry>
709                 <term>action = "initgn"</term>
710                 <listitem>
711                     <para>
712                         <literal>grand("initgn", I)</literal> réinitialise l'état du générateur virtuel courant :
713                     </para>
714                     <variablelist>
715                         <varlistentry>
716                             <term>I = -1</term>
717                             <listitem>
718                                 <para>remet l'état à sa valeur initiale</para>
719                             </listitem>
720                         </varlistentry>
721                         <varlistentry>
722                             <term>I = 0</term>
723                             <listitem>
724                                 <para>remet l'état au début du segment courant</para>
725                             </listitem>
726                         </varlistentry>
727                         <varlistentry>
728                             <term>I = 1</term>
729                             <listitem>
730                                 <para>
731                                     positionne l'état au début du segment suivant et met à jour les valeurs définissant
732                                     le segment courant (vous ne pouvez pas revenir au début du segment précédent).
733                                 </para>
734                             </listitem>
735                         </varlistentry>
736                     </variablelist>
737                 </listitem>
738             </varlistentry>
739             <varlistentry>
740                 <term>action = "setall"</term>
741                 <listitem>
742                     <para>
743                         <literal>grand("setall", s1, s2, s3, s4)</literal> impose l'état interne du générateur virtuel
744                         de numéro <literal>0</literal> à <literal>s1, s2, s3, s4</literal>. L'état initial des autres générateurs est
745                         alors reconstruit (de façon à obtenir 101 séquences qui ne s'intersectent pas). Voir
746                         l'action "setsd" pour les contraintes sur <literal>s1, s2, s3, s4</literal>.
747                     </para>
748                 </listitem>
749             </varlistentry>
750             <varlistentry>
751                 <term>action = "advnst"</term>
752                 <listitem>
753                     <para>
754                         <literal>grand("advnst", K)</literal> avance l'état du générateur virtuel courant de <literal>2^K</literal>
755                         valeurs et réinitialise l'état initial (du générateur virtuel courant) à
756                         ce nouvel état.
757                     </para>
758                 </listitem>
759             </varlistentry>
760         </variablelist>
761     </refsection>
762     <refsection>
763         <title>Exemples</title>
764         <para>
765             Dans l'exemple suivant, nous produisons des nombres aléatoires
766             associés à différentes lois de distribution et dessinons les histogrammes
767             associés.
768         </para>
769         <programlisting role="example"><![CDATA[ 
770 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
771 // avec une distribution normale de moyenne 0 et d'écart-type 1. 
772 R = grand(400, 800, "nor", 0, 1);
773 scf();
774 histplot(10, R);
775 xtitle("Nombres aléatoires (loi normale) par grand", "X", "Fréquence");
776  ]]></programlisting>
777         <scilab:image localized="true">
778             R = grand(400, 800, "nor", 0, 1);
779             histplot(10, R);
780             xtitle("Nombres aléatoires (loi normale) par grand", "X", "Fréquence");
781         </scilab:image>
782         <programlisting role="example"><![CDATA[ 
783 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
784 // uniformes dans [0, 1).
785 R = grand(400, 800, "def");
786 scf();
787 histplot(10, R);
788 xtitle("Nombres aléatoires uniformes par grand", "X", "Fréquence");
789  ]]></programlisting>
790         <scilab:image localized="true">
791             R = grand(400, 800, "def");
792             histplot(10, R);
793             xtitle("Nombres aléatoires uniformes par grand", "X", "Fréquence");
794         </scilab:image>
795         <programlisting role="example"><![CDATA[ 
796 // Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
797 // avec une distribution de Poisson de moyenne 5.
798 R = grand(400, 800, "poi", 5);
799 scf();
800 histplot(10, R);
801 xtitle("Nombres aléatoires (loi de Poisson) par grand", "X", "Fréquence");
802  ]]></programlisting>
803         <scilab:image localized="true">
804             R = grand(400, 800, "poi", 5);
805             histplot(10, R);
806             xtitle("Nombres aléatoires (loi de Poisson) par grand", "X", "Fréquence");
807         </scilab:image>
808         <para>
809             Dans l'exemple suivant, nous produisons des nombres aléatoires
810             suivant la loi exponentielle et comparons ensuite la distribution empirique
811             et la fonction de distribution théorique.
812         </para>
813         <programlisting role="example"><![CDATA[ 
814 lambda = 1.6;
815 N = 100000;
816 X = grand(1, N, "exp", lambda);
817 scf();
818 classes = linspace(0, 12, 25);
819 histplot(classes, X)
820 x = linspace(0, 12, 25);
821 y = (1/lambda)*exp(-(1/lambda)*x);
822 plot(x, y, "ro-");
823 legend(["Empirique" "Theorique"]);
824 xtitle("Loi exponentielle par grand", "X", "Fréquence");
825  ]]></programlisting>
826         <scilab:image localized="true">
827             lambda = 1.6;
828             N = 100000;
829             X = grand(1, N, "exp", lambda);
830             classes = linspace(0, 12, 25);
831             histplot(classes, X)
832             x = linspace(0, 12, 25);
833             y = (1/lambda)*exp(-(1/lambda)*x);
834             plot(x, y, "ro-");
835             legend(["Empirique" "Theorique"]);
836             xtitle("Loi exponentielle par grand", "X", "Fréquence");
837         </scilab:image>
838         <para>
839             Dans l'exemple suivant, nous générons des nombres aléatoires selon la distribution
840             gamma et comparons la distribution empirique et la loi de distribution théorique.
841         </para>
842         <programlisting role="example"><![CDATA[ 
843 N = 10000;
844 A = 10;
845 B = 4;
846 R = grand(1, N, "gam", A, B);
847 XS = gsort(R, "g", "i")';
848 PS = (1:N)'/N;
849 P = cdfgam("PQ", XS, A*ones(XS), B*ones(XS));
850 scf();
851 plot(XS, PS, "b-"); // Empirical distribution
852 plot(XS, P, "r-"); // Theoretical distribution
853 legend(["Empirique" "Théorique"]);
854 xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma", "X", "F");
855  ]]></programlisting>
856         <scilab:image localized="true">
857             N = 10000;
858             A = 10;
859             B = 4;
860             R = grand(1, N, "gam", A, B); 
861             XS = gsort(R, "g", "i")';
862             PS = (1:N)'/N;
863             P = cdfgam("PQ", XS, A*ones(XS), B*ones(XS));
864             plot(XS, PS, "b-");
865             plot(XS, P, "r-");
866             legend(["Empirique" "Théorique"]);
867             xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma", "X", "F");
868         </scilab:image>
869         <para>
870             Dans l'exemple suivant, nous générons 10 entiers aléatoires dans l'intervalle [1, 365].
871         </para>
872         <programlisting role="example"><![CDATA[ 
873 grand(10, 1, "uin", 1, 365)
874  ]]></programlisting>
875         <para>
876             Dans l'exemple suivant, nous générons 12 permutations de l'ensemble [1,2,...,7].
877             Les 12 permutations sont stockées colonne par colonne.
878         </para>
879         <programlisting role="example"><![CDATA[ 
880 grand(12, "prm", (1:7)')
881  ]]></programlisting>
882         <para>
883             L'exemple suivant génère une hypermatrice <varname>10</varname>-par-<varname>10</varname>-par-<varname>10</varname>
884             de nombre aléatoires provenant de la distribution "normale" et affiche les histogrammes associés.
885             Le graphes montrent les première et dernière couches de la matrice.
886         </para>
887         <programlisting role="example"><![CDATA[ 
888 // Retounrne une hypermatrice 400-par-800-par-10 de nombre aléatoires,
889 // avec la distribution normale, une moyenne de 0 et un écart-type de 1.
890 // Affichage de la première et dernière couches.
891 R = grand(10,10,10,"nor",0,1);
892 subplot(1,2,1)
893 hist3d(R(:,:,1));
894 xtitle("Couche 1");
895 subplot(1,2,2)
896 hist3d(R(:,:,10));
897 xtitle("Couche 10");
898  ]]></programlisting>
899         <scilab:image localized="true">
900             R = grand(10,10,10,"nor",0,1);
901             subplot(1,2,1)
902             hist3d(R(:,:,1));
903             xtitle("Couche 1");
904             subplot(1,2,2)
905             hist3d(R(:,:,10));
906             xtitle("Couche 10");
907         </scilab:image>
908     </refsection>
909     <refsection>
910         <title>Produire des nombres prévisibles ou moins prévisibles</title>
911         <para>
912             Les générateurs pseudo aléatoires sont fondés sur des séquences déterministes.
913             Pour produire des simulations reproductibles, la graine du générateur est constante,
914             de telle sorte que la séquence est la même d'une session à l'autre.
915             En conséquence, par défaut, les premiers nombres produis par <literal>grand</literal>
916             sont toujours les mêmes.
917         </para>
918         <para>
919             Dans certaines situations, nous peut vouloir initialiser la graine du générateur
920             dans le but de produire des nombres moins prédictibles.
921             Dans ce cas, on peut initialiser la graine avec la sortie de la fonction <literal>getdate</literal> :
922         </para>
923         <programlisting role="example"><![CDATA[
924 n = getdate("s");
925 grand("setsd", n)
926     ]]></programlisting>
927     </refsection>
928     <refsection>
929         <title>Exemple d'utilisation de clcg4</title>
930         <para>
931             On cherche à comparer deux techniques statistiques sur des données de tailles différentes.
932             La première, utilisant le 'bootstrapping' est supposée a priori aussi précise que
933             la deuxième technique (utilisant uniquement la force brute) tout en utilisant moins
934             de données. Pour la première méthode, un ensemble de données de taille n1, uniformément
935             distribuée entre 25 et 50 devra être généré puis analysé par la méthode.  Pour la
936             seconde méthode, on procède de même avec une taille n2 à choisir entre 100 et 200. Ce processus
937             est répété 1000 fois. Pour la réduction de la variance, on veut que les nombres aléatoires
938             utilisés dans les deux méthodes soient les mêmes pour chacune des 1000 comparaisons.
939             Comme la deuxième méthode utilise plus de nombres aléatoires, la synchronisation
940             peut être difficile si l'on utilise un générateur classique. Avec un générateur
941             comme clcg4 c'est par contre très simple : utilisez le générateur 0 pour obtenir
942             la taille n1 du jeux de données et le générateur 1 pour obtenir les données.
943             Avec le générateur 0 tirer la taille n2 puis resélectionner le générateur 1 et revenez
944             au début du segment courant pour obtenir les n2 données pour la deuxième méthode : ainsi
945             les données initiales (les n1 premieres) sont les mêmes pour les deux méthodes.
946             Pour la comparaison suivante, il suffit d'avancer le générateur 1 au segment suivant,
947             etc...
948         </para>
949     </refsection>
950     <refsection role="see also">
951         <title>Voir aussi</title>
952         <simplelist type="inline">
953             <member>
954                 <link linkend="rand">rand</link>
955             </member>
956             <member>
957                 <link linkend="sprand">sprand</link>
958             </member>
959             <member>
960                 <link linkend="ssrand">ssrand</link>
961             </member>
962         </simplelist>
963     </refsection>
964 </refentry>