La fonction X = RND(1) est elle vraiment aléatoire ?

' Générateur aléatoire : Test d'équidistribution
'
' La fonction X = RND(1) fournit un nombre entre 0 et 1
' Le générateur aléatoire est censé être équidistribué sur 0-1
' Principe : On découpe l'intervalle en un certain nombre de tranches égales
' (30 dans ce cas précis), on effectue un grand nombre de tirages aléatoires
' (300 par exemple) et on compte le nombre de fois où on est tombé dans chaque
' tranche. Si on a 300 tirages pour 30 tranches, on attend en moyenne 10 tirages
' par tranche. Plus on s'éloigne de 10, mois la distributionest conforme à ce que
' l'on désire. On calcule pour chaque tranche la quantité :(N-10)*(N-10)/10 où
' N est le nombre de tirage dans cette tranche. Si l'on additionne cela sur toutes
' les tranches, on obtient un nombre (le chi carré de la distribution) qui est
' une mesure de la qualité de cette distribution. Plus le chi carré est petit,
' meilleur est la distribution.
' Pour une partition en 30 tranches comme celle employée dans ce programme,une
' valeur du chi carré inférieur à 20 est excellente et une valeur comprise entre
' 20 et 35 est tout à fait acceptable. Si, en revanche, vous obtenez une valeur
' supérieure à 50, votre gégérateur aléatoire est très suspect.

dim nbtranches, nbtirages : nbtranches = 30 : nbtirages = 300
dim t(nbtranches),n,k,x,y,i
label aleat

while n < nbtirages
    gosub aleat
    n = n + 1
    k = 1 + int(x * nbtranches) : t(k) = t(k) + 1
  '  print n
end_while
for i = 1 to nbtranches
    y = y + (t(i) - nbtirages/nbtranches) * (t(i) - nbtirages / nbtranches)
next i
y = y * nbtranches / nbtirages
print " Valeur du CHI^2 = " ; y
end

aleat:
x = rnd(1)
return

' Générateur aléatoire
' Analyse graphique de la repartition bidimentionnelle
'
' On trace des points au hasard sur l'écran en utilisant le générateur aléatoire
' et on constate de visu qu'ils sont bien ou non répartis au hasard.

dim nbpoints : nbpoints = 1000  : ' Augmenter ou diminuer cette valeur pour voir
dim x,y,xp,yp,n

label aleat

color 0,0,0,0 : 2d_pen_color 0,255,0 : font_color 0,255,0,0

while n < nbpoints
    gosub aleat : y = x : gosub aleat
' Transformation en coordonnées écran
    xp = 100 + 320 * x : yp = 100 + 240 * y
    2d_point xp,yp
    n = n + 1
    print_locate 10,10 : print n;  " / " ;nbpoints
end_while

end

aleat:
x = rnd(1)
return

' Générateur aléatoire
'
' Calcul des paramètres statistiques du générateur aléatoire

' Ce programme examine moyennes et écarts-types pour les tirages pairs et impairs
' Pour un nombre de tirages suffisant, les moyennes doivent évoluer autour de 0.5
' et les écarts-types autour de 0.288 ( 1/sqr(12) ).
' Ce programmes vérifie également si les tirages pairs et impairs sont indépendants
' en calculant leur coefficient de corrélation.

' Pour que votre générateur aléatoire soit correct, celui-ci doit être compris
' entre -0.05 et +0.05 (moins de 5% de corrélation).

dim nbtirages : nbtirages = 1000 : ' Valeur à modifier pour voir
dim n,x,y,sx,sy,xy,x2,y2,vx,vy,cv

label aleat

while n < nbtirages
    n = n + 1 : gosub aleat : y = x : gosub aleat
    sx = sx + x
    sy = sy + y
    xy = xy + x * y
    x2 = x2 + x * x
    y2 = y2 + y * y
end_while
vx = sqr((x2 - (sx * sx / n)) / (n - 1))
vy = sqr((y2 - (sy * sy / n)) / (n - 1))
cv = (xy - (sx * sy / n)) / (n - 1)
print "  S T A T I S T I Q U E S "
print
print "  Moyenne des tirages impairs    : " ; sx / n
print "  Moyenne des tirages pairs      : " ; sy / n
print "  Ecart type des tirages impairs : " ; vx
print "  Ecart type des tirages pairs    : " ; vy
print "  Covariance                      : " ; cv
print "  Coefficient de corrélation      : " ; cv /(vx * vy)
end

aleat:
x = rnd(1)
return

' Générateur aléatoire
' Calcul de PI par la methode de Monte-Carlo

' On considère un quart de cercle inscrit dans un carré de coté 1
' Le carré a une surface égale à 1
' Le quart de cercle a une surface égale à pi/4

' Principe de Monte-carlo :
'  si on trace un grand nombre de points au hasard dans le carré, le rapport
'  de ceux qui sont dans le quart de cercle sur le nombre total est égal au
'  rapport des surfaces , c-à-d  pi/4

' Méthode :
'  On tire un grand nombre N de points (X,Y) au hasard. Si X * X + y * y < 1,
'  le point est dans le cercle; alors on augmente P de 1 (P = nombre de points
'  dans le cercle).
'  Lorsque N est très grand P/N tend vers pi/4

' Cette méthode n'est pas très efficasse, mais c'est probablement la plus simple

dim x,y,n,p,a

caption 0, " <CLICK>  pour arrêter "
while scancode = 0
    x = rnd(1) : y = rnd(1) : n = n + 1
    print_locate 10,10
    print 4 * p / n
    if x*x + y*y < 1 then p = p + 1
end_while

' *** Test von RND *************************************************************
'
DIm n%
' n% = 16384
n% = 56
DIM i%
DIM j%
DIM x(n%)
DIM sumx
DIM sumsqx
DIM mean
DIM meanTotal
DIM std
DIM stdTotal


' *** Form 0000
Full_space 0
PRINT
PRINT

FOR i% = 1 TO 10
sumx = 0
sumsqx = 0

FOR j% = 1 TO n%
' RANDOMIZE TIMER
x(j%) = RND(n%)
sumx = sumx + x(j%)
sumsqx = sumsqx + x(j%) * x(j%)

NEXT j%

mean = sumx / n%
std = SQR((sumsqx - sumx * sumx / n%) / (n% - 1))

Wait 1

PRINT mean,"  ", std
meanTotal = meanTotal + mean
stdTotal = stdTotal + std

NEXT i%
'
'
' ******************************************************************************
PRINT "-------------------------"
PRINT meanTotal / 10,"  ", stdTotal / 10
PRINT " .5000000 ";"  ", 1 / SQR(12)

' *****************************************************************************

' 4

' Dieses Format:
' mittlere Standardabweichung
' Mine: .4998024 .2888851 und



' *********************************************************************************
' Wenn Ihr RND den Test nicht besteht:

' If the RND function in your BASIC (or compiled BASIC) is not good Wenn der RND-Funktion in Ihrem BASIC (oder kompilierte BASIC) ist nicht gut
' enough for your requirements, must you give up? genug für Ihre Anforderungen, müssen Sie aufgeben? No, you can still Nein, kann man immer noch
' simulate the RND function with a few BASIC statements. simulieren die RND-Funktion mit ein paar grundlegende Aussagen. The best form Die beste Form
' of RNG is called a `mixed congruential' RNG. der RNG, heisst 'gemischtes Kongruenz "RNG. To implement this form of Um diese Form der Umsetzung
' RNG, you simply select a seed number `R' (which may be zero), multiply RNG, wählen Sie einfach einen Samen Zahl `R '(der Null sein kann), multiplizieren
' it by a selected number, add a different selected number, then save only bis eine ausgewählte Zahl, fügen eine andere ausgewählte Anzahl, dann nur zu speichern
' the decimal portion of the resulting number for both the random number die Dezimalstellen der resultierenden Zahl sowohl der Zufallszahl
' and for the seed number for the next random number. und für die Startnummer für die nächste Zufallszahl. That sounds rather Das klingt eher
' complicated, but it's really quite simple: Just use something like kompliziert, aber es ist wirklich ganz einfach:

' Verwenden Sie einfach so etwas wie
' P = 21 and Q = 0.3271,
' and the formula:
'  P = 21 und Q = 0,3271,
' und die Formel:

' R(n+1) = FRAC(R(n)*P+Q)
' R (n +1) = FRAC (R (n) * P + Q)

' Eine Unterroutine wie:

' 9000 R=R*P+Q :R=R-INT(R) :RETURN
' 9000 R = R * P + Q: R = R-INT (R): RETURN

PRINT n% / 2, "                ", n% / SQR(12)

DIM n%
n% = 56
DIM i%
DIM j%
DIM x(n%)
DIM sumx
DIM sumsqx
DIM mean
DIM meanTotal
DIM std
DIM stdTotal

Full_space 0
PRINT
PRINT

FOR i% = 1 TO 10
  sumx = 0
  sumsqx = 0

  FOR j% = 1 TO n%
    x(j%) = RND(n%)
    sumx = sumx + x(j%)
    sumsqx = sumsqx + x(j%) * x(j%)
  NEXT j%

  mean = sumx / n%
  std = SQR((sumsqx - sumx * sumx / n%) / (n% - 1))

  Wait 1

  PRINT mean,"  ", std
  meanTotal = meanTotal + mean
  stdTotal = stdTotal + std
NEXT i%

PRINT "-------------------------"
PRINT meanTotal / 10,"  ", stdTotal / 10
PRINT n% / 2, "                ", n% / SQR(12)

DIM n%
n% = 56
DIM i%
DIM j%
DIM x
DIM sumx
DIM sumsqx
DIM mean
DIM meanTotal
DIM std
DIM stdTotal
DIM res%

DLL_ON "ranmt.dll"

Full_space 0
PRINT
PRINT

FOR i% = 1 TO 10
  sumx = 0
  sumsqx = 0

  FOR j% = 1 TO n%
    res% = DLL_CALL1("RanMT", ADR(x))  : ' Reel aleatoire dans [0, 1[
    x = n% * x                        : ' Reel aleatoire dans [0, n[
    sumx = sumx + x
    sumsqx = sumsqx + x * x
  NEXT j%

  mean = sumx / n%
  std = SQR((sumsqx - sumx * sumx / n%) / (n% - 1))

  Wait 1

  PRINT mean,"  ", std
  meanTotal = meanTotal + mean
  stdTotal = stdTotal + std
NEXT i%

PRINT "-------------------------"
PRINT meanTotal / 10,"  ", stdTotal / 10
PRINT n% / 2, "                ", n% / SQR(12)