Version imprimable
Bonjour , je voudrai faire une fonction genre my_rand(max, min) qui prend comme parametres float max et min, et qui me donne une valeur aléatoire entre ces deux valeurs, nb: mon min à comme valeur 0, mon max doit être inférieur à 1, car avec les entier c'est faisable. j'ai pas pu le faire; la fonction que j'ai trouvé sur le net ne prend pas des paramètres et elle est prédifinie en C.
Merci de votre réponse
Le C définit une fonction rand() qui retourne une valeur comprise entre 0 et RAND_MAX. A partir de là, ça devient un simple exercice d'arithmétique...Citation:
Envoyé par Ontolingua
Si on divise cette valeur par RAND_MAX, on a une valeur comprise entre 0/RAND_MAX et RAND_MAX/RAND_MAX, soit 0 et 1.
Si on multiplie cette valeur par une plage P, elle varie de 0xP à 1xP, soit de 0 à P. Si on décale le tout d'une valeur minimale MIN, elle varie de MIN+0 à MIN+P etc.
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Code:
2
3
4
5
6
7
8
9
10
11
12
13
Citation:
Envoyé par Emmanuel Delahaye
Merci de votre réponse mais je comprends pas pourquoi toutes les valeurs affichées dans ma matrice après que j'ai utilisé votre fonction sont égal à 0.0000 ?
alors que mon max est égal à 1, et mon min égal à 0.
[QUOTE=Ontolingua;2994915]Parce que la démo d'Emmanuel est superbe mais elle ne prend pas en compte le problème de la borne extrème. Autrement dit pour que pour que t'obtiennes 1 il faudrait que ton rand() ait envoyé pile-poil le nombre RAND_MAX et que ce ceci fausse l'équiprobabilité des nombres possibles.Citation:
Envoyé par Emmanuel Delahaye
Explication
Prenons l'hypothèse que RAND_MAX soit égal à 5000 donc rand() te renvoie un nombre entre 0 et 5000. Et que toi tu cherches un nombre entre 0 et 5, ton nombre sera issu du calcul 5.0 * rand() / 5000
Cela signifie que si rand() te sors un nombre entre 0 et 999 ton générateur te renverra 0. Puis s'il te sort un nombre entre 1000 et 1999 ton générateur te renverra 1. Puis s'il te sort un nombre entre 2000 et 2999 il te renverra 2, etc jusqu'aux nombres qu'il sort entre 4000 et 4999 où tu obtiendras 4. Et seulement s'il te sort cet unique 5000 tu obtiendras 5. Le 5 a donc 5000/5 fois moins de chances de sortir que les autres nombres.
Dans la réalité RAND_MAX est égal à 32765 donc ton 1 a 32765 fois moins de chances de sortir que le 0...
Dans ce nouveau code, je m'arrange pour créer une plage de valeurs suplémentaire dans laquelle le nombre max a autant de chances que les autres mais je la divise par MAX + 1 pour éliminer la borne extrème qui est devenue un parasite de l'équiprobabilité. Reprenons l'exemple de 0 à 5 avec RAND_MAX=5000. Là, je multiplie le nombre sorti par 6 et je le divise par 1001. Résultat:Code:
2
3
4
- Si le nombre sorti par rand() est entre 0 et 833, alors le résultat sera 0
- Si le nombre sorti par rand() est entre 834 et 1666 alors le résultat sera 1
- Si le nombre sorti par rand() est entre 1667 et 2500 alors le résultat sera 2
- Si le nombre sorti par rand() est entre 2501 et 3333 alors le résultat sera 3
- Si le nombre sorti par rand() est entre 3334 et 4167 alors le résultat sera 4
- Si le nombre sorti par rand() est entre 4168 et 5000 alors le résultat sera 5
Total chaque possibilité entre 0 et 5 est quasiment équiprobable (à +-1 près)
Euh, Bizarre. avec ce code et la plage 0, 1, j'obtiens :Citation:
Envoyé par Sve@r
soit une plage de 0 à 2-epsilon...Code:
2
3
4
5
6
7
8
9
10
11
12
13
Pour voir ce qui se passe, j'ajoute un tri :
et ça donne :Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
Alors qu'avec mon code, ça donne :Code:
2
3
4
5
6
7
8
9
10
11
12
13
ce qui correspond bien à la plage 0.-1.0-epsilon... Je pense qu'on ne raisonne pas de la même manière en entier et en réel...Code:
2
3
4
5
6
7
8
9
10
11
12
13
Bah, montre ton code, parce que avecCitation:
Envoyé par Ontolingua
j'obtiens :Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Code:
2
3
4
5
6
7
8
9
10
11
12
13
Sve@r :
Mais, le résultat renvoyé est un double :Citation:
Résultat:Code:
2
3
4
Si le nombre sorti par rand() est entre 0 et 833, alors le résultat sera 0
Si le nombre sorti par rand() est entre 834 et 1666 alors le résultat sera 1
Si le nombre sorti par rand() est entre 1667 et 2500 alors le résultat sera 2
Si le nombre sorti par rand() est entre 2501 et 3333 alors le résultat sera 3
Si le nombre sorti par rand() est entre 3334 et 4167 alors le résultat sera 4
Si le nombre sorti par rand() est entre 4168 et 5000 alors le résultat sera 5
Résultat:
Si le nombre sorti par rand() est entre 0 et 833, alors le résultat sera 0.
xxx
Si le nombre sorti par rand() est entre 834 et 1666 alors le résultat sera 1.xxx
Si le nombre sorti par rand() est entre 1667 et 2500 alors le résultat sera 2.xxx
Si le nombre sorti par rand() est entre 2501 et 3333 alors le résultat sera 3.xxx
Si le nombre sorti par rand() est entre 3334 et 4167 alors le résultat sera 4.xxx
Si le nombre sorti par rand() est entre 4168 et 5000 alors le résultat sera 5.xxx
Valeurs comprises entre 0 et 6-epsilon
Si on convertit en entier le résultat du calcul, ce que tu donnes est correct, mais correspond à un problème différent :
un nombre entier aléatoire compris entre min et max
je pense que je n'était pas clair; je voudrai que my_rand me retourne une valeur entre min et max; avec min = 0 et le max je le défini comme je veux par ex 0.8 ou 0.7.
dans mon code çi dessou montre un pti traitement ou mon max prendra la valeur (1 - la valeur ancienne de my_rand ), vous aez remarquer que mon max varie à chaque fois d'une façon décroissante, entre max et 0.
mon code est :
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
Quelques remarques :
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16... pTransition = (float**)malloc(nbr_trans*sizeof(float*)); ... pTransition[j][i]= k; temp=temp+pTransition[j][i]; fprintf(f, "\t%f", pTransition[j][i]=); .... fflush(stdin); // ne s'applique pas aux flux d'entrée : rechercher fclean() sur le forum .... p= realloc(pTransition, nbr_trans*sizeof(float)); p=NULL; // l'adresse de réallocation est perdue .... printf("Les probabilités de t : \n"); // main non terminée .... min + ((max - min + 1) * (rand () / (float) (RAND_MAX + 1))); // Non : voir les éléments de la discussion qui précèdent
Et si RAND_MAX vaut INT_MAX?Citation:
Envoyé par Sve@r
Thierry
Tout à fait exact. La fonction que je montre et qui est issue deCitation:
Envoyé par Emmanuel Delahaye
Permet d'obtenir un nombre aléatoire entier entre min et max (min et max inclus). Cela vient de la façon dont on considère le réel appartenant à l'intervalle [x; x + 1[ qui est arrondi à "x"quand on le rend entierCitation:
Numerical Recipes in C: The Art of Scientific Computing (William H. Press, Brian P. Flannery, Saul A. Teukolsky, William T. Vetterling; New York: Cambridge University Press, 1990 (1st ed, p. 207))
Pour un aléa en réel pur, ce n'est plus la même théorie car l'intervalle n'est plus intégré dans l'entier donc faut pas utiliser la même fonction...
Oui, je suis effectivement parti dans cette voie...Citation:
Envoyé par diogene
voici mon code, je vous merci :
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
Attention, je te redis que ce calcul "min + ((max - min + 1) * rand() / (RAND_MAX + 1)" est destiné à assurer l'équiprobabilité pour un aléatoire "entier". Pour un aléatoire flottant, ce n'est pas forcément le meilleur (tout dépend en fait de la façon dont tu considères "max").Citation:
Envoyé par Ontolingua
Et tu peux remplacer
ParCode:(float) (RAND_MAX + 1)))
Code:(RAND_MAX + 1.0)))
Nous te de rien...;)Citation:
Envoyé par Ontolingua