Generating Random Numbers/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1		-	~~<figure>~~
2		-	~~<img src="fpc_source_logo.png" title="fpc_source_logo.png" />~~
3		-	~~<figcaption>fpc_source_logo.png</figcaption>~~
4		-	~~</figure>~~
	1	+	![](/wiki-images/8/84/Fpc_source_logo.png)
5	2
6	3		(Ndt : quelques réserves sur la traduction, n'étant pas spécialiste)
7	4
8	5		Les nombres aléatoires sont une importante ressource pour les applications scientifiques, l'éducation, le développement de jeu et la visualisation. Ils jouent un rôle clé dans la simulation scientifique.
9	6
10	7		les nombres aléatoires générés par des algorithmes sont des nombres pseudo-aléatoires. Ils appartiennent à un (large) ensemble de nombres répétitifs, en une suite qui est impossible ou au moins difficilement prédictible. Contrairement à Delphi, Free Pascal utilise un algorithme MersenneTwister pour sa fonction standard [[doc:rtl/system/random.html\|random]] comme définie dans la [[RTL/fr\|RTL]]. Avant sa première utilisation, le générateur de nombres aléatoires doit être initialisé avec un simple appel à la fonction [[doc:rtl/system/randomize.html\|randomize]], laquelle mets la graine du générateur. De préférence, cela est fait à la phase de lancement du programme.
11	8
12	9		Alternativement, dans les systèmes basés sur Linux et Unix, les périphériques virtuels [[Dev random\|/dev/random]] et `/dev/urandom` sont disponibles. Ils générent des nombres (pseudo) aléatoires basés sur le matériel.
13	10
14	11		Une troisième option est d'utiliser des nombres aléatoires depuis une source externe, comme des périphériques spécialisés ou depuis des sources publiques, p.ex. basées sur des données de désintégration nucléaire.
15	12
16	13		## Loi uniforme
17	14
18	15		La loi uniforme (aussi appelée loi rectangulaire) représente une famille de loi de probabilité symétriques. Là, pour chaque membre de la famille, tous les intervalles de même longueur sur le support de la loi sont également probable.
19	16
20	17		La fonction standard [[RTL/fr\|RTL]] [[doc:rtl/system/random.html\|random]] génère des nombres aléatoires qui remplissent une loi uniforme. Si appelée sans paramètre, `random` délivre un nombre flottant pseudo-aléatoire dans l'intervalle \[0,1\[ (i.e. 0 \<= result \< 1). Si `random` est appelée avec un argument Longint L, elle délivre un Longint aléatoire dans l'intervalle \[0, L\[. Pour créer des nombres aléatoires, d'autres algorithmes de loi spéciales sont nécessaires.
21	18
22	19		## Loi Normale (gaussienne)
23	20
24	21		Un des algorithmes les plus courants pour produire des nombres aléatoires normalement distribués depuis des nombres aléatoires uniformément distribués est [l'approche de Box-Müller](https://fr.wikipedia.org/wiki/M%C3%A9thode_de_Box-Muller). La fonction suivante calcule des nombres aléatoires selon une distribution gaussienne :
25	22
26	23		``` pascal
27	24		function rnorm (mean, sd: real): real;
28	25		{Calculates Gaussian random numbers according to the Box-Müller approach}
29	26		var
30	27		u1, u2: real;
31	28		begin
32	29		u1 := random;
33	30		u2 := random;
34	31		rnorm := mean * abs(1 + sqrt(-2 * (ln(u1))) * cos(2 * pi * u2) * sd);
35	32		end;
36	33		```
37	34
38	35		Le même algorithme est utilisé par la fonction [[doc:rtl/math/randg.html\|randg]] de l'unité [[RTL/fr\|RTL]] [[doc:rtl/math/index.html\|math]] :
39	36
40	37		``` pascal
41	38		function randg(mean,stddev: float): float;
42	39		```
43	40
44	41		## Loi Exponentielle
45	42
46	43		Une loi exponentielle se rencontre souvent dans les problèmes du monde réel. Un exemple classique est la distribution des temps d'attente entre des événements Poisson-aléatoire indépendants, p.ex. la désintégration radioactive des noyaux \[Press et al. 1989\].
47	44
48	45		La fonction suivante délivre un nombre aléatoire en réel à partir de la loi exponentielle. Rate est l'inverse de la moyenne, et la constante RESOLUTION détermine la granularité des nombres aléatoires générés.
49	46
50	47		``` pascal
51	48		function randomExp(a, rate: real): real;
52	49		const
53	50		RESOLUTION = 1000;
54	51		var
55	52		unif: real;
56	53		begin
57	54		if rate = 0 then
58	55		randomExp := NaN
59	56		else
60	57		begin
61	58		repeat
62	59		unif := random(RESOLUTION) / RESOLUTION;
63	60		until unif <> 0;
64	61		randomExp := a - rate * ln(unif);
65	62		end;
66	63		end;
67	64		```
68	65
69	66		## Loi Gamma
70	67
71	68		La loi gamma est une famille à deux paramètres de distributions aléatoires continues. C'est une généralisation à la fois de la loi exponentielle et de la loi d'Erlang. Les applications possibles de la loi gamma incluent la modélisation et la simulation des files d'attente et la science actuarielle.
72	69
73	70		La fonction suivante délivre un nombre aléatoire réel à partir d'une gamma. La structure de la distribution est définie par les paramètres a, b et c. La fonction fait usage de la fonction randomExp définie ci-dessus.
74	71
75	72		``` pascal
76	73		function randomGamma(a, b, c: real): real;
77	74		const
78	75		RESOLUTION = 1000;
79	76		T = 4.5;
80	77		D = 1 + ln(T);
81	78		var
82	79		unif: real;
83	80		A2, B2, C2, Q, p, y: real;
84	81		p1, p2, v, w, z: real;
85	82		found: boolean;
86	83		begin
87	84		A2 := 1 / sqrt(2 * c - 1);
88	85		B2 := c - ln(4);
89	86		Q := c + 1 / A2;
90	87		C2 := 1 + c / exp(1);
91	88		found := False;
92	89		if c < 1 then
93	90		begin
94	91		repeat
95	92		repeat
96	93		unif := random(RESOLUTION) / RESOLUTION;
97	94		until unif > 0;
98	95		p := C2 * unif;
99	96		if p > 1 then
100	97		begin
101	98		repeat
102	99		unif := random(RESOLUTION) / RESOLUTION;
103	100		until unif > 0;
104	101		y := -ln((C2 - p) / c);
105	102		if unif <= power(y, c - 1) then
106	103		begin
107	104		randomGamma := a + b * y;
108	105		found := True;
109	106		end;
110	107		end
111	108		else
112	109		begin
113	110		y := power(p, 1 / c);
114	111		if unif <= exp(-y) then
115	112		begin
116	113		randomGamma := a + b * y;
117	114		found := True;
118	115		end;
119	116		end;
120	117		until found;
121	118		end
122	119		else if c = 1 then
123	120		{ Gamma distribution becomes exponential distribution, if c = 1 }
124	121		begin
125	122		randomGamma := randomExp(a, b);
126	123		end
127	124		else
128	125		begin
129	126		repeat
130	127		repeat
131	128		p1 := random(RESOLUTION) / RESOLUTION;
132	129		until p1 > 0;
133	130		repeat
134	131		p2 := random(RESOLUTION) / RESOLUTION;
135	132		until p2 > 0;
136	133		v := A2 * ln(p1 / (1 - p1));
137	134		y := c * exp(v);
138	135		z := p1 * p1 * p2;
139	136		w := B2 + Q * v - y;
140	137		if (w + D - T * z >= 0) or (w >= ln(z)) then
141	138		begin
142	139		randomGamma := a + b * y;
143	140		found := True;
144	141		end;
145	142		until found;
146	143		end;
147	144		end;
148	145		```
149	146
150	147		## Loi d'Erlang
151	148
152	149		La loi d'Erlang est une famille à deux paramètres de distributions de probabilité continues. C'est une généralisation de la loi exponentielle et un cas particulier de la loi gamma, où c est un entier. L loi d'Erlang La loi d'Erlang a été décrite d'abord par [Agner Krarup Erlang](https://fr.wikipedia.org/wiki/Agner_Krarup_Erlang) en vue de modéliser le délai entre des appels téléphoniques. Elle est utilisée dans la théorie des files d'attente et pour simuler les files d'attente.
153	150
154	151		``` pascal
155	152		function randomErlang(mean: real; k: integer): real;
156	153		const
157	154		RESOLUTION = 1000;
158	155		var
159	156		i: integer;
160	157		unif, prod: real;
161	158		begin
162	159		if (mean <= 0) or (k < 1) then
163	160		randomErlang := NaN
164	161		else
165	162		begin
166	163		prod := 1;
167	164		for i := 1 to k do
168	165		begin
169	166		repeat
170	167		unif := random(RESOLUTION) / RESOLUTION;
171	168		until unif <> 0;
172	169		prod := prod * unif;
173	170		end;
174	171		randomErlang := -mean * ln(prod);
175	172		end;
176	173		end;
177	174		```
178	175
179	176		## Loi de Poisson
180	177
181	178		La loi de Poisson s'applique aux valeurs entières. Elle représente la probabilité de k succès, quand la probabilité de réussite à chaque essai est petite et le taux d'occurrences (la valeur mpoyenne) est constant.
182	179
183	180		``` pascal
184	181		function randomPoisson(mean: integer): integer;
185	182		{ Generator for Poisson distribution (Donald Knuth's algorithm) }
186	183		const
187	184		RESOLUTION = 1000;
188	185		var
189	186		k: integer;
190	187		b, l: real;
191	188		begin
192	189		assert(mean > 0, 'mean < 1');
193	190		k := 0;
194	191		b := 1;
195	192		l := exp(-mean);
196	193		while b > l do
197	194		begin
198	195		k := k + 1;
199	196		b := b * random(RESOLUTION) / RESOLUTION;
200	197		end;
201	198		randomPoisson := k - 1;
202	199		end;
203	200		```
204	201
205	202		## Loi t
206	203
207	204		La loi t (également appelée loi t de Student, puisqu'elle a été publiée par William Sealy Gosset en 1908 sous le pseudonyme Student) est une loi de probabilité continue. Sa structure est définie par un paramètre, le degré de liberté (df). En statistiques, plusieurs estimateurs sont t-distribués. Donc, la loi t de Student joue un rôle majeur dans nombre d'analyses statistiques largement utilisées, incluant le t-test de Student pour évaluer l'importance statistique de la différence entre deux moyennes d'échantillonnage, la construction d'intervalle de confiance pour la différence entre deux moyennes de population et dans les analyses de régression linéaire. La loi t surgit aussi dans l'analyse de donnée bayésienne d'une famille normale.
208	205
209	206		L'algorithme suivant dépend de la fonction [[doc:rtl/system/random.html\|random]] de la [[RTL/fr\|RTL]] et de la fonction randomChisq.
210	207
211	208		``` pascal
212	209		function randomT(df: integer): real;
213	210		{ Generator for Student's t distribution }
214	211		begin
215	212		if df < 1 then randomT := NaN
216	213		else
217	214		begin
218	215		randomT := randg(0, 1) / sqrt(randomChisq(df) / df);
219	216		end;
220	217		end;
221	218		```
222	219
223	220		## Loi Chi carré
224	221
225	222		La loi Chi carré est une loi continue de nombres aléatoires avec df degrés de liberté. C'est la loi de la somme des carrés de df variables aléatoires normal standard indépendantes. La loi Chi carré a de nombreuses applications en statistiques inférentielles, p.ex. dans l'estimation de la variance et pour les tests chi-carré. C'est une loi gamma spéciale avec c = df/ 2 et b = 2. Donc, la fonction suivante dépend de la fonction randomGamma.
226	223
227	224		``` pascal
228	225		function randomChisq(df: integer): real;
229	226		begin
230	227		if df < 1 then randomChisq := NaN
231	228		else
232	229		randomChisq := randomGamma(0, 2, 0.5 * df);
233	230		end;
234	231		```
235	232
236	233		## Loi F
237	234
238	235		La loi F, appelée aussi loi Fisher-Snedecor, est un loi de probabilité continue. Elle est utilisée pour le test F et l'ANOVA. Elle a deux degrés de liberté qui serve de paramètre de structure v et w qui sont des entiers positifs. La fonction suivante randomF fait usage de randomChisq.
239	236
240	237		``` pascal
241	238		function randomF(v, w: integer): real;
242	239		begin
243	240		if (v < 1) or (w < 1) then
244	241		randomF := NaN
245	242		else
246	243		randomF := randomChisq(v) / v / (randomChisq(w) / w);
247	244		end;
248	245		```
249	246
250	247		## Voir aussi
251	248
252	249		- [[Dev random/fr\|Dev random]]
253	250		- [[Functions for descriptive statistics/fr\|Fonctions pour la statistique descriptive]]
254	251
255	252		## Références
256	253
257	254		(non traduit...)
258	255
259	256		1. [G. E. P. Box and Mervin E. Muller, A Note on the Generation of Random Normal Deviates, The Annals of Mathematical Statistics (1958), Vol. 29, No. 2 pp. 610–611](http://projecteuclid.org/DPubS/Repository/1.0/Disseminate?view=body&id=pdf_1&handle=euclid.aoms/1177706645)
260	257		2. Dietrich, J. W. (2002). [Der Hypophysen-Schilddrüsen-Regelkreis](http://openlibrary.org/books/OL24586469M/Der_Hypophysen-Schilddrüsen-Regelkreis). Berlin, Germany: Logos-Verlag Berlin. ISBN 978-3-89722-850-4. OCLC 50451543.
261	258		3. Press, W. H., B. P. Flannery, S. A. Teukolsky, W. T. Vetterling (1989). [Numerical Recipes in Pascal](http://openlibrary.org/works/OL16807779W/). The Art of Scientific Computing, Cambridge University Press, ISBN 0-521-37516-9.
262	259		4. Richard Saucier, [Computer Generation of Statistical Distributions](http://ftp.arl.mil/random/random.pdf), ARL-TR-2168, US Army Research Laboratory, Aberdeen Proving Ground, MD, 21005-5068, March 2000.
263	260		5. R.U. Seydel, Generating Random Numbers with Specified Distributions. In: Tools for Computational Finance, Universitext, [DOI 10.1007/978-1-4471-2993-6_2](http://dx.doi.org/10.1007/978-1-4471-2993-6_2), © Springer-Verlag London Limited 2012
264	261		6. Christian Walck, Hand-book on STATISTICAL DISTRIBUTIONS for experimentalists, Internal Report SUF–PFY/96–01, University of Stockholm 2007
265		-
266		-	\
267	262
268	263		---
269	264		From the Free Pascal wiki, page "Generating Random Numbers/fr", as it stood on 2020-02-16 after a change by GAN, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history