wie funktioniert eigentlich random()

[Lukas-P]

hm ich hab irgenwei gerade ncihts besseres zu tuen un dann komtm mir die Frage in den Kopf wie funktioneirt eigentlich Random() ?

[AND51]

Wie es genau funktioniert weiß ich nicht. Nur so viel: Es ermittelt irgendwie aus der Systemzeit eine Zufallszahl.

Zur Funktionsweise:
Debug Random(5) gibt eine Zufallszahl zwischen 0 und 5 aus. Immer eine Ganzzahl (ohne Komma) zwischen 0 und deiner Zahl.
Und wenn du die Lottozahlen zufällig ermitteln willst, schreibt du einfach
Debug Random( 48 )+1, d. h. Er ermittelt eine Zufallszahl zwischen 0 und 48 und "verscheibt" diese Bandbreite an Zahlen um 1 nach oben.
Zufallszahl zwischen -10 und 10: Debug Random(20)-10
Hier habe ich den Befehl Debug verwendet, der gibt einfach den Rückgabewert von Random() aus.
Folgender:

Code: Alles auswählen

OpenWindow(#PB_Any, 0, 0, Random(400)+100, Random(250)+100, #PB_Window_SystemMenu|#PB_Window_ScreenCentered, "Testfenster")

würde ein fenster öffnen mit einer Zufälligen Größe. 100 bis 500 Pixel breit und 100 bis 350 Pixel hoch.

Du siehst, man kann also die Random()-Befehle auch direkt in soetwas wie OpenWindow() einbauen.

Schau nochmal n der Hilfe nach RandomSeed(), damit kannst du, wenn du diesen befehl vor allen adneren Random-befehlen anwendest, immer wieder die gleiche Zufallszahlen in derselben reihenfolge bekommen, wenn du das brauchst. Lässt du RandomSeed() weg, kommen immer weider neue, andere Zufallszahlen heraus.

MfG, AND51

[freedimension]

Also, das ist sehr oft als Kette von Berechnungen implementiert, d.h. du initialisierst einmalig deinen Zufallsgenerator mit der Zahl R und rechnest anhand dieser einen zufälligen Wert aus. Sehr oft ist bei den Berechnungen dann noch eine LookUp Table (LUT) im Spiel.

Sehr stark vereinfachter Pseudocode:

Code: Alles auswählen

currentR = R

Prozedur Random
  Global currentR
  currentR = currentR % LUT(currentR % 256)
  Return currentR  
ProzedurEnde

LUT = (34, 46, 23, 62, ...)

Wirklich funktionierende Beispiele findest du aber auch über Google.

[remi_meier]

Z. B. so:

Code: Alles auswählen

#m=100000000
#m1=10000
#b=31415821

i.l
Global a.l
N.l

Procedure mult(p.l,q.l)
  p1.l
  p0.l
  q1.l
  q0.l
  p1=Int(p/#m1)
  p0=p%#m1
  q1=Int(q/#m1)
  q0=q%#m1
  ProcedureReturn (((p0*q1+p1*q0)%#m1)*#m1+p0*q0)%#m
EndProcedure

Procedure myrandom(r)  ;r=max
  a=(mult(a,#b)+1)%#m
  ProcedureReturn Int((Int(a/#m1)*r)/#m1)+1  ;zahlen von 1 bis r
EndProcedure

N=10
a=Random(12135)   ;seed
For i=1 To N
  Debug myrandom(11)  
Next

[xperience2003]

endgeil...jetz hab ich endlich ne gängige random funktion für pb-amiga

DANKE remi

...jetz brauch ich nur noch ne sin() cos() lololol ...pb amiga hat sowas nämlich nicht

[Kaeru Gaman]

für sin() und cos() kan ich dir da ne tabelle empfehlen...

für die meisten anwendungen reicht ein array, wo du ein paar hunderst ergebnisse drin speicherst...

und schneller ist es auch, nur speicherintensiver....


im zweifel proggst dus selbst über den pythagoras, damit wärst du sogar eigentlich beim echten sinus.. oder?

[Froggerprogger]

@experience
Für sin() gibt's ne schöne Taylorentwicklung

Code: Alles auswählen

Procedure.f mySin(x.f)
  Protected res.f, sum.f, num.f, denom.f

  ; map x into [0, 2*PI[
  x   = x/(2*#PI)
  x   = x-Int(x)
  sum = x*(2*#PI)
  
  ; do the taylor series approx 
  res   = 0.0
  num   = -sum*sum
  denom = 2.0
  repeat
    res   = res + sum
    sum   = sum * num / (denom*denom+denom)
    denom + 2.0
  until abs(sum/res) < 1/100000
  
  ProcedureReturn res
EndProcedure

Procedure.f myCos(x.f)
  ProcedureReturn mySin(x + 0.5*#PI)
EndProcedure

Debug "Calculating the sine and cos using"
Debug "the taylor series approximation."
Debug "val := mySin(x) - sin(x):"
Debug "val := myCos(x) - cos(x):"

For i=0 to 20
  bla.f = Random(100000)/1000.0 - 50.0
  debug StrF(mySin(bla) - Sin(bla), 10)
  debug StrF(myCos(bla) - Cos(bla), 10)
next

Trotzdem sollte man diese Prozeduren nicht in zeitkritischen Abschnitten verwenden (Bei mir braucht mySin() für 1.000.000 Durchläufe etwa 650 ms, während sin() nur 20 braucht), aber man könnte mit ihnen z.B. ein Array mit z.B. 3600 Werten (also für jedes Zehntelgrad ein Wert) zu Beginn des Programms erstellen.

[Froggerprogger]

[Habe ab Xabys Beitrag abgeschnitten, da das ja nun wirklich gar nix mehr mit dem Thema zu tun hatte. Wer da weiterlesen will:
http://forums.purebasic.com/german/viewtopic.php?t=5613 ]

[Kaeru Gaman]

aber man könnte mit ihnen z.B. ein Array mit z.B. 3600 Werten (also für jedes Zehntelgrad ein Wert) zu Beginn des Programms erstellen.

yap, so meinte ich das.

man kann sie da auch nach den bedürfnissen der anwendung richten,
viele brauchen keine 3600 verschiedenen werte.
(und manchmal braucht man vielleicht sogar mehr)