Wertebereich von -X bis +X erstellen ?

[turboPASCAL]

Hi,

Ich ein kleines Problem. Ich möchte gern einen Wertebereich so einfach wie möglich erstellen
der von Minimum -X bis maximum +X reicht. Das ist ja weiter nicht so schlimm:

Delphi-Quellcode:

X :=  (100 + random(100)) - (100 + random(100) );

Aber nichts im Bereich von -50 bis +50.


Ich komm gerade nicht darauf... :gruebel:

[RWarnecke]

ich würde das ganze so machen :

Delphi-Quellcode:

niedrigsterWert := random(50);
hoechsterWert := random(50);
niedrigsterWert := (niedrigsterWert * 2) - niedrigsterWert

Oder müssen es immer Paare sein z.B. -45 und +45 ?

[turboPASCAL]

Ja.

Nach deiner Lösung hätte ich mehr -X als +X.

[Helmi]

Zitat:

Zitat von RWarnecke

Delphi-Quellcode:

niedrigsterWert := (niedrigsterWert * 2) - niedrigsterWert

Dann kannst gleich das schreiben:

Delphi-Quellcode:

niedrigsterWert := niedrigsterWert;

Denn (umgeschrieben)

Delphi-Quellcode:

niedrigsterWert := (niedrigsterWert + niedrigsterWert) - niedrigsterWert

ist identlisch mit:

Delphi-Quellcode:

niedrigsterWert := niedrigsterWert

Oder diese Zeile einfach weglassen :-)

[Fussball-Robby]

Delphi-Quellcode:

X := Random(101) - 50;

Random(101) = 0..100, dann 50 abziehen -> -50..50. Ich hoffe ich hab das so richtig verstanden, dass du eine zufällige Zahl zwischen -50 und 50 haben wolltest?

[DeddyH]

Meinst Du sowas?

Delphi-Quellcode:

function MyRandom(iRange: Integer): Integer;
const iSigns: array[0..1] of Integer = (1,-1);
begin
  Result := Random(Succ(iRange)) * iSigns[Random(2)];
end;

[turboPASCAL]

In Etwa. :stupid:
Nur bekomme ich dann eine lustige Gruppenbildung (siehe Anhang).

Delphi-Quellcode:

function MyRandom(minRange, maxRange: Integer): Integer;
const
  iSigns: array[0..1] of Integer = (1, -1);
begin
  Result := (minRange + Random(maxRange + 1)) * iSigns[Random(2)];
end;

// Edit:

Ich möchte. um es mal bildlich darzustellen eine hole Kugel deren Mantel aus Punkten besteht.
(eine Kugel oder ein Quader ist dabei egal)

[Fussball-Robby]

Kleiner Tipp: Dir Funktion RandomRange() aus der Unit Math, bevor hier noch weiter rumgebastelt wird :mrgreen:

[jfheins]

Und wie kommst du von der Randow-Fuznktion zu den Punkten?

Weil ich glaube schon, dass die Randowm-Funktion richtig arbeitet :stupid:

Ediit: nehme es zurück: Sie arbeitet falsch.

Wie man am Demo-Prog erkennen kann, wird die 0 überbewertet.

Da es +0 und -0 gibt ;)

==> nur einmal randowm verwenden und auf den passendden Bereich mappen.

[turboPASCAL]

Die Funktion RandomRange() aus der Math-Unit habe ich nicht da ich die Unit Math.pas nicht in meinem Programm habe. :stupid:
Diese importiere ich auch nicht da sie mir Units imliziert importiert die ich nicht imliziert importiert haben will.
:gruebel:


Was zum ... ist ein "randowm" ? Was zu essen ?
:mrgreen:



Lösungsvorschlage ?

[Larsi]

Du willst aber keinen Kexgen erstellen oder? Sieht für mich so aus :mrgreen:

[jfheins]

Ja, was zum Essen :mrgreen:

Erzeugt eine Zufallszahl zwischen -x und x

Code:

        private int MyRandom(int x) 
        {
            Result = Random(2 * x + 1) - x;
        }

Achtung - Kompiliert nicht :mrgreen:

[turboPASCAL]

@Larsi,
Doch. :mrgreen: Ich muss nur noch jemanden Überreden eim Programm passend zu meinem Keksgen zu schreiben.


@jfheins Ja, eine Zufallszahl zwischen -x und x. Das ist aner nicht das Problem an sich,
das Loch in der Mitte ist es.

Siehe bildliche Beschreibung in Post #7.

[jfheins]

Zitat:

Zitat von turboPASCAL

@Larsi,
Doch. :mrgreen: Ich muss nur noch jemanden Überreden eim Programm passend zu meinem Keksgen zu schreiben.

Auja, ein Keksgenerator hätte was :stupid: Dann hab ich auch was zum naschen :mrgreen:

Zitat:

@jfheins Ja, eine Zufallszahl zwischen -x und x. Das ist aner nicht das Problem an sich,
das Loch in der Mitte ist es.

Siehe bildliche Beschreibung in Post #7.

Wie gesagt, meine Funktion erfüllt den Zweck 100%ig. Die Zufallszahlen sind auch gleich verteilt.

Deshalb ja meine Frage, wie du von den Zufallszahlen zu den Punkten kommst ;)

[turboPASCAL]

Achso, so:

Delphi-Quellcode:

procedure some...;
const
  WBMax = 150;
  WBMin = 50;

  function MyRandom(minRange, maxRange: Integer): Integer;
  const
    iSigns: array[0..1] of Integer = (1, -1);
  begin
    Result := (Random(maxRange + 1)) * iSigns[Random(2)];
  end;

begin
  for i := 0 to high(p3d) do
  begin
    p3d[i].X := MyRandom(WBMin, WBMax);
    p3d[i].Y := MyRandom(WBMin, WBMax);
    p3d[i].Z := MyRandom(WBMin, WBMax);
  end;
end;

[jfheins]

Du benutzt aber schon randomize, oder?

Edit: Wenn du gerne eine Kugel aus den Punten haben willst, solltest du in Kugelkoordinaten rechnen, beide Winkel zufällig wählen und den Radius mehr oder weniger zufällig wählen, und das dann in kartesische Koordinaten umrechnen ;)

[turboPASCAL]

Zitat:

Du benutzt aber schon randomize, oder?

Klar.

Nur wie gesagt ich bekomme immer diesen Gruppeneffekt. Ich muss mir wohl doch das Kugelkoordinatendings antun. :gruebel:

[turboPASCAL]

:stupid:

(Simmt zwar noch nicht so recht, passt aber)

[angos]

Zitat:

Zitat von turboPASCAL

Achso, so:

Delphi-Quellcode:

procedure some...;
const
  WBMax = 150;
  WBMin = 50;

  // Berechnet einen Zufallswert zwischen minRange und MaxRange
  // Dieser Wert wird zufällig positiv oder negativ zurückgegeben werden
  function MyRandom(minRange, maxRange: Integer): Integer;
  const
    iSigns: array[0..1] of Integer = (1, -1);
  begin
    // Result := (Random(maxRange + 1)) * iSigns[Random(2)];
    Result := minRange + (Random(maxRange + 1)) * iSigns[Random(2)];
  end;

begin
  for i := 0 to high(p3d) do
  begin
    p3d[i].X := MyRandom(WBMin, WBMax);
    p3d[i].Y := MyRandom(WBMin, WBMax);
    p3d[i].Z := MyRandom(WBMin, WBMax);
  end;
end;

Hast du hier nicht einfach nur das minRange vergessen? :gruebel:

Gruß
Ansgar

PS: Bei deinen Downloads meckert mein Kaspersky: Das angeforderte Objekt ist mit folgenden Viren INFIZIERT: Multi.Packed

[turboPASCAL]

Zitat:

Hast du hier nicht einfach nur das minRange vergessen?

Nein, nicht direkt.

Genauer müsste die Procedure so aussehen:

Delphi-Quellcode:

function RandomFromTo(minRange, maxRange: Integer): integer;
const
  iSigns: array[0..1] of Integer = (1, -1);
begin
  Result := (minRange + Random((maxRange-minRange) + 1)) * iSigns[Random(2)];
end;

Das bringt aber leider nix da das Resultat eher komisch im Ergebnis wie oben beschrieben ausschaut.

Absolut nicht Perfekt aber Funktionsfähig wie gewünscht wird es zur Zeit so errechnet:

Delphi-Quellcode:

function MyRandom(minRange, maxRange: Integer): TVector_3D;
const
  iSigns: array[0..1] of Integer = (1, -1);
begin
  Result.X := cos((minRange + Random((maxRange) + 1)) * iSigns[Random(2)])*minRange;
  Result.Y := sin((minRange + Random((maxRange) + 1)) * iSigns[Random(2)])*minRange;
  Result.Z := cos((minRange + Random((maxRange) + 1)) * iSigns[Random(2)])*minRange;
end;

PS zum PS.:

Zitat:

PS: Bei deinen Downloads meckert mein Kaspersky: Das angeforderte Objekt ist mit folgenden Viren INFIZIERT: Multi.Packed

Das kann durchaus vorkommen das ein Antivierenprogramm die Exe bemeckert. Sie ist in der Tat gepackt aber VIERENFREI !
Selbst wenn die Datei mit UPX gepackt wird meckert mein AntiVir mit akt. Updates.

Leider bekomme ich auf programiertechnische Weise die App noch nicht kleiner als 120 KB. :cry:

[jfheins]

Wie bereits in #9 gesagt: Vegiss bitte dieses "iSigns[Random(2)]" - das bevorzugt die Null und verfälscht daher das Ergebnis. (Die null wird doppelt so oft gezogen wie andere Zahlen da minus null gleich plus null)

Ich weis zwar nicht, inwieweit das dein Ergebnis beinflusst, aber naja ;)

Wenn du willst, kann ich dir auch ne Funktion schreiben, die einen zufälligen Vektor mit dem Betrag r (also zufällige Richtung bei bestimmten betrag) ausspuckt ;)

Oder alternativ zufällige Richtung und Bertag zwischen rmin und rmax ;)

[turboPASCAL]

Wenn du Langeweile hast, kannst du nem altem Man so etwas antun. :mrgreen:

[jfheins]

Okay, dann will ich das mal tun :P

Delphi-Quellcode:

TVector3D = record
  X,  Y, Z: Double;
end;

function RandomFromTo(minRange, maxRange: Double): Double;
begin
  Result := Random() * (maxRange - minRange) + minRange;
end; // Random liefert eine Zahl zwischen 0 und 1 ???

function RandomPoint(minRadius, maxRadius: Double): TVector_3D;
const
  PI = 3.1415926535;
var
  r, phi, theta: Double
begin
  r = RandomFromTo(minRadius, maxRadius);
  phi = RandomFromTo(0, 2*PI);
  theta = RandomFromTo(0, PI);

  Result.X = r * sin(theta) * cos(phi);
  Result.Y = r * sin(theta) * sin(phi);
  Result.Z = r * cos(theta);
end;

Da ich kein Delphi hab, Code ohne Compilierbarkeits-garantie ;)

Die Funktion sollte dann entsprechend Punkte ausspucken, deren Betrag in den Grenzen liegt, und eine zufällige Richtung haben.

Das kann man natürlich umso besser sehen, je mehr Punkte du erstellst ;)

Btw.: zum Testen kannst du ja einmal statt -PI eine Null einsetzen, dann sollte es nur eine Halbkugel werden ...

[turboPASCAL]

Zitat:

Zitat von jfheins

Okay, dann will ich das mal tun :P

Hui, nett.

Zitat:

Zitat von jfheins

Code:

[b]const[/b]
  [color=#ff0000]PI[/color] = 3[color=#ff0000][b],[/b][/color]1415926535;

Zu viel C .net ? Pi ist in Delphi definiert. ;)

Zitat:

Zitat von jfheins

Da ich kein Delphi hab, Code ohne Compilierbarkeits-garantie ;)

Och, das wird schon.

Zitat:

Zitat von jfheins

Die Funktion sollte dann entsprechend Punkte ausspucken, deren Betrag in den Grenzen liegt, und eine zufällige Richtung haben.

Eine schöne runde Kugel.

Zitat:

Zitat von jfheins

Das kann man natürlich umso besser sehen, je mehr Punkte du erstellst ;)

Logisch. aber der Rechenaufwand wird grösser was dan beinstarten dauert.

Zitat:

Zitat von jfheins

Btw.: zum Testen kannst du ja einmal statt -PI eine Null einsetzen, dann sollte es nur eine Halbkugel werden ...

Eher ein Ring, gelle. ;)

:thumb:

[jfheins]

Freut mich, geholfen zu haben :)

Es ist aber leider noch ein kleiner Fehler drin:
Laut Wikipedia sollte phi im Intervall 0 bis 2*Pi sein und theta von 0 bis Pi.

Und wenn du dann ein Intervall halbierst sollte tatsächlich eine Halbkugel rauskommen und kein Kreis. Der sollte dann kommen, wenn du theta gleich Pi/4 setzt ... und ein Halbkreis, wenn du stattdessen phi konstant setzt :mrgreen:

Dann stimmts übrigens auch mit dem Bild: http://de.wikipedia.org/w/index.php?...inaten_svg.png ;)

[mschaefer]

Moin, moin,

so dann werfe ich auch mal meine Randomformel in den Thread !

Delphi-Quellcode:

function MyRandom ( High        : integer;   { Oberer Wert  (+100) }
                    Shift       : integer;   { Verschiebung (- 50) }
                    n           : Integer;   [ Anzahl              } 
                    MyMemoLines : TStrings   ( Vom Memo nebenan)   )                      )
var
  int   : Integer;
  i     : Integer;

// Generiert eine integer random Nummer zwischen 1..High und verschiebt um Shift
  for i := 1 to n do
  begin
    int := 1 + Random(abs(High) );    // Der 100 Wert würde einen Bereich von 0..99 ergeben, deshalb +1
    int :=  int + Shift;
    MyMemoLines.add ('n: ' + inttostr(n) + '  Random: '+IntToStr(int) );
  end;
end;

Grüße // Martin

[turboPASCAL]

Bevor ich es vergesse, danke. :thumb: