Ik had onlangs een idee voor een random number generator. Nu vraag ik me af in welke mate de gegenereerde nummers echt willekeurig zijn. Als er sprake is van echte willekeurigheid lijkt dit interessant, anders niet.
Hieronder drie voorbeeldjes van 100 nummers tussen 0 en 63 (incl.):
Code: Selecteer alles
45 40 58 17 8 41 56 8 43 4 43 29 44 44 58 46 30 58 53 20 53 12 42 40 8 47 40 30 20 28 41 55 23 19 19 27 9 53 20 42 51 7 10 34 13 54 47 21 21 16 55 42 16 35 50 0 25 25 43 10 51 60 61 22 47 43 49 60 59 56 30 2 59 24 21 27 23 46 61 26 6 48 30 50 38 43 51 11 38 47 10 52 25 40 50 44 19 42 38 20
Code: Selecteer alles
49 8 32 59 17 9 41 20 23 21 21 61 23 43 29 13 30 5 38 44 26 11 63 55 61 30 22 61 54 6 54 5 53 53 26 58 42 62 42 57 42 3 41 36 23 37 29 23 22 43 46 12 20 8 33 21 9 13 59 45 29 7 22 42 37 10 40 46 45 15 22 20 38 47 37 58 54 61 38 57 39 55 30 56 42 48 63 50 57 36 54 48 49 7 54 50 59 42 36 29
Code: Selecteer alles
44 33 4 10 42 58 48 42 38 48 33 50 63 38 53 5 53 57 52 17 3 40 30 42 59 34 57 43 10 40 38 12 43 43 6 41 19 27 19 29 36 52 58 17 22 34 47 53 15 44 43 41 15 53 5 21 21 48 35 35 57 43 13 30 42 41 10 27 54 31 12 21 33 45 9 59 5 22 39 20 50 63 44 61 47 37 41 40 14 47 3 4 5 30 19 26 41 44 31 54
Principe kort uitgelegd: twee threads checken constant een boolean variabele, wanneer die op true wordt gezet, geeft één van de twee threads een waarde aan een getal en zet de boolean variabele weer op false. Zo geeft bijvoorbeeld de ene thread waarde 1 en de andere thread waarde 0. Op die manier genereer je een rij van nullen en eenen die je decimaal kan voorstellen.
Code in Java:
-
Spoiler: [+]
Code: Selecteer alles
public class RandomNumber {
static boolean assign=false;
static boolean kill=false;
static int number=2;
static int decNumber=0;
static int binairySize=6;
static int[] binairyList=new int[binairySize];
static Thread t0=new Thread(){
public void run(){
while(!kill){
if(assign){
assign=false;
number=0;
try {sleep(1);} catch (InterruptedException e) {}
}
}
}
};
static Thread t1=new Thread(){
public void run(){
while(!kill){
if(assign){
assign=false;
number=1;
try {sleep(1);} catch (InterruptedException e) {}
}
}
}
};
static void generateNumber(int amount){
for(int a=0;a<amount;a++){
//genereer nummer
for(int i=0;i<binairySize;i++){
assign=true;
try {Thread.sleep(10);} catch (InterruptedException e) {}
binairyList[i]=number;
}
//print decimale vorm
decNumber=0;
for(int j=0;j<binairySize;j++){
decNumber+=binairyList[j]*(int)Math.pow(2, binairySize-j-1);
}
System.out.print(decNumber+" ");
}
}
public static void main(String[] args) {
//start de twee threads
t0.start();
t1.start();
try {Thread.sleep(10);} catch (InterruptedException e) {}
//genereer en print 100 nummers
generateNumber(100);
//stop de twee threads
kill=true;
}
}
Hoe test ik het best op willekeurigheid? Zijn er manieren te voorspellen welke thread (en dus processor) het getal uiteindelijk een waarde geeft?
Je leest maar niet verder want je, je voelt het begin van wanhoop.
