nombre aléatoire dans un interval

**Ontolingua** · 27/02/2008, 02h15

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

**Emmanuel Delahaye** · 27/02/2008, 02h42

Envoyé par Ontolingua

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. 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édéfinie 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...

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <time.h>
 
double random_range (double min, double max)
{
   return min + ((max - min) * (rand () / (double) RAND_MAX));
}
 
int main (void)
{
   int i;
   srand ((int) time (NULL));
   for (i = 0; i < 100; i++)
   {
      double n = random_range (5, 10);
      printf ("%8.4f", n);
   }
   return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  6.9823  7.9875  5.3995  6.2235  9.0402  8.8142  5.0520  6.4628  8.9451  7.5925
  7.1540  8.0985  5.4578  8.0619  7.9208  7.6821  5.8315  5.2426  9.4519  9.9329
  5.3531  7.4361  6.8555  6.9898  7.7155  5.7346  7.8439  5.2506  7.6252  6.8221
  7.4551  6.8294  9.5526  7.3476  8.0592  5.1653  9.0323  5.6516  7.3028  6.8128
  5.4167  9.1278  9.1502  8.9448  7.4931  8.0004  5.6751  9.5994  5.8654  8.7989
  9.7627  5.2031  8.5127  8.3113  6.3730  7.4000  8.4260  6.2969  7.5292  8.7178
  9.7324  7.7413  8.6789  9.1055  6.2105  7.9310  6.5902  7.8695  8.6065  6.1347
  6.4383  8.0413  9.6535  6.1675  8.2365  7.7100  8.2028  9.6210  5.2684  5.3459
  6.3742  5.0412  9.6808  8.6531  6.1280  8.8362  7.8883  8.9749  9.1675  6.1901
  5.9508  5.7904  6.5789  7.7721  7.5770  8.3291  7.1137  5.5150  9.9100  8.8342
 
Press ENTER to continue.

**Ontolingua** · 27/02/2008, 03h28

Envoyé par Emmanuel Delahaye

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...

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.

**Sve@r** · 27/02/2008, 07h58

[QUOTE=Ontolingua;2994915]

Envoyé par Emmanuel Delahaye

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...

*******************
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.

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.
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...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
long random_range (long min, long max)
{
   return min + ((max - min + 1) * (rand () / (double) (RAND_MAX + 1)));
}

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:

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)

**Emmanuel Delahaye** · 27/02/2008, 10h32

Envoyé par Sve@r

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double random_range (double min, double max)
{
   return min + ((max - min + 1) * (rand () / (double) (RAND_MAX + 1)));
}

Euh, Bizarre. avec ce code et la plage 0, 1, j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.3917  1.0963  1.8806  0.5003  1.7222  1.8159  0.2482  1.8381  0.3287  0.3129
  1.2797  0.7564  0.7882  1.5291  1.1323  0.8401  1.1794  1.7293  0.5079  0.4917
  1.7683  0.6947  1.3258  1.1652  1.5573  0.3253  0.1643  1.2910  1.7599  0.4655
  0.0342  1.2048  0.2644  1.7645  1.0469  1.3934  0.1470  0.3851  1.5402  1.3683
  0.2997  0.3713  0.2224  1.4818  1.2326  0.4898  0.8995  0.9967  0.1160  1.3565
  0.3465  0.7218  0.1218  1.6598  0.8856  1.5272  0.1287  1.2949  0.2343  1.0505
  1.8542  0.2207  0.1854  1.9069  0.4730  0.8512  0.6809  1.7159  1.7877  0.7954
  0.8444  0.2569  0.0118  1.7567  1.5312  0.0660  1.2299  1.4055  0.9621  1.7867
  0.5938  0.0361  0.0005  0.5875  0.3220  0.8226  0.6373  0.9578  0.5608  1.4836
  0.2449  0.1953  0.1715  0.1703  1.1634  1.8978  1.5062  1.3900  0.1814  1.7710
 
Press ENTER to continue.

soit une plage de 0 à 2-epsilon...
Pour voir ce qui se passe, j'ajoute un tri :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
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
 
#include <stdio.h>
#include <time.h>
 
#if 1
double random_range (double min, double max)
{
   return min + ((max - min + 1) * (rand () / (double) (RAND_MAX + 1)));
}
#else
double random_range (double min, double max)
{
   return min + ((max - min) * (rand () / (double) RAND_MAX));
}
#endif
 
static int cmp (void const *a, void const *b)
{
   int ret = 0;
   double const *pa = a;
   double const *pb = b;
   double diff = *pa - *pb;
   if (diff > 0)
   {
      ret = 1;
   }
   else if (diff < 0)
   {
      ret = -1;
   }
 
   return ret;
}
 
int main (void)
{
   double tab[100];
   int i;
   srand ((int) time (NULL));
   for (i = 0; i < sizeof tab / sizeof *tab; i++)
   {
      tab[i] = random_range (0, 1);
   }
 
   qsort (tab, sizeof tab / sizeof *tab, sizeof *tab, cmp);
 
   for (i = 0; i < sizeof tab / sizeof *tab; i++)
   {
      printf ("%8.4f", tab[i]);
   }
 
   return 0;
}

et ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.0095  0.0117  0.0659  0.0693  0.0701  0.0970  0.1301  0.1707  0.2048  0.2175
  0.2273  0.2483  0.2698  0.3205  0.3218  0.3245  0.3361  0.3577  0.3769  0.4000
  0.4077  0.4089  0.4174  0.4238  0.4351  0.4399  0.4870  0.5009  0.5164  0.5236
  0.5858  0.6161  0.6595  0.7200  0.7415  0.7628  0.8022  0.8212  0.8522  0.8549
  0.8710  0.8893  0.9055  0.9055  0.9200  0.9901  0.9920  0.9975  1.0000  1.0005
  1.0093  1.0220  1.0385  1.0555  1.0690  1.0765  1.0774  1.0867  1.1061  1.1354
  1.1514  1.1719  1.1741  1.1791  1.1915  1.2279  1.2365  1.2530  1.2779  1.3153
  1.3187  1.3253  1.3409  1.3749  1.4272  1.4612  1.4620  1.4968  1.5297  1.5551
  1.5591  1.6784  1.6965  1.7089  1.7471  1.7504  1.7546  1.7988  1.8090  1.8167
  1.8192  1.8240  1.8629  1.8734  1.8741  1.8830  1.9055  1.9083  1.9137  1.9309
 
Press ENTER to continue.

Alors qu'avec mon code, ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.0226  0.0256  0.0270  0.0419  0.0933  0.1024  0.1060  0.1244  0.1323  0.1376
  0.1401  0.1468  0.1531  0.1537  0.1822  0.1851  0.1905  0.2097  0.2376  0.2411
  0.2535  0.2580  0.2596  0.2618  0.2641  0.2665  0.2759  0.2960  0.2979  0.2989
  0.3157  0.3380  0.3393  0.3479  0.3515  0.3725  0.4109  0.4419  0.4478  0.4529
  0.4531  0.4584  0.4634  0.4727  0.4772  0.4871  0.4997  0.5046  0.5266  0.5337
  0.5386  0.5484  0.5554  0.5710  0.5723  0.5749  0.5761  0.5781  0.5826  0.5869
  0.6075  0.6448  0.6469  0.6474  0.6485  0.6517  0.6634  0.6635  0.6790  0.7125
  0.7160  0.7203  0.7284  0.7342  0.7664  0.7681  0.8079  0.8166  0.8260  0.8362
  0.8437  0.8511  0.8549  0.8801  0.8809  0.8824  0.8868  0.8919  0.9047  0.9055
  0.9264  0.9295  0.9431  0.9463  0.9471  0.9727  0.9802  0.9833  0.9902  0.9993
 
Press ENTER to continue.

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...

**Sve@r** · 27/02/2008, 15h50

Envoyé par Emmanuel Delahaye

Euh, Bizarre. avec ce code et la plage 0, 1, j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.3917  1.0963  1.8806  0.5003  1.7222  1.8159  0.2482  1.8381  0.3287  0.3129
  1.2797  0.7564  0.7882  1.5291  1.1323  0.8401  1.1794  1.7293  0.5079  0.4917
  1.7683  0.6947  1.3258  1.1652  1.5573  0.3253  0.1643  1.2910  1.7599  0.4655
  0.0342  1.2048  0.2644  1.7645  1.0469  1.3934  0.1470  0.3851  1.5402  1.3683
  0.2997  0.3713  0.2224  1.4818  1.2326  0.4898  0.8995  0.9967  0.1160  1.3565
  0.3465  0.7218  0.1218  1.6598  0.8856  1.5272  0.1287  1.2949  0.2343  1.0505
  1.8542  0.2207  0.1854  1.9069  0.4730  0.8512  0.6809  1.7159  1.7877  0.7954
  0.8444  0.2569  0.0118  1.7567  1.5312  0.0660  1.2299  1.4055  0.9621  1.7867
  0.5938  0.0361  0.0005  0.5875  0.3220  0.8226  0.6373  0.9578  0.5608  1.4836
  0.2449  0.1953  0.1715  0.1703  1.1634  1.8978  1.5062  1.3900  0.1814  1.7710
 
Press ENTER to continue.

Alors qu'avec mon code, ça donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.0226  0.0256  0.0270  0.0419  0.0933  0.1024  0.1060  0.1244  0.1323  0.1376
  0.1401  0.1468  0.1531  0.1537  0.1822  0.1851  0.1905  0.2097  0.2376  0.2411
  0.2535  0.2580  0.2596  0.2618  0.2641  0.2665  0.2759  0.2960  0.2979  0.2989
  0.3157  0.3380  0.3393  0.3479  0.3515  0.3725  0.4109  0.4419  0.4478  0.4529
  0.4531  0.4584  0.4634  0.4727  0.4772  0.4871  0.4997  0.5046  0.5266  0.5337
  0.5386  0.5484  0.5554  0.5710  0.5723  0.5749  0.5761  0.5781  0.5826  0.5869
  0.6075  0.6448  0.6469  0.6474  0.6485  0.6517  0.6634  0.6635  0.6790  0.7125
  0.7160  0.7203  0.7284  0.7342  0.7664  0.7681  0.8079  0.8166  0.8260  0.8362
  0.8437  0.8511  0.8549  0.8801  0.8809  0.8824  0.8868  0.8919  0.9047  0.9055
  0.9264  0.9295  0.9431  0.9463  0.9471  0.9727  0.9802  0.9833  0.9902  0.9993
 
Press ENTER to continue.

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...

Tout à fait exact. La fonction que je montre et qui est issue de

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))

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 entier

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...

Envoyé par diogene

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

Oui, je suis effectivement parti dans cette voie...

**Thierry Chappuis** · 27/02/2008, 14h34

Envoyé par Sve@r

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double random_range (double min, double max)
{
   return min + ((max - min + 1) * (rand () / (double) (RAND_MAX + 1)));
}

Et si RAND_MAX vaut INT_MAX?

Thierry

**Emmanuel Delahaye** · 27/02/2008, 10h37

Envoyé par Ontolingua

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.

Bah, montre ton code, parce que avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <stdio.h>
#include <time.h>
 
double random_range (double min, double max)
{
   return min + ((max - min) * (rand () / (double) RAND_MAX));
}
 
int main (void)
{
   int i;
   srand ((int) time (NULL));
   for (i = 0; i < 100; i++)
   {
      double n = random_range (0, 1);
      printf ("%8.4f", n);
   }
   return 0;
}

j'obtiens :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
  0.1772  0.2093  0.9933  0.9260  0.9980  0.4989  0.3620  0.6244  0.9362  0.2422
  0.4840  0.1268  0.0522  0.3382  0.9202  0.4753  0.5452  0.7159  0.8065  0.9956
  0.7383  0.0009  0.9765  0.5518  0.4426  0.0525  0.4788  0.6223  0.8523  0.8995
  0.8914  0.9796  0.6308  0.1088  0.3417  0.2548  0.3418  0.1168  0.6387  0.1688
  0.8827  0.5544  0.4212  0.7092  0.0756  0.0977  0.7315  0.0374  0.0737  0.8758
  0.9176  0.4044  0.7377  0.9655  0.2730  0.8582  0.6392  0.0057  0.3182  0.0229
  0.8475  0.4629  0.1317  0.7319  0.1560  0.5766  0.6359  0.7955  0.9039  0.5193
  0.2433  0.6845  0.0500  0.7996  0.7723  0.4116  0.6549  0.4412  0.0351  0.3902
  0.4275  0.9684  0.0063  0.5545  0.4921  0.7293  0.9780  0.5189  0.0329  0.5884
  0.6070  0.0613  0.9707  0.5196  0.2615  0.7087  0.3303  0.1305  0.5722  0.7083
 
Press ENTER to continue.

**diogene** · 27/02/2008, 11h49

Sve@r :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
double random_range (double min, double max)
{
   return min + ((max - min + 1) * (rand () / (double) (RAND_MAX + 1)));
}.

Résultat:
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

Mais, le résultat renvoyé est un double :

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

**Ontolingua** · 27/02/2008, 11h59

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
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
int main(void) { 
 
FILE *f= NULL; 
int  nbr_trans, nbr_seq; 
int  i, j, l, m, vec;
float min=0;
float max=0.5;
float my_rand();
float k, maxim, y;
float temp=0;
float  **pTransition; 
float  **pSequence; 
float *vect; 
float *p=NULL;
//************************************
 
f = fopen("Fichier.txt", "w");
printf("entrez le nombre Etats :");
scanf("%d", &nbr_trans);
printf("Les probabilités  : \n");
 
pTransition = (float**)malloc(nbr_trans*sizeof(float)); 
fprintf(f, "La matrice des probabilités T : \n");
fprintf(f, " \n");       
for (j=0;j<nbr_trans; j++) {
 
for (i=0;i<nbr_trans; i++) {
    pTransition[i] = (float *) malloc (nbr_trans* sizeof(float));
 
    max=max-temp;  
    k=my_rand(min,  max);
    printf ("%f\n", k);  
    pTransition[i][j]= k;
    temp=temp+pTransition[i][j];
 
      fprintf(f, "\t%f", pTransition[i][j]);
 
 
	fflush(stdin);
}
  fprintf(f, "\n");
 
}
p= realloc(pTransition, nbr_trans*sizeof(float));
p=NULL;printf("entrez le nombre Etats :");
scanf("%d", &nbr_trans);
printf("Les probabilités de t : \n");
 
 
//************************************
float my_rand (min,  max){
         static int first = 0;
 
   if (first == 0)
   {
      srand (time (NULL));
      first = 1;
   }
   return min + ((max - min + 1) * (rand () / (float) (RAND_MAX + 1)));
}

nombre aléatoire dans un interval

C

Vue hybride

Discussions similaires

Partager

Partager