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