~ubuntu-branches/ubuntu/raring/scilab/raring-proposed

« back to all changes in this revision

Viewing changes to modules/randlib/help/fr_FR/grand.xml

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2012-08-30 14:42:38 UTC
  • mfrom: (1.4.7)
  • Revision ID: package-import@ubuntu.com-20120830144238-c1y2og7dbm7m9nig
Tags: 5.4.0-beta-3-1~exp1
* New upstream release
* Update the scirenderer dep
* Get ride of libjhdf5-java dependency

Show diffs side-by-side

added added

removed removed

Lines of Context:
11
11
 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
12
12
 *
13
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" version="5.0-subset Scilab" 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 <literal>
412
 
              (High-Low+1)
413
 
              &lt; 2147483561
414
 
            </literal>
415
 
            .
416
 
          </para>
417
 
        </listitem>
418
 
      </varlistentry>
419
 
      <varlistentry>
420
 
        <term>uniforme (lgi)</term>
421
 
        <listitem>
422
 
          <para>
423
 
            <literal>Y=grand(m,n,"lgi")</literal> retourne la sortie du générateur de base courant : des entiers
424
 
            aléatoires suivant une loi uniforme sur :
425
 
          </para>
426
 
          <itemizedlist>
427
 
            <listitem>
428
 
              <para>
429
 
                <literal>[0, 2^32 - 1]</literal> for mt, kiss and fsultra;
430
 
              </para>
431
 
            </listitem>
432
 
            <listitem>
433
 
              <para>
434
 
                <literal>[0, 2147483561]</literal> for clcg2;
435
 
              </para>
436
 
            </listitem>
437
 
            <listitem>
438
 
              <para>
439
 
                <literal>[0, 2^31 - 2]</literal> for clcg4;
440
 
              </para>
441
 
            </listitem>
442
 
            <listitem>
443
 
              <para>
444
 
                <literal>[0, 2^31 - 1]</literal> for urand.
445
 
              </para>
446
 
            </listitem>
447
 
          </itemizedlist>
448
 
        </listitem>
449
 
      </varlistentry>
450
 
    </variablelist>
451
 
  </refsection>
452
 
  <refsection>
453
 
    <title>Actions sur le(s) générateur(s) de base</title>
454
 
    <para>
455
 
      Depuis Scilab-2.7 vous avez la possibilité de choisir parmi plusieurs générateurs de base
456
 
      (donnant des entiers aléatoires suivant la loi "lgi") :
457
 
    </para>
458
 
    <variablelist>
459
 
      <varlistentry>
460
 
        <term>mt</term>
461
 
        <listitem>
462
 
          <para>
463
 
            Le Mersenne-Twister de M. Matsumoto and T. Nishimura, période d'environ <literal>2^19937</literal>,
464
 
            état interne donné par <literal>624</literal> entiers (plus un index); c'est le générateur
465
 
            par défaut.
466
 
          </para>
467
 
        </listitem>
468
 
      </varlistentry>
469
 
      <varlistentry>
470
 
        <term>kiss</term>
471
 
        <listitem>
472
 
          <para>
473
 
            Le Keep It Simple Stupid de G. Marsaglia,  période d'environ <literal>2^123</literal>,
474
 
            état interne donné par <literal>4</literal> entiers.
475
 
          </para>
476
 
        </listitem>
477
 
      </varlistentry>
478
 
      <varlistentry>
479
 
        <term>clcg2</term>
480
 
        <listitem>
481
 
          <para>
482
 
            Une combinaison de 2 générateurs linéaires congruentiels de P. L'Ecuyer,
483
 
            période d'environ <literal>2^61</literal>, état interne donné par <literal>2</literal> entiers ;
484
 
            c'était le seul générateur de base utilisé auparavent par grand (cette
485
 
            version est cependant légèrement différente de l'ancienne).
486
 
          </para>
487
 
        </listitem>
488
 
      </varlistentry>
489
 
      <varlistentry>
490
 
        <term>clcg4</term>
491
 
        <listitem>
492
 
          <para>
493
 
            Une combinaison de 4 générateurs linéaires congruentiels de P. L'Ecuyer,
494
 
            période d'environ <literal>2^121</literal>, état interne donné par 4 entiers ; ce générateur
495
 
            peut être partagé en <literal>101</literal> générateur virtuels (en fait la suite de
496
 
            longueur <literal>2^121</literal> peut être découpée en <literal>101</literal> sous-suites) ce qui peut
497
 
            être utile dans certains cas (voir 'Actions specifiques à clcg4' et
498
 
            'Exemple d'utilisation de clcg4').
499
 
          </para>
500
 
        </listitem>
501
 
      </varlistentry>
502
 
      <varlistentry>
503
 
        <term>fsultra</term>
504
 
        <listitem>
505
 
          <para>
506
 
            Un générateur SWB (subtract-with-borrow) mixé avec un générator congruentiel
507
 
            concu par Arif Zaman et George Marsaglia. Sa période est supérieure à <literal>10^356</literal>,
508
 
            et son état interne est constitué d'un tableau de 37 entiers, d'un index sur
509
 
            ce tableau et d'un drapeau (0 ou 1) ainsi qu'un autre entier donnant l'état interne
510
 
            du générateur congruentiel.
511
 
          </para>
512
 
        </listitem>
513
 
      </varlistentry>
514
 
      <varlistentry>
515
 
        <term>urand</term>
516
 
        <listitem>
517
 
          <para>
518
 
            Le générateur de base utilisé par la fonction
519
 
            <link linkend="rand">rand</link>, état interne constitué d'un entier, période de
520
 
            <literal>2^31</literal>.
521
 
            Ce generateur est fondé sur "Urand, A Universal Random Number Generator" By,
522
 
            Michael A. Malcolm, Cleve B. Moler, Stan-Cs-73-334, January 1973, Computer
523
 
            Science Department, School Of Humanities And Sciences, Stanford University.
524
 
            C'est le plus rapide de cette liste, mais ses qualités statistiques
525
 
            sont inférieures aux autres générateurs.
526
 
          </para>
527
 
        </listitem>
528
 
      </varlistentry>
529
 
    </variablelist>
530
 
  </refsection>
531
 
  <refsection>
532
 
    <title>Actions</title>
533
 
    <variablelist>
534
 
      <varlistentry>
535
 
        <term>action= "getgen"</term>
536
 
        <listitem>
537
 
          <para>
538
 
            <literal>S=grand("getgen")</literal> retourne le nom du générateur de base actuel (<literal>S</literal> est
539
 
            l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand",
540
 
            "fsultra").
541
 
          </para>
542
 
        </listitem>
543
 
      </varlistentry>
544
 
      <varlistentry>
545
 
        <term>action= "setgen"</term>
546
 
        <listitem>
547
 
          <para>
548
 
            <literal>grand("setgen",gen)</literal> permet de changer le générateur de base : <literal>gen</literal>
549
 
            doit être l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra".
550
 
            En cas de succès la fonction retourne cette même chaîne.
551
 
          </para>
552
 
        </listitem>
553
 
      </varlistentry>
554
 
      <varlistentry>
555
 
        <term>action= "getsd"</term>
556
 
        <listitem>
557
 
          <para>
558
 
            <literal>S=grand("getsd")</literal> retourne l'état interne actuel (les 'germes' dans l'ancienne
559
 
            appelation quoique ce terme désigne plutôt l'état initial) du générateur de base courant ;
560
 
            <literal>S</literal> est un vecteur colonne (d'entiers) de dimension <literal>625</literal>
561
 
            pour mt (la première composante étant un 'index' sur l'état, c-a-d un entier de l'intervalle
562
 
            <literal>[1,624]</literal>), <literal>4</literal>
563
 
            pour kiss, <literal>2</literal> pour clcg2 , <literal>40</literal>pour fsultra, <literal>4</literal> pour clcg4
564
 
            (pour ce dernier vous obtenez l'état interne du générateur virtuel courant), et <literal>1</literal>
565
 
            pour urand.
566
 
          </para>
567
 
        </listitem>
568
 
      </varlistentry>
569
 
      <varlistentry>
570
 
        <term>action= "setsd"</term>
571
 
        <listitem>
572
 
          <para>
573
 
            <literal>grand("setsd",S), grand("setsd",s1[,s2,s3,s4])</literal> impose l'état interne du générateur de
574
 
            base courant :
575
 
          </para>
576
 
          <variablelist>
577
 
            <varlistentry>
578
 
              <term>pour mt</term>
579
 
              <listitem>
580
 
                <para>
581
 
                  <literal>S</literal> est un vecteur d'entiers de dimension <literal>625</literal> (la première composante
582
 
                  étant un index sur <literal>[1,624]</literal>), les <literal>624</literal> dernières composantes doivent
583
 
                  être dans <literal>[0,2^32[</literal>) (mais ne doivent pas être toutes nulles) ; une initialisation
584
 
                  plus simple est possible (et recommandée) en donnant un seul entier <literal>s1</literal> (<literal>s1</literal> appartenant
585
 
                  à <literal>[0,2^32[</literal>) ;
586
 
                </para>
587
 
              </listitem>
588
 
            </varlistentry>
589
 
            <varlistentry>
590
 
              <term>pour kiss</term>
591
 
              <listitem>
592
 
                <para>
593
 
                  <literal>4</literal> entiers <literal>s1,s2, s3,s4</literal> dans <literal>[0,2^32[</literal> doivent être
594
 
                  fournis ;
595
 
                </para>
596
 
              </listitem>
597
 
            </varlistentry>
598
 
            <varlistentry>
599
 
              <term>pour clcg2</term>
600
 
              <listitem>
601
 
                <para>
602
 
                  <literal>2</literal> entiers <literal>s1</literal> dans <literal>[1,2147483562]</literal> et <literal>s2</literal>
603
 
                  dans <literal>[1,2147483398]</literal> doivent être fournis ;
604
 
                </para>
605
 
              </listitem>
606
 
            </varlistentry>
607
 
            <varlistentry>
608
 
              <term>pour clcg4</term>
609
 
              <listitem>
610
 
                <para>
611
 
                  <literal>4</literal> entiers <literal>s1</literal> dans <literal>[1,2147483646]</literal>, <literal>s2</literal>
612
 
                  dans <literal>[1,2147483542]</literal>, <literal>s3</literal> dans <literal>[1,2147483422]</literal>,
613
 
                  <literal>s4</literal> dans <literal>[1,2147483322]</literal> sont requis ;
614
 
                  <literal>ATTENTION</literal> : avec clcg4 vous positionnez l'état interne du générateur virtuel
615
 
                  courant mais vous perdez alors la synchronisation avec les autres générateurs virtuels.
616
 
                  (=&gt; si vous utilisez clcg4 avec différents générateurs virtuels, il faut utiliser
617
 
                  l'option "setall" qui permet de changer l'état interne (du générateur numéro 0) tout en
618
 
                  recalculant l'état initial des 100 autres générateurs virtuels).
619
 
                </para>
620
 
              </listitem>
621
 
            </varlistentry>
622
 
            <varlistentry>
623
 
              <term>pour urand</term>
624
 
              <listitem>
625
 
                <para>
626
 
                  <literal>1</literal> entier <literal>s1</literal> appartenant à
627
 
                  <literal>[0,2^31[</literal> est requis.
628
 
                </para>
629
 
              </listitem>
630
 
            </varlistentry>
631
 
            <varlistentry>
632
 
              <term>for fsultra</term>
633
 
              <listitem>
634
 
                <para>
635
 
                  <literal>S</literal> est un vecteur de <literal>40</literal> entiers (son premier élément doit être dans
636
 
                  l'intervalle<literal>[0,37]</literal>, son deuxième (drapeau) doit être 0 ou 1, le troisième un
637
 
                  entier de <literal>[1,2^32[</literal> et les 37 composantes suivantes, des entiers de <literal>[0,2^32[</literal>) ; il est recommandé
638
 
                  d'utiliser l'autre procédure d'initialisation (plus simple) avec deux entiers <literal>s1</literal> et
639
 
                  <literal>s2</literal> de <literal>[0,2^32[</literal>.
640
 
                </para>
641
 
              </listitem>
642
 
            </varlistentry>
643
 
          </variablelist>
644
 
        </listitem>
645
 
      </varlistentry>
646
 
      <varlistentry>
647
 
        <term>action= "phr2sd"</term>
648
 
        <listitem>
649
 
          <para>
650
 
            <literal>Sd=grand("phr2sd", phrase)</literal> étant donnée une chaîne de caractères <literal>phrase</literal>
651
 
            cet appel retourne un vecteur <literal>1 x 2</literal> qui peut être utilisé comme
652
 
            état interne pour un générateur de base (initialement adapté pour clcg2).
653
 
          </para>
654
 
        </listitem>
655
 
      </varlistentry>
656
 
    </variablelist>
657
 
  </refsection>
658
 
  <refsection>
659
 
    <title>Options specifiques à clcg4</title>
660
 
    <para>
661
 
      Le générateur clcg4 peut être utilisé comme les autres mais il offre l'avantage de pouvoir être
662
 
      découpé en (<literal>101</literal>) générateurs virtuels différents, c-a-d avec des séquences sans
663
 
      intersection (quand vous utilisez un générateur classique vous pouvez changer l'état initial
664
 
      de façon à obtenir une autre séquence mais vous n'êtes pas complètement sûr d'obtenir une
665
 
      séquence complètement différente). Chaque générateur virtuel correspond à une séquence de
666
 
      longueur <literal>2^72</literal> qui est de plus découpée en <literal>V=2^31</literal> segments de longueur
667
 
      <literal>W=2^41</literal>. Pour un générateur virtuel donné vous pouvez retourner au début de la séquence
668
 
      ou au début du segment ou bien au début du segment suivant.
669
 
      Vous pouvez aussi changer l'état initial du générateur <literal>0</literal> avec l'option
670
 
      "setall" qui recalcule l'état initial des autres générateurs virtuels de sorte à obtenir
671
 
      la synchronisation entre les générateurs (c-a-d qu'en fonction du nouvel état initial du générateur
672
 
      <literal>0</literal> l'état initial des générateurs <literal>1..100</literal> sont recalculés de façon à
673
 
      obtenir <literal>101</literal> séquences qui ne s'intersectent pas).
674
 
    </para>
675
 
    <variablelist>
676
 
      <varlistentry>
677
 
        <term>action= "setcgn"</term>
678
 
        <listitem>
679
 
          <para>
680
 
            <literal>grand("setcgn",G)</literal> sélectionne le générateur virtuel numéro <literal>G</literal> :
681
 
            lorsque le générateur de base courant est clcg4, c'est le générateur virtuel <literal>G</literal>
682
 
            qui sera alors utilisé ; les <literal>101</literal> générateurs virtuels sont numérotés
683
 
            <literal>0,1,...,100</literal> (ainsi <literal>G</literal> doit être un entier de l'intervalle
684
 
            <literal>[0,100]</literal>) ; par défaut le générateur virtuel courant est celui de numéro
685
 
            <literal>0</literal>.
686
 
          </para>
687
 
        </listitem>
688
 
      </varlistentry>
689
 
      <varlistentry>
690
 
        <term>action= "getcgn"</term>
691
 
        <listitem>
692
 
          <para>
693
 
            <literal>S=grand("getcgn")</literal> retourne le numéro du générateur
694
 
            virtuel courant.
695
 
          </para>
696
 
        </listitem>
697
 
      </varlistentry>
698
 
      <varlistentry>
699
 
        <term>action= "initgn"</term>
700
 
        <listitem>
701
 
          <para>
702
 
            <literal>grand("initgn",I)</literal> réinitialise l'état du générateur virtuel courant :
703
 
          </para>
704
 
          <variablelist>
705
 
            <varlistentry>
706
 
              <term>I = -1</term>
707
 
              <listitem>
708
 
                <para>remet l'état à sa valeur initiale</para>
709
 
              </listitem>
710
 
            </varlistentry>
711
 
            <varlistentry>
712
 
              <term>I = 0</term>
713
 
              <listitem>
714
 
                <para>remet l'état au début du segment courant</para>
715
 
              </listitem>
716
 
            </varlistentry>
717
 
            <varlistentry>
718
 
              <term>I = 1</term>
719
 
              <listitem>
720
 
                <para>
721
 
                  positionne l'état au début du segment suivant et met à jour les valeurs définissant
722
 
                  le segment courant (vous ne pouvez pas revenir au début du segment précédent).
723
 
                </para>
724
 
              </listitem>
725
 
            </varlistentry>
726
 
          </variablelist>
727
 
        </listitem>
728
 
      </varlistentry>
729
 
      <varlistentry>
730
 
        <term>action= "setall"</term>
731
 
        <listitem>
732
 
          <para>
733
 
            <literal>grand("setall",s1,s2,s3,s4)</literal> impose l'état interne du générateur virtuel
734
 
            de numéro <literal>0</literal> à <literal>s1,s2,s3,s4</literal>. L'état initial des autres générateurs est
735
 
            alors reconstruit (de façon à obtenir 101 séquences qui ne s'intersectent pas). Voir
736
 
            l'action "setsd" pour les contraintes sur <literal>s1, s2, s3, s4</literal>.
737
 
          </para>
738
 
        </listitem>
739
 
      </varlistentry>
740
 
      <varlistentry>
741
 
        <term>action= "advnst"</term>
742
 
        <listitem>
743
 
          <para>
744
 
            <literal>grand("advnst",K)</literal> avance l'état du générateur virtuel courant de <literal>2^K</literal>
745
 
            valeurs et réinitialise l'état initial (du générateur virtuel courant) à
746
 
            ce nouvel état.
747
 
          </para>
748
 
        </listitem>
749
 
      </varlistentry>
750
 
    </variablelist>
751
 
  </refsection>
752
 
  <refsection>
753
 
    <title>Exemples</title>
754
 
    <para>
755
 
      Dans l'exemple suivant, nous produisons des nombres aléatoires
756
 
      associés à différentes lois de distribution et dessinons les histogrammes
757
 
      associés.
758
 
    </para>
759
 
    <programlisting role="example"><![CDATA[ 
 
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" version="5.0-subset Scilab" 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 <literal>
 
412
                            (High-Low+1)
 
413
                            &lt; 2147483561
 
414
                        </literal>
 
415
                        .
 
416
                    </para>
 
417
                </listitem>
 
418
            </varlistentry>
 
419
            <varlistentry>
 
420
                <term>uniforme (lgi)</term>
 
421
                <listitem>
 
422
                    <para>
 
423
                        <literal>Y=grand(m,n,"lgi")</literal> retourne la sortie du générateur de base courant : des entiers
 
424
                        aléatoires suivant une loi uniforme sur :
 
425
                    </para>
 
426
                    <itemizedlist>
 
427
                        <listitem>
 
428
                            <para>
 
429
                                <literal>[0, 2^32 - 1]</literal> for mt, kiss and fsultra;
 
430
                            </para>
 
431
                        </listitem>
 
432
                        <listitem>
 
433
                            <para>
 
434
                                <literal>[0, 2147483561]</literal> for clcg2;
 
435
                            </para>
 
436
                        </listitem>
 
437
                        <listitem>
 
438
                            <para>
 
439
                                <literal>[0, 2^31 - 2]</literal> for clcg4;
 
440
                            </para>
 
441
                        </listitem>
 
442
                        <listitem>
 
443
                            <para>
 
444
                                <literal>[0, 2^31 - 1]</literal> for urand.
 
445
                            </para>
 
446
                        </listitem>
 
447
                    </itemizedlist>
 
448
                </listitem>
 
449
            </varlistentry>
 
450
        </variablelist>
 
451
    </refsection>
 
452
    <refsection>
 
453
        <title>Actions sur le(s) générateur(s) de base</title>
 
454
        <para>
 
455
            Depuis Scilab-2.7 vous avez la possibilité de choisir parmi plusieurs générateurs de base
 
456
            (donnant des entiers aléatoires suivant la loi "lgi") :
 
457
        </para>
 
458
        <variablelist>
 
459
            <varlistentry>
 
460
                <term>mt</term>
 
461
                <listitem>
 
462
                    <para>
 
463
                        Le Mersenne-Twister de M. Matsumoto and T. Nishimura, période d'environ <literal>2^19937</literal>,
 
464
                        état interne donné par <literal>624</literal> entiers (plus un index); c'est le générateur
 
465
                        par défaut.
 
466
                    </para>
 
467
                </listitem>
 
468
            </varlistentry>
 
469
            <varlistentry>
 
470
                <term>kiss</term>
 
471
                <listitem>
 
472
                    <para>
 
473
                        Le Keep It Simple Stupid de G. Marsaglia,  période d'environ <literal>2^123</literal>,
 
474
                        état interne donné par <literal>4</literal> entiers.
 
475
                    </para>
 
476
                </listitem>
 
477
            </varlistentry>
 
478
            <varlistentry>
 
479
                <term>clcg2</term>
 
480
                <listitem>
 
481
                    <para>
 
482
                        Une combinaison de 2 générateurs linéaires congruentiels de P. L'Ecuyer,
 
483
                        période d'environ <literal>2^61</literal>, état interne donné par <literal>2</literal> entiers ;
 
484
                        c'était le seul générateur de base utilisé auparavent par grand (cette
 
485
                        version est cependant légèrement différente de l'ancienne).
 
486
                    </para>
 
487
                </listitem>
 
488
            </varlistentry>
 
489
            <varlistentry>
 
490
                <term>clcg4</term>
 
491
                <listitem>
 
492
                    <para>
 
493
                        Une combinaison de 4 générateurs linéaires congruentiels de P. L'Ecuyer,
 
494
                        période d'environ <literal>2^121</literal>, état interne donné par 4 entiers ; ce générateur
 
495
                        peut être partagé en <literal>101</literal> générateur virtuels (en fait la suite de
 
496
                        longueur <literal>2^121</literal> peut être découpée en <literal>101</literal> sous-suites) ce qui peut
 
497
                        être utile dans certains cas (voir 'Actions specifiques à clcg4' et
 
498
                        'Exemple d'utilisation de clcg4').
 
499
                    </para>
 
500
                </listitem>
 
501
            </varlistentry>
 
502
            <varlistentry>
 
503
                <term>fsultra</term>
 
504
                <listitem>
 
505
                    <para>
 
506
                        Un générateur SWB (subtract-with-borrow) mixé avec un générator congruentiel
 
507
                        concu par Arif Zaman et George Marsaglia. Sa période est supérieure à <literal>10^356</literal>,
 
508
                        et son état interne est constitué d'un tableau de 37 entiers, d'un index sur
 
509
                        ce tableau et d'un drapeau (0 ou 1) ainsi qu'un autre entier donnant l'état interne
 
510
                        du générateur congruentiel.
 
511
                    </para>
 
512
                </listitem>
 
513
            </varlistentry>
 
514
            <varlistentry>
 
515
                <term>urand</term>
 
516
                <listitem>
 
517
                    <para>
 
518
                        Le générateur de base utilisé par la fonction
 
519
                        <link linkend="rand">rand</link>, état interne constitué d'un entier, période de
 
520
                        <literal>2^31</literal>.
 
521
                        Ce generateur est fondé sur "Urand, A Universal Random Number Generator" By,
 
522
                        Michael A. Malcolm, Cleve B. Moler, Stan-Cs-73-334, January 1973, Computer
 
523
                        Science Department, School Of Humanities And Sciences, Stanford University.
 
524
                        C'est le plus rapide de cette liste, mais ses qualités statistiques
 
525
                        sont inférieures aux autres générateurs.
 
526
                    </para>
 
527
                </listitem>
 
528
            </varlistentry>
 
529
        </variablelist>
 
530
    </refsection>
 
531
    <refsection>
 
532
        <title>Actions</title>
 
533
        <variablelist>
 
534
            <varlistentry>
 
535
                <term>action= "getgen"</term>
 
536
                <listitem>
 
537
                    <para>
 
538
                        <literal>S=grand("getgen")</literal> retourne le nom du générateur de base actuel (<literal>S</literal> est
 
539
                        l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand",
 
540
                        "fsultra").
 
541
                    </para>
 
542
                </listitem>
 
543
            </varlistentry>
 
544
            <varlistentry>
 
545
                <term>action= "setgen"</term>
 
546
                <listitem>
 
547
                    <para>
 
548
                        <literal>grand("setgen",gen)</literal> permet de changer le générateur de base : <literal>gen</literal>
 
549
                        doit être l'une des chaînes de caractères "mt", "kiss", "clcg2", "clcg4", "urand", "fsultra".
 
550
                        En cas de succès la fonction retourne cette même chaîne.
 
551
                    </para>
 
552
                </listitem>
 
553
            </varlistentry>
 
554
            <varlistentry>
 
555
                <term>action= "getsd"</term>
 
556
                <listitem>
 
557
                    <para>
 
558
                        <literal>S=grand("getsd")</literal> retourne l'état interne actuel (les 'germes' dans l'ancienne
 
559
                        appelation quoique ce terme désigne plutôt l'état initial) du générateur de base courant ;
 
560
                        <literal>S</literal> est un vecteur colonne (d'entiers) de dimension <literal>625</literal>
 
561
                        pour mt (la première composante étant un 'index' sur l'état, c-a-d un entier de l'intervalle
 
562
                        <literal>[1,624]</literal>), <literal>4</literal>
 
563
                        pour kiss, <literal>2</literal> pour clcg2 , <literal>40</literal>pour fsultra, <literal>4</literal> pour clcg4
 
564
                        (pour ce dernier vous obtenez l'état interne du générateur virtuel courant), et <literal>1</literal>
 
565
                        pour urand.
 
566
                    </para>
 
567
                </listitem>
 
568
            </varlistentry>
 
569
            <varlistentry>
 
570
                <term>action= "setsd"</term>
 
571
                <listitem>
 
572
                    <para>
 
573
                        <literal>grand("setsd",S), grand("setsd",s1[,s2,s3,s4])</literal> impose l'état interne du générateur de
 
574
                        base courant :
 
575
                    </para>
 
576
                    <variablelist>
 
577
                        <varlistentry>
 
578
                            <term>pour mt</term>
 
579
                            <listitem>
 
580
                                <para>
 
581
                                    <literal>S</literal> est un vecteur d'entiers de dimension <literal>625</literal> (la première composante
 
582
                                    étant un index sur <literal>[1,624]</literal>), les <literal>624</literal> dernières composantes doivent
 
583
                                    être dans <literal>[0,2^32[</literal>) (mais ne doivent pas être toutes nulles) ; une initialisation
 
584
                                    plus simple est possible (et recommandée) en donnant un seul entier <literal>s1</literal> (<literal>s1</literal> appartenant
 
585
                                    à <literal>[0,2^32[</literal>) ;
 
586
                                </para>
 
587
                            </listitem>
 
588
                        </varlistentry>
 
589
                        <varlistentry>
 
590
                            <term>pour kiss</term>
 
591
                            <listitem>
 
592
                                <para>
 
593
                                    <literal>4</literal> entiers <literal>s1,s2, s3,s4</literal> dans <literal>[0,2^32[</literal> doivent être
 
594
                                    fournis ;
 
595
                                </para>
 
596
                            </listitem>
 
597
                        </varlistentry>
 
598
                        <varlistentry>
 
599
                            <term>pour clcg2</term>
 
600
                            <listitem>
 
601
                                <para>
 
602
                                    <literal>2</literal> entiers <literal>s1</literal> dans <literal>[1,2147483562]</literal> et <literal>s2</literal>
 
603
                                    dans <literal>[1,2147483398]</literal> doivent être fournis ;
 
604
                                </para>
 
605
                            </listitem>
 
606
                        </varlistentry>
 
607
                        <varlistentry>
 
608
                            <term>pour clcg4</term>
 
609
                            <listitem>
 
610
                                <para>
 
611
                                    <literal>4</literal> entiers <literal>s1</literal> dans <literal>[1,2147483646]</literal>, <literal>s2</literal>
 
612
                                    dans <literal>[1,2147483542]</literal>, <literal>s3</literal> dans <literal>[1,2147483422]</literal>,
 
613
                                    <literal>s4</literal> dans <literal>[1,2147483322]</literal> sont requis ;
 
614
                                    <literal>ATTENTION</literal> : avec clcg4 vous positionnez l'état interne du générateur virtuel
 
615
                                    courant mais vous perdez alors la synchronisation avec les autres générateurs virtuels.
 
616
                                    (=&gt; si vous utilisez clcg4 avec différents générateurs virtuels, il faut utiliser
 
617
                                    l'option "setall" qui permet de changer l'état interne (du générateur numéro 0) tout en
 
618
                                    recalculant l'état initial des 100 autres générateurs virtuels).
 
619
                                </para>
 
620
                            </listitem>
 
621
                        </varlistentry>
 
622
                        <varlistentry>
 
623
                            <term>pour urand</term>
 
624
                            <listitem>
 
625
                                <para>
 
626
                                    <literal>1</literal> entier <literal>s1</literal> appartenant à
 
627
                                    <literal>[0,2^31[</literal> est requis.
 
628
                                </para>
 
629
                            </listitem>
 
630
                        </varlistentry>
 
631
                        <varlistentry>
 
632
                            <term>for fsultra</term>
 
633
                            <listitem>
 
634
                                <para>
 
635
                                    <literal>S</literal> est un vecteur de <literal>40</literal> entiers (son premier élément doit être dans
 
636
                                    l'intervalle<literal>[0,37]</literal>, son deuxième (drapeau) doit être 0 ou 1, le troisième un
 
637
                                    entier de <literal>[1,2^32[</literal> et les 37 composantes suivantes, des entiers de <literal>[0,2^32[</literal>) ; il est recommandé
 
638
                                    d'utiliser l'autre procédure d'initialisation (plus simple) avec deux entiers <literal>s1</literal> et
 
639
                                    <literal>s2</literal> de <literal>[0,2^32[</literal>.
 
640
                                </para>
 
641
                            </listitem>
 
642
                        </varlistentry>
 
643
                    </variablelist>
 
644
                </listitem>
 
645
            </varlistentry>
 
646
            <varlistentry>
 
647
                <term>action= "phr2sd"</term>
 
648
                <listitem>
 
649
                    <para>
 
650
                        <literal>Sd=grand("phr2sd", phrase)</literal> étant donnée une chaîne de caractères <literal>phrase</literal>
 
651
                        cet appel retourne un vecteur <literal>1 x 2</literal> qui peut être utilisé comme
 
652
                        état interne pour un générateur de base (initialement adapté pour clcg2).
 
653
                    </para>
 
654
                </listitem>
 
655
            </varlistentry>
 
656
        </variablelist>
 
657
    </refsection>
 
658
    <refsection>
 
659
        <title>Options specifiques à clcg4</title>
 
660
        <para>
 
661
            Le générateur clcg4 peut être utilisé comme les autres mais il offre l'avantage de pouvoir être
 
662
            découpé en (<literal>101</literal>) générateurs virtuels différents, c-a-d avec des séquences sans
 
663
            intersection (quand vous utilisez un générateur classique vous pouvez changer l'état initial
 
664
            de façon à obtenir une autre séquence mais vous n'êtes pas complètement sûr d'obtenir une
 
665
            séquence complètement différente). Chaque générateur virtuel correspond à une séquence de
 
666
            longueur <literal>2^72</literal> qui est de plus découpée en <literal>V=2^31</literal> segments de longueur
 
667
            <literal>W=2^41</literal>. Pour un générateur virtuel donné vous pouvez retourner au début de la séquence
 
668
            ou au début du segment ou bien au début du segment suivant.
 
669
            Vous pouvez aussi changer l'état initial du générateur <literal>0</literal> avec l'option
 
670
            "setall" qui recalcule l'état initial des autres générateurs virtuels de sorte à obtenir
 
671
            la synchronisation entre les générateurs (c-a-d qu'en fonction du nouvel état initial du générateur
 
672
            <literal>0</literal> l'état initial des générateurs <literal>1..100</literal> sont recalculés de façon à
 
673
            obtenir <literal>101</literal> séquences qui ne s'intersectent pas).
 
674
        </para>
 
675
        <variablelist>
 
676
            <varlistentry>
 
677
                <term>action= "setcgn"</term>
 
678
                <listitem>
 
679
                    <para>
 
680
                        <literal>grand("setcgn",G)</literal> sélectionne le générateur virtuel numéro <literal>G</literal> :
 
681
                        lorsque le générateur de base courant est clcg4, c'est le générateur virtuel <literal>G</literal>
 
682
                        qui sera alors utilisé ; les <literal>101</literal> générateurs virtuels sont numérotés
 
683
                        <literal>0,1,...,100</literal> (ainsi <literal>G</literal> doit être un entier de l'intervalle
 
684
                        <literal>[0,100]</literal>) ; par défaut le générateur virtuel courant est celui de numéro
 
685
                        <literal>0</literal>.
 
686
                    </para>
 
687
                </listitem>
 
688
            </varlistentry>
 
689
            <varlistentry>
 
690
                <term>action= "getcgn"</term>
 
691
                <listitem>
 
692
                    <para>
 
693
                        <literal>S=grand("getcgn")</literal> retourne le numéro du générateur
 
694
                        virtuel courant.
 
695
                    </para>
 
696
                </listitem>
 
697
            </varlistentry>
 
698
            <varlistentry>
 
699
                <term>action= "initgn"</term>
 
700
                <listitem>
 
701
                    <para>
 
702
                        <literal>grand("initgn",I)</literal> réinitialise l'état du générateur virtuel courant :
 
703
                    </para>
 
704
                    <variablelist>
 
705
                        <varlistentry>
 
706
                            <term>I = -1</term>
 
707
                            <listitem>
 
708
                                <para>remet l'état à sa valeur initiale</para>
 
709
                            </listitem>
 
710
                        </varlistentry>
 
711
                        <varlistentry>
 
712
                            <term>I = 0</term>
 
713
                            <listitem>
 
714
                                <para>remet l'état au début du segment courant</para>
 
715
                            </listitem>
 
716
                        </varlistentry>
 
717
                        <varlistentry>
 
718
                            <term>I = 1</term>
 
719
                            <listitem>
 
720
                                <para>
 
721
                                    positionne l'état au début du segment suivant et met à jour les valeurs définissant
 
722
                                    le segment courant (vous ne pouvez pas revenir au début du segment précédent).
 
723
                                </para>
 
724
                            </listitem>
 
725
                        </varlistentry>
 
726
                    </variablelist>
 
727
                </listitem>
 
728
            </varlistentry>
 
729
            <varlistentry>
 
730
                <term>action= "setall"</term>
 
731
                <listitem>
 
732
                    <para>
 
733
                        <literal>grand("setall",s1,s2,s3,s4)</literal> impose l'état interne du générateur virtuel
 
734
                        de numéro <literal>0</literal> à <literal>s1,s2,s3,s4</literal>. L'état initial des autres générateurs est
 
735
                        alors reconstruit (de façon à obtenir 101 séquences qui ne s'intersectent pas). Voir
 
736
                        l'action "setsd" pour les contraintes sur <literal>s1, s2, s3, s4</literal>.
 
737
                    </para>
 
738
                </listitem>
 
739
            </varlistentry>
 
740
            <varlistentry>
 
741
                <term>action= "advnst"</term>
 
742
                <listitem>
 
743
                    <para>
 
744
                        <literal>grand("advnst",K)</literal> avance l'état du générateur virtuel courant de <literal>2^K</literal>
 
745
                        valeurs et réinitialise l'état initial (du générateur virtuel courant) à
 
746
                        ce nouvel état.
 
747
                    </para>
 
748
                </listitem>
 
749
            </varlistentry>
 
750
        </variablelist>
 
751
    </refsection>
 
752
    <refsection>
 
753
        <title>Exemples</title>
 
754
        <para>
 
755
            Dans l'exemple suivant, nous produisons des nombres aléatoires
 
756
            associés à différentes lois de distribution et dessinons les histogrammes
 
757
            associés.
 
758
        </para>
 
759
        <programlisting role="example"><![CDATA[ 
760
760
// Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
761
761
// avec une distribution normale de moyenne 0 et d'écart-type 1. 
762
762
R = grand(400,800,"nor",0,1);
763
763
scf();
764
764
histplot(10,R);
765
765
xtitle("Nombres aléatoires (loi normale) par grand","X","Fréquence");
 
766
 ]]></programlisting>
 
767
<scilab:image localized="true">
 
768
R = grand(400,800,"nor",0,1);
 
769
histplot(10,R);
 
770
xtitle("Nombres aléatoires (loi normale) par grand","X","Fréquence");
 
771
</scilab:image>
 
772
        <programlisting role="example"><![CDATA[ 
766
773
// Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
767
774
// uniformes dans [0,1).
768
775
R = grand(400,800,"def");
769
776
scf();
770
777
histplot(10,R);
771
778
xtitle("Nombres aléatoires uniformes par grand","X","Fréquence");
 
779
 ]]></programlisting>
 
780
<scilab:image localized="true">
 
781
R = grand(400,800,"def");
 
782
histplot(10,R);
 
783
xtitle("Nombres aléatoires uniformes par grand","X","Fréquence");
 
784
</scilab:image>
 
785
        <programlisting role="example"><![CDATA[ 
772
786
// Renvoit une matrice de taille 400-par-800 de doubles aléatoires, 
773
787
// avec une distribution de Poisson de moyenne 5.
774
788
R = grand(400,800,"poi",5);
776
790
histplot(10,R);
777
791
xtitle("Nombres aléatoires (loi de Poisson) par grand","X","Fréquence");
778
792
 ]]></programlisting>
779
 
    <para>
780
 
      Dans l'exemple suivant, nous produisons des nombres aléatoires
781
 
      suivant la loi exponentielle et comparons ensuite la distribution empirique
782
 
      et la fonction de distribution théorique.
783
 
    </para>
784
 
    <programlisting role="example"><![CDATA[ 
 
793
<scilab:image localized="true">
 
794
R = grand(400,800,"poi",5);
 
795
histplot(10,R);
 
796
xtitle("Nombres aléatoires (loi de Poisson) par grand","X","Fréquence");
 
797
</scilab:image>
 
798
        <para>
 
799
            Dans l'exemple suivant, nous produisons des nombres aléatoires
 
800
            suivant la loi exponentielle et comparons ensuite la distribution empirique
 
801
            et la fonction de distribution théorique.
 
802
        </para>
 
803
        <programlisting role="example"><![CDATA[ 
785
804
lambda=1.6;
786
805
N=100000;
787
806
X = grand(1,N,"exp",lambda);
794
813
legend(["Empirique" "Theorique"]);
795
814
xtitle("Loi exponentielle par grand","X","Fréquence");
796
815
 ]]></programlisting>
797
 
    <para>
798
 
      Dans l'exemple suivant, nous générons des nombres aléatoires selon la distribution
799
 
      gamma et comparons la distribution empirique et la loi de distribution théorique.
800
 
    </para>
801
 
    <programlisting role="example"><![CDATA[ 
 
816
<scilab:image localized="true">
 
817
lambda=1.6;
 
818
N=100000;
 
819
X = grand(1,N,"exp",lambda);
 
820
classes = linspace(0,12,25);
 
821
histplot(classes,X)
 
822
x=linspace(0,12,25);
 
823
y = (1/lambda)*exp(-(1/lambda)*x);
 
824
plot(x,y,"ro-");
 
825
legend(["Empirique" "Theorique"]);
 
826
xtitle("Loi exponentielle par grand","X","Fréquence");
 
827
</scilab:image>
 
828
        <para>
 
829
            Dans l'exemple suivant, nous générons des nombres aléatoires selon la distribution
 
830
            gamma et comparons la distribution empirique et la loi de distribution théorique.
 
831
        </para>
 
832
        <programlisting role="example"><![CDATA[ 
802
833
N=10000;
803
834
A=10;
804
835
B=4;
805
 
R=grand(1,N,"gam",A,B); 
 
836
R=grand(1,N,"gam",A,B);
806
837
XS=gsort(R,"g","i")';
807
838
PS=(1:N)'/N;
808
839
P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
812
843
legend(["Empirique" "Théorique"]);
813
844
xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma","X","F");
814
845
 ]]></programlisting>
815
 
    <para>
816
 
      Dans l'exemple suivant, nous générons 10 entiers aléatoires dans l'intervalle [1,365].
817
 
    </para>
818
 
    <programlisting role="example"><![CDATA[ 
 
846
<scilab:image localized="true">
 
847
N=10000;
 
848
A=10;
 
849
B=4;
 
850
R=grand(1,N,"gam",A,B); 
 
851
XS=gsort(R,"g","i")';
 
852
PS=(1:N)'/N;
 
853
P=cdfgam("PQ",XS,A*ones(XS),B*ones(XS));
 
854
plot(XS,PS,"b-");
 
855
plot(XS,P,"r-");
 
856
legend(["Empirique" "Théorique"]);
 
857
xtitle("Fonction de distribution cumulée de nombres aléatoires selon la loi Gamma","X","F");
 
858
</scilab:image>
 
859
        <para>
 
860
            Dans l'exemple suivant, nous générons 10 entiers aléatoires dans l'intervalle [1,365].
 
861
        </para>
 
862
        <programlisting role="example"><![CDATA[ 
819
863
grand(10,1,"uin",1,365)
820
864
 ]]></programlisting>
821
 
    <para>
822
 
      Dans l'exemple suivant, nous générons 12 permutations de l'ensemble [1,2,...,7].
823
 
      Les 12 permutations sont stockées colonne par colonne.
824
 
    </para>
825
 
    <programlisting role="example"><![CDATA[ 
 
865
        <para>
 
866
            Dans l'exemple suivant, nous générons 12 permutations de l'ensemble [1,2,...,7].
 
867
            Les 12 permutations sont stockées colonne par colonne.
 
868
        </para>
 
869
        <programlisting role="example"><![CDATA[ 
826
870
grand(12,"prm",(1:7)')
827
871
 ]]></programlisting>
828
 
  </refsection>
829
 
  <refsection>
830
 
    <title>Produire des nombres prévisibles ou moins prévisibles</title>
831
 
    <para>
832
 
      Les générateurs pseudo aléatoires sont fondés sur des séquences déterministes.
833
 
      Pour produire des simulations reproductibles, la graine du générateur est constante,
834
 
      de telle sorte que la séquence est la même d'une session à l'autre.
835
 
      En conséquence, par défaut, les premiers nombres produis par <literal>grand</literal>
836
 
      sont toujours les mêmes.
837
 
    </para>
838
 
    <para>
839
 
      Dans certaines situations, nous peut vouloir initialiser la graine du générateur
840
 
      dans le but de produire des nombres moins prédictibles.
841
 
      Dans ce cas, on peut initialiser la graine avec la sortie de la fonction <literal>getdate</literal> :
842
 
    </para>
843
 
    <programlisting role="example"><![CDATA[
 
872
    </refsection>
 
873
    <refsection>
 
874
        <title>Produire des nombres prévisibles ou moins prévisibles</title>
 
875
        <para>
 
876
            Les générateurs pseudo aléatoires sont fondés sur des séquences déterministes.
 
877
            Pour produire des simulations reproductibles, la graine du générateur est constante,
 
878
            de telle sorte que la séquence est la même d'une session à l'autre.
 
879
            En conséquence, par défaut, les premiers nombres produis par <literal>grand</literal>
 
880
            sont toujours les mêmes.
 
881
        </para>
 
882
        <para>
 
883
            Dans certaines situations, nous peut vouloir initialiser la graine du générateur
 
884
            dans le but de produire des nombres moins prédictibles.
 
885
            Dans ce cas, on peut initialiser la graine avec la sortie de la fonction <literal>getdate</literal> :
 
886
        </para>
 
887
        <programlisting role="example"><![CDATA[
844
888
n=getdate("s");
845
889
grand("setsd",n)
846
890
    ]]></programlisting>
847
 
  </refsection>
848
 
  <refsection>
849
 
    <title>Exemple d'utilisation de clcg4</title>
850
 
    <para>
851
 
      On cherche à comparer deux techniques statistiques sur des données de tailles différentes.
852
 
      La première, utilisant le 'bootstrapping' est supposée a priori aussi précise que
853
 
      la deuxième technique (utilisant uniquement la force brute) tout en utilisant moins
854
 
      de données. Pour la première méthode, un ensemble de données de taille n1, uniformément
855
 
      distribuée entre 25 et 50 devra être généré puis analysé par la méthode.  Pour la
856
 
      seconde méthode, on procède de même avec une taille n2 à choisir entre 100 et 200. Ce processus
857
 
      est répété 1000 fois. Pour la réduction de la variance, on veut que les nombres aléatoires
858
 
      utilisés dans les deux méthodes soient les mêmes pour chacune des 1000 comparaisons.
859
 
      Comme la deuxième méthode utilise plus de nombres aléatoires, la synchronisation
860
 
      peut être difficile si l'on utilise un générateur classique. Avec un générateur
861
 
      comme clcg4 c'est par contre très simple : utilisez le générateur 0 pour obtenir
862
 
      la taille n1 du jeux de données et le générateur 1 pour obtenir les données.
863
 
      Avec le générateur 0 tirer la taille n2 puis resélectionner le générateur 1 et revenez
864
 
      au début du segment courant pour obtenir les n2 données pour la deuxième méthode : ainsi
865
 
      les données initiales (les n1 premieres) sont les mêmes pour les deux méthodes.
866
 
      Pour la comparaison suivante, il suffit d'avancer le générateur 1 au segment suivant,
867
 
      etc...
868
 
    </para>
869
 
  </refsection>
870
 
  <refsection role="see also">
871
 
    <title>Voir aussi</title>
872
 
    <simplelist type="inline">
873
 
      <member>
874
 
        <link linkend="rand">rand</link>
875
 
      </member>
876
 
      <member>
877
 
        <link linkend="sprand">sprand</link>
878
 
      </member>
879
 
      <member>
880
 
        <link linkend="ssrand">ssrand</link>
881
 
      </member>
882
 
    </simplelist>
883
 
  </refsection>
 
891
    </refsection>
 
892
    <refsection>
 
893
        <title>Exemple d'utilisation de clcg4</title>
 
894
        <para>
 
895
            On cherche à comparer deux techniques statistiques sur des données de tailles différentes.
 
896
            La première, utilisant le 'bootstrapping' est supposée a priori aussi précise que
 
897
            la deuxième technique (utilisant uniquement la force brute) tout en utilisant moins
 
898
            de données. Pour la première méthode, un ensemble de données de taille n1, uniformément
 
899
            distribuée entre 25 et 50 devra être généré puis analysé par la méthode.  Pour la
 
900
            seconde méthode, on procède de même avec une taille n2 à choisir entre 100 et 200. Ce processus
 
901
            est répété 1000 fois. Pour la réduction de la variance, on veut que les nombres aléatoires
 
902
            utilisés dans les deux méthodes soient les mêmes pour chacune des 1000 comparaisons.
 
903
            Comme la deuxième méthode utilise plus de nombres aléatoires, la synchronisation
 
904
            peut être difficile si l'on utilise un générateur classique. Avec un générateur
 
905
            comme clcg4 c'est par contre très simple : utilisez le générateur 0 pour obtenir
 
906
            la taille n1 du jeux de données et le générateur 1 pour obtenir les données.
 
907
            Avec le générateur 0 tirer la taille n2 puis resélectionner le générateur 1 et revenez
 
908
            au début du segment courant pour obtenir les n2 données pour la deuxième méthode : ainsi
 
909
            les données initiales (les n1 premieres) sont les mêmes pour les deux méthodes.
 
910
            Pour la comparaison suivante, il suffit d'avancer le générateur 1 au segment suivant,
 
911
            etc...
 
912
        </para>
 
913
    </refsection>
 
914
    <refsection role="see also">
 
915
        <title>Voir aussi</title>
 
916
        <simplelist type="inline">
 
917
            <member>
 
918
                <link linkend="rand">rand</link>
 
919
            </member>
 
920
            <member>
 
921
                <link linkend="sprand">sprand</link>
 
922
            </member>
 
923
            <member>
 
924
                <link linkend="ssrand">ssrand</link>
 
925
            </member>
 
926
        </simplelist>
 
927
    </refsection>
884
928
</refentry>