salut, je voulais savoir comment ont peut donner à une nombre A une valeur aléatoire située entre 0 et 6

T´as pas d´eu chercher des masses , et en plus tu indiques meme pas le langage utilise ...

enfin , bon , supposons que ce soit du c/c++ :

tu includes l´header <stdlib.h> et le <time.h>

int a = 0;
a = rand()%7;
rand() donne une valeur entre 0 et 32.000 et quelques ... l´operation modulo 7 donne alors un resultat entre 0 et 6 ...

bon , ensuite , pour avoir des valeurs differentes a chaque lancement , tu marques :

srand( time(NULL) );

// bon , je sais que certains diront que modulo , c ´est pas la meilleure methode , mais c´est quand meme la plus simple je pense ... ?

non seulement c´est la plus simple, mais pour des nombres assez petit (inférieur à 100 disont) le biais est très petit.

Par contre ça ne marche que pour avoir des entiers.

Si tu veux des nombre entre m et M (min et Max) en flottant, tu peut faire :

nombre_alea=((double)rand()/(double)RAND_MAX)*(M-m
)+m;

c´est bon c´est reglé j´aurais du utiliser la fonction avant de poser une question bete

pour le derangement et pour l´aide

PS: bah oui j´avais oublié de preciser que c´était du C ^^, j´ai utilisé la methode de jejej, en quoi n´est elle pas la meilleure question:

en plus j´ai loupé mon smiley->

c´est du au fait que rand te donne une valeur entre 0 et 32767.

Donc si tu veux par exemple un nombre entre 0 et 10000 et que tu fait :
nombre=rand()%10000;
alors si c´est entre 0 et 30000 il n´y a pas de problème, mais entre 30000 et 32000, tu va obtenir quelque chose entre 0 et 2000.

Donc tu vois que les nombre entre 0 et 2767 vont sortir 1/3 plus souvent que les autres.

Mais bon, si tu veux des nombre plus petit que 100, alors ils ne sortiront même pas 1/300 fois plus souvent.

Dans ton cas, les nombres 0 et 1 sortiront 1 fois de plus tout les 4500 tirages. Ce qui n´est pas énorme si tu ne fait pas un jeu de casino.

Si tu as besoind´un meilleur hasards utilise l´autre méthode.

je vais répondre a cette question par le seul language que je connaisse assez par coeur en cas que qqn retrouve ce topic un jour par la fonction recherché

Irc scripting :

$r(1,6) ou $random(1,6)

dnob700 Posté le 07 novembre 2005 à 23:16:17

Dans ton cas, les nombres 0 et 1 sortiront 1 fois de plus tout les 4500 tirages. Ce qui n´est pas énorme si tu ne fait pas un jeu de casino.

Si tu as besoind´un meilleur hasards utilise l´autre méthode.
---------
c´est bon ça me convient parfaitement

allez hop, j´en rajoute une...
les LCG sont majoritaire dans les algo de génération d´aléa et ils disposent d´une propriete remarquable qui est de ne pas etre uniformément aléatoire quand on les tire par couple.
(essayez de les tirer par pair et de les afficher en 2D, vous constaterez de joli droite parallele.)
La meilleur solutions dans ce cas reste de tirer de facon aléatoire sur l´ensemble des combinaison.
ainsi si l´on veut tirer 2D6, on en fait pas:
D1 = alea_uniforme (1,6);
D2 = alea_uniforme (1,6);
mais
val = alea_uniforme (1,36/*6*6*/);
D1 = val%6;
D2 = val/6;
deplus, c´est plus rapide dans tous les cas alors pourquoi s´en priver ?

avec de bonnes valeurs, un LCG peut être tout à fait fiable à ce niveau là et pour cette demande d´exigence (je veux bien que tu me sorte un code source qui va me dessiner des droite paralèlle à partir de valeur aléatoire).

Mais si certain veulent voir le must en matière de générateur de nombre pseudo aléatoire.
Votre bonheur se trouve là :
http://www-cs-faculty.stanford.edu/~knuth/programs/rng.c (pour générer des long)
http://www-cs-faculty.stanford.edu/~knuth/programs/rng-double.c (pour générer des double)

voici un bout de code,
j´utilise un LCG poposé par D Knuth sur 8 bits. Il respecte les regles de base des LCG, je ne sais pas trop pour les règles évolué par contre, mais TOUS les LCGs ont cette failles la.
Bien sur la distance entre les droites parallèle est un indice de la qualité du LCG.
Je te laisse gnuplot-er ou excel-er la sorti pour t´en convaincre.

1. include <stdio.h>

unsigned int seed = 1;
unsigned int a = 137;
unsigned int b = 187;
unsigned int mod = (1 << 8);

unsigned int myrand()
{
seed *= a;
seed += b;
seed %= mod;
return seed;
}

int main ()
{
int i;
for (i=0; i<500; i++)
printf ("%d %d\n", myrand(), myrand());
return 1;
}

d´ailleurs si on considere les
myrand()%8
on a la suite recurente: 47250361

en utilisant les bit de poids fort, on ne voit pas de suite a l´oeil nu
une nouvelle version:

1. include <stdio.h>

unsigned int seed = 1;
unsigned int a = 137;
unsigned int b = 187;
unsigned int mod = (1 << 8);

unsigned int myrand()
{
seed *= a;
seed += b;
seed %= mod;
return seed;
}

unsigned int myrandmod(unsigned int m)
{
double toto = myrand();
toto /= mod;
return toto * m;
}

int main ()
{
int i;
double toto;
for (i=0; i<500; i++)
{
unsigned int t = myrandmod(100);
printf ("%d %d\n", t%10, t/10);
// printf ("%d %d\n", myrandmod(10), myrandmod(10));
}

return 1;
}

ici, je normalise mes valeures et je les tire d´un coup, toutes les valeurs apparaissent,
dans la version en commentaire, on constate des trous (PS: rappelons que c´est ici un generateur 8 bits, alors, on ne peut pas s´attendre a des merveilles. Mais ca explicite mes propos)

bien sur, mais si tes générateurs sont des blagues alors forcément.

essaye avec ces valeurs, là tu aura un véritable LCG :

//Les __int64 sont des entiers sur 64 bits.
__int64 X0=314159;
__int64 a0=89853;
__int64 a1=4756877;
__int64 m=999999999989;

long rng()
{
X0=(((X0*a0)%m)*a1)%m;
return (long)(X0&0x7fffffff);
}

Et là, bien sûr ce n´est pas un générateur 8 bits, mais au moins il n´y a pas de droites parallèles quelque soit le modulo avec lequel tu récupère les valeurs (quelque soit la valeur de a dans "pixel(rng()%a,rng()%a);" si pixel est ta fonction pour allumer des pixels).

bien sur ta méthode pour tirer des valeurs uniforme est valable, mais ce que je veux dire, c´est qu´avec un bon générateur (celui-ci est celui de Maple) on peut largement s´en passer car c´est un biais qui n´apparait pas.

je ne peux pas tester, mon compilos ne gere pas les int64 (je vais hacké ca, mais la j´ai plein de truc a faire, je ferai ca a la fin du mois, rappele le moi au cas ou j´oublierai)

mais je t´assure que tous les LCG ont cette propriété, apres, celui ci est peut etre suffisament bien pour que la distance entre les droites parallele soit de 1 et donc, tous les points du plan discretisé [0; 2^64-1]^2 apparaisse.

En outre, la plupart des libs n´implémente pas un LCG sur 64 bits, mais un LCG sur 16 bits qui est bien moins bon (celui de java par exemple n´est pas sans faille).
Apres, je ne dis pas qu´il ne faut pas utiliser les LCGs. J´en utilises moi même au quotidien. Je veux juste attirer l´attention sur le fait que les propriété les générateurs aléatoire reposent sur des loi statistiques et que l´on ne peut pas tout faire avec.

un LCG génère de l´aléa uniformément distribué sur [0; mod-1] et il ne fait rien d´autre.
Il n´assure en outre pas la non-prédiction. (et c´est d´ailleurs cette propriété qui pèche lors du tirage par pacquet).

Sur ce, je met ce générateur dans ma TODO list.

PS: je ne suis pas bien conviancu que ce soit un LCG que tu me présente la...
je m´explique:

X0=(((X0*a0)%m)*a1)%m;

bon ok X_{n+1} = X_n*a0*a1%m
ca c´est bien linéaire...

return (long)(X0&0x7fffffff);

Ca j´ai peur que ce ne soit pas tres linéaire par contre...
tu as une décomposition qui te ramene a quelque chsoe de la forme
X_{n+1} = a*X_n + b %m ?

In fact, ca a déjà été fait pour moi:
http://crypto.mat.sbg.ac.at/results/karl/server/node5.html
regarde le LCG de maple avec la jolie photo au dessus

Effectivement, tu as absolument raison, ce n´était pas un LCG. J´avais juste fait ça pour me ramener à des long, sans faire gaffe.

Mais en le supprimant (le AND), je ne retrouve tout de même pas ce qui est annoncé sur ton site.

bon, je testerais ça un peu plus si j´ai du temps.

une autre technique pour te convaincre consiste a tirer n couples (x, y) n >> mod^2 et a compterle nombre d´occurence de chaque valeur puis a comparer la distribution avec une distribution aléatoire (test du chi-deux ou kolmororov-smirnoff).
Je penses (sans être sur) que tu rejettra ainsi l´hypothese d´uniformité de la distribution des couples (x,y).

pour conclure ce que l´on dit, j´ai rédigé un petit article sur les LCGs et la génération d´aléa:
http://www.mandragor.org/article.php?id=12

Si j´ai oublié des choses, fais des erreurs, vous pensez que je devrait parler d´autre choses... n´hesitez pas!

Deplus, cet article peut faire une bonne réponses aux erreurs standards sur l´aléa et aux demande d´explication.