Hallo,

Ich benutze diese beiden Funktionen um Zufalls-Gleitkommazahlen in einem bestimmten Bereich zu bekommen.

markieren

Delphi-Quellcode:

function iZufallsZahlen(Von, Bis: Integer): integer;
begin
  Result:= RandomRange(Von, Bis+1);
end;

function dZufallsZahlen(Von, Bis: Integer): Double;
begin
  Result:= iZufallsZahlen(Von*100, bis*100)/100;
end;

Mit diesen Funktionen bekomme ich Gleitkommazahlen immer mit 2 Nachkommastellen, ich würde aber gerne auch die Nachkommastellen durch den Zufallsgenerator laufen lassen, so dass ich immer Nachkommastellen von 0 bis 8 bekomme.

Hat einer eine Idee, wie man das am besten realisieren kann?

Bis bald Chemiker

zusammenfalten · markieren

Delphi-Quellcode:

function Random2(digitCount: Integer): Double;
var i: Integer; offset: Double;
begin
  Result := 0;
  offset := 0.1;
  for i := 1 to digitCount do
  begin
    Result := Result + Random(9) * offset;
    offset := offset * 0.1;
  end;
end;

Ich weiß nicht, ob ich genau verstanden habe, was du willst, aber vllt. ist es das: (?)

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer): Double;
begin
  Result:= von+random*(bis-von);
end;

MfG,
Bug

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer; Stellen:byte): Double;
var K:cardinal;
begin
  K:=trunc(power(10, Stellen));
  Result:= (Von*K + random((bis-von)*K)) / K;
end;

Ich lese die Anforderung als Random2.ToString ~ [0-8]+ - dann würde der normale Generator eher versagen, egal wie er gewrapt wird.

Hallo,

Dank für die Antworten.

@Bug: Die Gleitkommazufallszahlen in Deiner Function leistet meine Function auch.
Ich würde gerne auch die Nachkommastellen durch den Zufallsgenerator bestimmen
lassen.
Das Ergebnis sollte dann wie folgt aussehen:

100,01234
99,2
-0,0004 usw.

@Dax: Mit Deiner Funktion kommen auch immer die gleiche Anzahl an Stellen raus.
Ich kann jetzt nicht so richtig feststellen, was der unterschied zu meiner Function ist.

@omata: Die Function leistet das gleiche wie meine Function außer das ich die Stellenzahl direkt vorgegeben habe durch die Division durch 100.

Ich muss die Frage präziser stellen.

Die Function dZufallsZahlen kann Gleitkommazufallszahlen in einem Bereich von bis generieren.
z.B.: von -100 bis 100

Ich möchte die Gleitkommazufallszahlen aber zusätzlich mit unterschiedlicher Kommastelle erstellen. Wie die Funktion jetzt erstellt worden ist kommen immer 2 Nachkommastellen.
Die Zahlen sollen also zwischen von und bis liegen und zusätzlich verschiede Nachkommastellen haben.

Bis bald Chemiker

Zitat von Chemiker:

Die Zahlen sollen also zwischen von und bis liegen und zusätzlich verschiede Nachkommastellen haben.

genau das macht folgendes...

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer; Stellen:byte): Double;
var K:cardinal;
begin
  K:=trunc(power(10, Stellen));
  Result:= iZufallsZahlen(Von, Bis) + random(K) / K;
end;

Hallo,

ich glaube, dass ich eine Lösung gefunden habe.

zusammenfalten · markieren

Delphi-Quellcode:

function iZufallsZahlen(Von, Bis: Integer): integer;
begin
  Result:= RandomRange(Von, Bis+1);
end;

function dZufallsZahlen(Von, Bis: Integer): Double;
const ArrKommaStellen : Array [0..7]of Integer =(1,
                                                 10,
                                                 100,
                                                 1000,
                                                 10000,
                                                 100000,
                                                 1000000,
                                                 10000000);
var
  KommaStellen: Integer;
begin
  KommaStellen:= RandomFrom(ArrKommaStellen);
  Result:= iZufallsZahlen(Von*KommaStellen, bis*KommaStellen)/KommaStellen;
end;

Vielleicht kann das einer von Euch mal überprüfen, ob man das so machen kann.

@Omata: Ich werde Deine Lösung auch noch mal prüfen.

Bis bald Chemiker

Hallo Omata,

die Werte sind aber nicht immer in den von bis Bereich.

Bis bald Chemiker

Einfacher:

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer): Double;
var
  KommaStellen: Integer;
begin
  KommaStellen := Power(10, random(8))*10;
  Result := iZufallsZahlen(Von*KommaStellen, bis*KommaStellen)/KommaStellen;
end;

Dennoch ist hierbei niemals sicher, dass die resultierenden Zahlen auch wirklich Log10(KommaStellen) Nachkommastellen hat, was an der internen Darstellung von Fließkommazahlen liegt. Das ist ein systemisches Problem, dass du nur über einen Festkommadatentyp lösen kannst. Zudem musst du aufpassen, weil ein Double mehr Nachkommastellen haben kann, als ein Integer Stellen insgesamt. Das heisst, dass du dir mit mehr als 8 Nachkommastellen sehr wahrscheinlich einen Integer-Überlauf in obiger Funktion einhandelst.

Um das zu beseitigen würde ich es dann so machen:

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer): Double;
var
  KommaStellen: Double;
begin
  KommaStellen := Power(10, random(15))*10;
  Result := (Trunc(Von + random*(Bis-Von))*KommaStellen)/KommaStellen;
end;

Die Ungenauigkeit der Floats bleibt jedoch, insbesondere bei sehr großen Zahlen wird sich das hier bemerkbar machen. Ebenso dürfte es bei 15 Nachkommastellen zu erheblichen Rechenfehlern kommen, da ja eine Zahl aus dem Bereich (Von; Bis) mit 1000000000000000 multipliziert wird, und damit dann die signifikanten Stellen von Double überschritten werden, sobald die Zahl >10 ist.
D.h. du müsstest vorher einplanen, wie viele Stellen deine Zahlen vor dem Komma haben können sollen, und entsprechend 15 minus dieser Anzahl an Nachkommastellen zulassen. (15 weil Double 15-16 signifikante Stellen im Dezimalsystem hat, womit man mit 15 auf der sicheren Seite ist.)


Alternativ kannst du aber auch folgendes machen:

markieren

Delphi-Quellcode:

function dZufallsZahlen(Von, Bis: Integer; var KommaStellen: Integer): Double;
begin
  KommaStellen := random(16);
  Result := Von + random*(Bis-Von);
end;

Dabei wird einfach eine Zufallszahl mit zufällig vielen Nachkommastellen (meistens wohl "alle") erzeugt, und zusätzlich ein Zufallsinteger zurückgegeben, der die Anzahl der bei der Darstellung der Zahl als String zu verwendenden Nachkommastellen angibt. Um ggf. Nullen an das Ende anzufügen um eine feste Länge der Zahl zu erreichen, würde ich dann auf Stringoperationen zurückgreifen: Einfach '0' anhängen bis der String die richtige Länge hat. Damit brauchst du dich nicht mehr um die Ungenauigkeiten von Floats zu scheren, dafür taugt es aber halt auch nur, wenn es dir explizit darum geht diese Zahlen als String auszugeben. Wenn es für eine weitere Berechnung erheblich ist wie viele Nachkommastellen eine Zahl hat, dann kommst du um Fixed-Point Arithmetik nicht herum.


Fazit: Da man bei der trunc(Muliplikation)Divisions-Methode sehr schnell die jeweiligen Wertebereiche überschreitet, und man eben mit der internen Darstellung von Floats so seine Last hat wenn es auf die Genauigkeit so an kommt, wäre der 3. Vorschlag der einzige der sicher genug arbeitet, oder aber wenn mit den Werten in dieser Genauigkeit (nämlich exakte Genauigkeit) weiter gerechnet werden soll, kommt man nur noch mit Festkommazahlen ans Ziel. Alles andere wäre Rumgehackel und bestenfalls ein "dirty trick", aber nichts zum vorm Chef damit glänzen