Comment générer des nombres reéls aléatoires ?

**rzmadjid** · 13/02/2008, 11h45

j'aimeais savoir comment fait on pour générer des nombres real compris entre 215 et 225.
avec les nombres entiers j'ai pu le faire mais avec les real c impossible
merci pour les reponses

**ShaiLeTroll** · 13/02/2008, 11h57

Tu fais un Random sans Range (résultat entre 0 et 0.99999) et tu multiplie le résultat par 10 et tu ajoute 215, résultat entre 215 et 224.999999

**ero-sennin** · 13/02/2008, 12h46

Salut et Bienvenue sur Developpez.com,

Je ne pense pas que cela soit faisable juste avec les bornes d'un nombre.
Ce qu'il faudrait faire, c'est déclarer un tableau de double et de la remplir via une boucle :

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
61
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
  // Déclaration du tableau dynamique.
  TabArray:array of double;
 
implementation
 
uses Math;
 
{$R *.dfm}
 
// Procédure d'initialisation du tableau
procedure InitTabRandom(AFrom,ATo,Increment:Double);
var
  i:Integer;
  Size:integer;
  Value:double;
begin
  i:=0;
  Value:=AFrom;
  // On détermine directement le nombre de cases qu'on doit allouer
  Size:=Ceil((ATo-AFrom) / Increment)+1;
  // On redimensionne le tableau en conséquence
  SetLength(TabArray,Size);
  // On remplit le tableau
  while (Value <= ATo ) do
  begin
    Inc(i);
    TabArray[i-1]:=value;
    Value:=Value+Increment;
  end;
end;
 
procedure TForm1.Button1Click(Sender: TObject);
begin
  // On appelle la procédure pour initialiser la tableau qui servira pour le Random
  InitTabRandom(215,225,0.1);
  Randomize;
  // On affiche une valeur aléatoire du tableau
  ShowMessage(FloatToStr(RandomFrom(TabArray)));
end;
 
end.

C'est une solution ... Surement la meilleure ?
Bon courage
A+

EDIT :
Le temps que je rédige ma réponse (entre deux, je suis allé manger

), ShaiLeTroll t'en propose une qui sans doute te conviendra mieux et sera plus rapide que la mienne ...

**ShaiLeTroll** · 13/02/2008, 14h36

Le Nombre de Valeur Double entre 215 et 225, un mathématique infinie, informatiquement, c'est quoi quelques milliers de milliards possible ... à 15 chiffre de précision

Sinon, ça me fait penser à un sujet pour un tirage à remise ... tient ça et ça, mais qu'avec des entiers ...

**ero-sennin** · 13/02/2008, 15h20

Re,

J'ai une petite question sur le code que je viens de poster! Y a une chose qui me chagrine pas mal ...
Je remplis bien mon tableau TabArray avec les valeurs de 215 à 225 avec un incrément de 0.1. Lorsque je suis en mode débug, je regarde le contenu de mon tableau, est là, pas de soucis, tout est niquel.
J'utilise donc le RandomFrom avec comme paramètre mon tableau est là, certaines fois, il me sort un nombre qui n'est pas compris dans le tableau

.
Du genre, il va me sorti un 224,199999999999 ... Il suffirait juste de faire un découpage à un chiffre après la virgule (RoundTo(ValeurTirée,-1))et on n'en parle plus mais c'est étrange qu'il me sorte un chiffre comme ça alors que dans l'aide de Delphi, il est bien spécifié :

Envoyé par aide Delphi

RandomFrom renvoie un élément choisi au hasard dans le tableau AValues transmis comme argument

Une petite explication pour ce léger soucis ?
Merci

**ShaiLeTroll** · 13/02/2008, 17h10

Un Arrondi pourri ??? en Double c'est surprenant ! Avec un Single j'aurais compris ... mais j'ai déjà vu sur les premiers P4 des résultats flottants assez étranges (la première fois la calcul échoue, les autres il est correcte, c'était pour de la 3D) ...

224.1999 peut être issu d'une longue vague d'erreur, tu devrais écrire dans un fichier le contenu du tableau ... si cela se trouve tu as bcp d'erreur d'arrondi lors du + 0.1

**ero-sennin** · 13/02/2008, 17h15

Envoyé par ShaiLeTroll

Un Arrondi pourri ??? en Double c'est surprenant ! Avec un Single j'aurais compris ... mais j'ai déjà vu sur les premiers P4 des résultats flottants assez étranges (la première fois la calcul échoue, les autres il est correcte, c'était pour de la 3D) ...

Comme tu dis, étrange! Pour info, j'ai un P4 HT ... mais est-ce vraiment là le soucis ??, As-tu essayé de tester mon code Shai pour voir si chez toi ça fait de même ? En général, le soucis survient après une quinzaine d'affichage ...

**ero-sennin** · 13/02/2008, 17h35

Double

! Après écriture des valeurs dans un memo, il en ressort que j'ai plein d'erreurs d'arrondis!!!

Voici un petit extrait des derniers nombres ...

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
223
223,1
223,2
223,3
223,4
223,5
223,6
223,7
223,8
223,899999999999
223,999999999999
224,099999999999
224,199999999999
224,299999999999
224,399999999999
224,499999999999
224,599999999999
224,699999999999
224,799999999999
224,899999999999
224,999999999999

Je n'ai aucune explication à fournir

et comme on peut le voir, on a un arrondi foireux et c'est toujours lorsque l'on arrive à la fin de la 8ième incrémentation que ça merde !!!

**ShaiLeTroll** · 13/02/2008, 17h55

J'ai fait

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
var
  D: double;
begin
  d := 223  ;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  showMessage(FloatToStr(d));
end;

et j'ai bien 223.9

sur un P4 3Ghz (surement HT car double core dans le gestionnaire des processus)

**ero-sennin** · 13/02/2008, 18h03

Envoyé par ShaiLeTroll

J'ai fait

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
var
  D: double;
begin
  d := 223  ;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  d := d + 0.1;
  showMessage(FloatToStr(d));
end;

et j'ai bien 223.9

sur un P4 3Ghz (surement HT car double core dans le gestionnaire des processus)

Oui oui, d'accord avec toi

Chez moi ça fait pareil! Je me suis peut être mal exprimé ...
Si on part de 0 pour arrivé à 9 avec un incrément de 0.1, ba dans ce cas là, c'est encore plus étrange car à cafouille à partir de 5.9! Aie aie aie ...

**ShaiLeTroll** · 13/02/2008, 18h25

Surement lié à la boucle ... et les algo de prédiction de résultat du P4

**ero-sennin** · 13/02/2008, 18h54

Ok ok. Merci pour l'info.
Je mets le code corrigé qui me fait un arrondi correct :

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
procedure InitTabRandom(AFrom,ATo,Increment:Double);
var
  i:Integer;
  Size:integer;
  Value:double;
  precision:integer;
  StrIncrement:string;
begin
  i:=0;
  StrIncrement:=FloatToStr(Increment);
  // Sert à déterminer avec quelel précision sera l'arrondi
  if Pos(DecimalSeparator,StrIncrement)>0 then
   precision:=Length(RightStr(StrIncrement,length(StrIncrement)-Pos(DecimalSeparator,StrIncrement)))
  else
    precision:=0;
 
  Value:=AFrom;
  // On détermine directement le nombre de cases qu'on doit allouer
  Size:=Ceil((ATo-AFrom) / Increment)+1;
  // On redimensionne le tableau en conséquence
  SetLength(TabArray,Size);
  // On remplit le tableau
  while (Value <= ATo ) do
  begin
    Inc(i);
    // On arrondi ...
    TabArray[i-1]:=RoundTo(Value,-precision);
    Value:=Value+Increment;
  end;
end;

Si ça intéresse ...

**ShaiLeTroll** · 13/02/2008, 19h49

Code :

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

precision:=Length(RightStr(StrIncrement,length(StrIncrement)-Pos(DecimalSeparator,StrIncrement)))

ou

Code :

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

Precision :=Length(FloatToStr(Frac(Increment))) - 2

Dingue, il n'y a pas de fonction qui renvoie le nombre après la virgule !

**ero-sennin** · 13/02/2008, 20h06

Envoyé par ShaiLeTroll

Code :

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

precision:=Length(RightStr(StrIncrement,length(StrIncrement)-Pos(DecimalSeparator,StrIncrement)))

ou

Code :

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

Precision :=Length(FloatToStr(Frac(Increment))) - 2

Dingue, il n'y a pas de fonction qui renvoie le nombre après la virgule !

Oué dingue!
En parlant de ta ligne de code, c'est plus adapté je pense mais il n'y a pas besoin du -2

Je pense que tu l'as mis dans le cadre d'avoir un nombre négatif pour précision, hors moi, je le mets directement dans le RoundTo

**ShaiLeTroll** · 14/02/2008, 12h10

si tu as comme Step 1.01, Frac donnera 0.01, je crois donc FloatToStr donnera '0.01', et donc -2 pour retirer '0.'

**ero-sennin** · 14/02/2008, 12h32

Salut,

Envoyé par ShaiLeTroll

si tu as comme Step 1.01, Frac donnera 0.01, je crois donc FloatToStr donnera '0.01', et donc -2 pour retirer '0.'

Effectivement! Mes excuses ...
Merci

**ShaiLeTroll** · 21/02/2008, 17h14

Sinon, cela fonctionne pas du tout avec FloatToStr qui renvoi pour 0.00001 la chaine 1e-06 ... lol ou dans certains cas le frac lui renvoie0.00000999999998....

alors
CountDecimalByString, c'est la plus lente (6 fois plus que ByDiv), et si le frac ne fourni pas la valeur exact, la résultat sera faux !
CountDecimalByMul, c'est la plus rapide, les arrondis du frac peuvent aussi géner, car on prend 4,56789, cela devient 456789.00 mais Frac donne 0.9999997, truc à la con
CountDecimalByRec, c'est la 2nde plus rapide (1.5 fois plus que ByDiv), faux à cause du frac, FloatToDecimal fonctionne sinon parfaitement, si le le nombre est 1000.00001 cela va renvoyer 4, et pour 0.00001, cela donnera -5

Code :

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

1
2
3
4
5
6
7
function CountDecimalByString(const Value: Double): Smallint;
var
  S: string;
begin
  S := FloatToStrF(Frac(Value), ffExponent, 0, 3);
  Result := StrToInt(Copy(S, Pos('E', S) + 2, 3)); // '1,0E-004' pour "0.0001"
end;

Code :

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

1
2
3
4
5
6
7
8
9
function CountDecimalByMul(Value: Double): Smallint;
begin
  Result := 0;
  while Frac(Value) > 0 do
  begin
    Value := Value * 10;
    Inc(Result);
  end;
end;

Code :

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

1
2
3
4
5
6
7
8
9
function CountDecimalByRec(const Value: Double): Smallint;
var
  FloatRec: TFloatRec;
  D: Extended;
begin
  D := Frac(Value);
  FloatToDecimal(FloatRec, D, fvExtended, 18, 18);
  Result := Abs(FloatRec.Exponent);
end;

Comment générer des nombres reéls aléatoires ?

Langage Delphi

Discussions similaires

Partager

Partager