Discussion modèle:Rand

Test

• {{#rand}} : {{#rand}}
• {{#rand:0|100}} : {{#rand:0|100}}
• {{NUMBEROFARTICLES}} : 2 610 739
• {{CURRENTDAY}}{{CURRENTMONTH}}{{CURRENTYEAR}}{{CURRENTDAY}} : 1005202410

Syntaxe	min	max	aléatoire
{{Rand|0|1}}	0	1	0
{{Rand|0|2}}	0	2	0
{{Rand|0|3}}	0	3	0
{{Rand|0|4}}	0	4	2
{{Rand|0|5}}	0	5	0
{{Rand|0|6}}	0	6	4
{{Rand|0|7}}	0	7	0
{{Rand|0|8}}	0	8	0
{{Rand|0|9}}	0	9	2

Test basé sur CURRENTDAY~CURRENTMONTH~CURRENTYEAR~CURRENTDAY

rien

Test basé sur NUMBEROFARTICLES (qui ne peut plus être utilisé maintenant)

germ * germ

Le résultat d'une puissance de 2 est toujours paire : très mauvais générateur

evaluation on range(300000, 500000)
function : {{rang|0|9}}
0 : 20000 ; 100%
1 : 40000 ; 200%
2 : 0 ; 0%
3 : 0 ; 0%
4 : 40000 ; 200%
5 : 20000 ; 100%
6 : 40000 ; 200%
7 : 0 ; 0%
8 : 0 ; 0%
9 : 40000 ; 200%

germ * germ * germ

Fonctionne bien de 1 à 10, mais ce con sort des nombres négatifs !!!!

-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|2}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents) : 0
0 : 333 ; 99%
1 : 333 ; 99%
2 : 334 ; 100%
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|9}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents) : 0
0 : 100 ; 100%
1 : 100 ; 100%
2 : 100 ; 100%
3 : 100 ; 100%
4 : 100 ; 100%
5 : 100 ; 100%
6 : 100 ; 100%
7 : 100 ; 100%
8 : 100 ; 100%
9 : 100 ; 100%
-----------------------------------
evaluation on range(300000, 400000)
0 : 20000 ; 100%
1 : 20000 ; 100%
2 : 20000 ; 100%
3 : 20000 ; 100%
4 : 20000 ; 100%
5 : 20000 ; 100%
6 : 20000 ; 100%
7 : 20000 ; 100%
8 : 20000 ; 100%
9 : 20000 ; 100%
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|19}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 5 soit 25% de l'interval
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|49}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 8 soit 16% de l'interval
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|99}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 37 soit 37% de l'interval
-----------------------------------
evaluation on range(300000, 500000)
0 : 40000 ; 100%
1 : 40000 ; 100%
2 : 40000 ; 100%
3 : 40000 ; 100%
4 : 40000 ; 100%

germ * germ * (germ-11)

Jusqu'a une centaine d'elements, tous on une chance non nul d'apparaitre, par contre le générateur n'est pas linéaire, et le 0 a de grande chance de sortir.

evaluation on range(300000, 310000)
function : {{rang|0|9}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 0 soit 0% de l'interval
0 : 2546 ; 254%
1 : 454 ; 45%
2 : 1180 ; 118%
3 : 455 ; 45%
4 : 1183 ; 118%
5 : 910 ; 91%
6 : 1183 ; 118%
7 : 455 ; 45%
8 : 1179 ; 117%
9 : 455 ; 45%
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|99}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 0 soit 0% de l'interval
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|199}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 21 soit 10% de l'interval
-----------------------------------
evaluation on range(300000, 301000)
function : {{rang|0|99}}
trou (nombre l'elements [min...max] qui ne peuvent pas etre presents)
trou : 0 soit 0% de l'interval
#5 premieres valeurs
0 : 142 ; 1420%
1 : 4 ; 40%
2 : 3 ; 30%
3 : 3 ; 30%
4 : 15 ; 150%
#valeurs remarquables <20% ou >500%
0 : 142 ; 1420%

Tests basés sur une fonction de hachage arithmétique modulaire

Une bonne fonction de hachage bien connue consiste à multiplier le germe par un nombre premier P suffisamment grand avant d'ajouter un élément, puis de titer un modulo N (le nombre de valeurs possibles de la série aléatoire) premier avec le multiplicateur. Comme P est premier, toute valeur de N est première avec P.

Plus en détail, la fonction de hachage est: h(germe,x) = germe*P+x modulo K, où K est très un entier grand premier avec P. (généralement K est la puissance de 2 correspondant au nombre de bits sur lesquels on effectue le calcul).

Donc on calcule: h(h(...h(germe, var_0), var_1), ...) modulo N pour obtenir le pseudo-générateur.

C'est-à-dire: (...((germe*P + var_0)*P + var_1)*P + var_2...) modulo N

Les variables {var_0, var_1, var_2...} devraient aussi être classées par variabilité décroissante (c'est à dire celles qui changent le plus souvent en tête).

Le germe peut être quelconque, son influence sur la fonction de hachage est celle d'un "glissement" de la série au sein du même cycle de valeurs possibles (la longueur du cycle de la série est très grande face à N, de l'ordre de 67 puissance 3, pour P=64 et pour 4 variables)

Un bon choix pour le nombre premier P est 67. Sa valeur minimale dépend en fait d'abord de la variabililité de var_0 ci-dessus (avant celle des autres variables), et du nombre de variables (ce qui modifie le degré du polynome).

Cette fonction de hachage est très rapide et simple à calculer (c’est un polynome exprimé sous forme factorisée à droit qui ne demande aucune mémoire intermédiaire). Elle est très abondamment utilisée comme fonction de hachage dans Java.

Tiens, pour moi, une forme factorisée, c'est P*Q. Cette forme là, pour moi, c'est un polynôme en P en forme de Horner. David.Monniaux 30 mai 2006 à 07:32 (CEST)

Il y a quelques conditions supplémentaires liant le choix du nombre premier P à N, mais les conditions la paire (P,N) a un mauvais comportement sont assez rares, donc faciles à éviter. Mais le choix pour P d'une valeur de 67 est suffisant quand on a 4 variables var_n, c'est-à-dire un polynome de degré 3 (formule qui se calcule avec seulement... 3 multiplications, 3 additions et 1 modulo!), pour des valeurs de N assez grandes (N < 67^3/100 pour P=67, soit N jusqu'à 3000 environ).

Si on veut un N plus grand, on prendra P plus grand. Par exemple avec P=201, et 4 variables, on peut avoir N jusqu'à 81206!

Attention à ne pas prendre P trop grand, sinon le polynome risque, par son degré, de dépasser les limites de précision d'un entier si les calculs sont effectués en virgule flottante (c'est le cas de PHP ou des expressions #expr de MediaWiki), ce qui fait qu'on perdra les bits de poids faible, les plus important dans le résultat du modulo N. Si cela peut se produire, on divisera le polynome par 2^n où n est le nombre de bits de précision perdus, avant d'effectuer le modulo N final. Mais comme ici le degré est assez faible (4 variables var_N), celanedevrait pas se produire sauf si on choisit P très grand (supérieur à 1000: mais il faut trouver et se souvenir d’un tel nombre premier P aussi grand!) 7 mai 2006 à 15:04 (CEST)

Mais non mais non. Si tu veux obtenir ((a*b)+c) mod N et que que tu as peur que a*b soit trop grand pour ton type, tu fais (((a*b) mod N)+c) mod N et tu obtiens le même résultat ! Comme dirait l'autre, x ↦ x mod N est un morphisme pour + et × ! David.Monniaux 30 mai 2006 à 07:32 (CEST)

Pas de nouveau nombre aléatoire au rafraichissement de la page

Pourquoi un rafraichissement de la page ne fait pas afficher de nouveaux numéros aléatoires... Il faut purger la page pour obtenir un nouveau nombre (action=purge). --Megajoule (discuter) 2 mai 2021 à 11:59 (CEST)