Generierung Zufallszahl von 2^30

Question

Ich möchte Zufallszahlen im Bereich von 0 bis 2^10 generieren. Ich habe gehört, dass rand() Funktion für diese vielen Zahlen nicht geeignet ist. Gibt es eine andere Möglichkeit, es mit fast gleicher Verteilung zu generieren?

Answer 1

g_random_int() gibt ein zufälliges guint32 gleichmäßig über den Bereich [0..2^32-1] verteilt.

#include <glib.h> 

int 
main(void) 
{ 
    g_print("%d\n", g_random_int()); 
    return 0; 
} 

mit gcc:

gcc -o rand rand.c `pkg-config --cflags --libs glib-2.0` 

EDIT:

Lesen direkt von/dev/random (weniger tragbar), Kompilieren wie üblich:

#include <stdio.h> 
#include <sys/types.h> 
#include <fcntl.h> 
#include <unistd.h> 

int 
main(void) 
{ 
    int    fd; 
    unsigned int number; 

    fd = open("/dev/random", O_RDONLY); 

    read(fd, &number, sizeof(number)); 

    printf("%u\n", number); 
    close(fd); 
    return 0; 
} 

PS: Auf Fehler prüfen.

Answer 2

Mark A. Overton hatte einen netten Artikel auf recht einfache, aber qualitativ hochwertige RNGs auf Dr. Dobbs am 24. Mai 2011

Answer 3

In Java können Sie Zufalls verwenden, die nach 2^48 Werte wiederholt sich.

Random rand = new Random(); 

for(int i = 0; i < (1<<30); i++) { 
    int n = rand.nextInt(1 << 10); 

} 

Answer 4

Die C++ <random> Bibliothek ist eine ausgezeichnete Wahl, mit vielen Möglichkeiten von PRNG Motor und Verteilung.

#include <random> 
#include <cstdint> 
#include <iostream> 

int main() { 
    std::random_device r; 
    std::seed_seq seed{r(), r(), r(), r(), r(), r(), r(), r()}; 
    std::mt19937_64 eng(seed); 
    std::uniform_int_distribution<> dist(0, 1<<10); 

    for (std::uint32_t i = 0; i< (1<<30); ++i) { 
     int value = dist(eng); 
     std::cout << value << ' '; 
    } 
} 

Auch random_device ist selbst ein Motor, der kann, abhängig von der Implementierung, den Zugang zu einem nicht-deterministisch oder Verschlüsselungs RNG bieten:

std::random_device eng; 
std::cout << dist(eng) << '\n'; 

Zum Beispiel in libC++ verwendet es/dev/urandom Standardmäßig verwendet OS X den Yarrow-Verschlüsselungs-RNG-Algorithmus.

Answer 5

Ein einfacher Weg, die Zufälligkeit und Periode zu inkrementieren:

public class Random2 { 

    private static int LEN = 64; 
    private final int[] buf = new int[LEN]; 
    private Random r; 
    private final int maxInt = 1 << 10; 

    public Random2() { 
     r = new Random(); 
     for (int i = 0; i < LEN; i++) 
      buf[i] = r.nextInt(maxInt); 
    } 

    public int nextInt() { 
     int i = r.nextInt(LEN); 
     int x = buf[i]; 
     buf[i] = r.nextInt(maxInt); 
     return x; 
    } 

} 

Answer 6

Hier ist ein alter Usenet-Post mit einer Reihe von interessanten RNGs - alles sehr einfach zu implementieren.

http://www.cse.yorku.ca/~oz/marsaglia-rng.html

Sie können nicht ganz die Mersenne-Twister passen, aber ich habe gute Verwendung von mehreren von ihnen gemacht und sie sind sicherlich überlegen einige der Standard-rand() Implementierungen. Sie bestehen die DIEHARD Tests der Zufälligkeit und der größte Periodengenerator hat eine Periode von> 2^7700 und benötigt nicht mehr als ein paar Zeilen zum Implementieren.

Ken