Immer große Zufallszahlen in C/C++

Standard rand() - Funktion gibt zahlen nicht groß genug für mich: ich brauche unsigned long long lieben. Wie bekommen wir die wirklich großen Zufallszahlen? Ich habe versucht, ändern Sie eine einfache hash-Funktion, aber es ist zu großen, zu lange dauert zu laufen und führt nie zu zahlen, die weniger als 1e5!!

Wie viel "GROßE" zahlen, die Sie wollen?
Wie wäre es mit rand() zu bekommen Sätze von Zufalls-bits, und füllen jedes int-Breite Anzahl von bits in einer Zeit, in der unsigned long long unter Verwendung von bit-Masken.
"nie zahlen, die kleiner sind, als 1e5" - wie haben Sie "nie"? Es wäre zu erwarten, dass der vollkommen zufällige zahlen würden nicht belegen, dass die Palette sehr oft, da die volle Bandbreite Sie für Fragen.
wie wäre Notwasserung rand() und mit einigen der besser RNGs c++ bietet en.cppreference.com/w/cpp/numeric/random
SEHR groß, viel mehr als 1e7
Haben Sie gesehen, stackoverflow.com/questions/8120062/...?
Ich bin nur nicht sicher, ob diese zahlen passen in unsigned long long

InformationsquelleAutor ForceBru | 2015-01-23

c c++random unsigned-long-long-int

8

Hier eine tragbare Lösung, die C99 gibt eine zufällige 64-bit-Zahl:
```
unsigned long long llrand() {
    unsigned long long r = 0;

    for (int i = 0; i < 5; ++i) {
        r = (r << 15) | (rand() & 0x7FFF);
    }

    return r & 0xFFFFFFFFFFFFFFFFULL;
}
```
Erklärung: rand() gibt ganze zahlen im Bereich von 0 bis RAND_MAX und RAND_MAX ist nur garantiert werden, zumindest als 32.767 (15 zufällige bits). long long wird garantiert, um 64 bit, aber möglicherweise größer.
- Wirklich müde von diesem. Es mag zwar sinnvoll erscheinen, aber die zahlen, die es produziert, darf nicht (eher wohl nicht) passieren viele statistische tests auf Zufälligkeit.
- Schön, aber können Sie erklären, warum r & 0xFFFFFFFFFFFFFFFFULL;?, es scheint ein NOOP
- Wie gesagt, long long könnte größer sein als 64 bits sein. Wenn es 64 bit ist, sollte der compiler machen es einem noop.
- Wooow, ok, jetzt verstehe ich, danke
- in den meisten modernen Compilern RAND_MAX == INT_MAX mit 32-bit int, also nur return rand() << 32 | rand(); ist genug
- Auch wenn RAND_MAX == INT_MAX, würde dies nicht funktionieren, da rand() gibt nur 31 zufälligen bits.
- Ich vergaß, dass es nicht wieder einen negativen Wert. Aber selbst in diesem Fall brauchen Sie nur 3 rand fordert, nicht 5
- MSVC (die einen vernünftigen Marktanteil) hat #define RAND_MAX 0x7fff
- können Sie uns ein Zitat oder ein Beispiel für einen test, würde scheitern auf (die rand() selbst übergeben würde)
- Fragen Sie sich, wenn alle möglichen unsigned long long Anzahl erzeugt werden können llrand und ob einige numebrs sind mehr oder weniger wahrscheinlich. Davon ausgehen, dass rand() & 0x7FFF ist gleichmäßig verteilt, die für die Zwecke dieses experiment.
- Sie können testen Sie es mit einer suite wie dieharder. Ich Wette, es werden nicht mehrere tests.
- Noch nicht zu sehen, Problem; vorausgesetzt, rand() ist gleichmäßig verteilt, nicht zu sehen, jede Zahl, die nicht generiert werden, oder alle, die hervorgebracht werden mehr oder weniger oft. Mit dieser sagte, diese lief gegen dieharder 3.31.1; es gab zwei "gute" tests, kam wieder schwach [keine Fehler] (im Gegensatz zu nur mit der Ausgabe von rand(), die hatte viele Ausfälle, vermutlich aufgrund von rand() nicht wieder 32 bits der Zufälligkeit, oder mit uchar x = rand() % 256, und die Ausgabe von 8 bit zu einer Zeit, nur 1 vermuten, test kam zurück, schwach (rest)übergeben
- für die Aufzeichnung, die zwei, die kam zurück schwach waren ein rgb_lagged_sum für ntuple=28 und einer der sts_serials für ntuple=8. Dies war mit ein srand(1) auf einem 64bit Linux-Kiste.
- Ack, im Interesse der nicht verstopfen diese Antwort mehr, die dies geschrieben als Folgen auf Frage: stackoverflow.com/questions/29366721/... Beachten Sie, dass, wenn ich wieder lief die tests, die 8 bit für bit version kam zurück mit einer Schwäche, nicht sicher, ob ich verpasst, dass Letzte mal ist, oder wenn sich etwas geändert hat zwischen den Läufen, die ich bin fehlt
InformationsquelleAutor nwellnhof
16

Können Sie ganz einfach tun dies mit std::uniform_int_distribution<unsigned long long>.

Einfaches Beispiel-code (aus hier, so modifiziert, dass unsigned long long):
```
#include <random>
#include <iostream>

int main()
{
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<unsigned long long> dis(lowerBorder, upperBorder);

    for (int n=0; n<10; ++n)
        std::cout << dis(gen) << ' ';
    std::cout << '\n';
}
```
Beachten Sie, dass das seeding des mersenne twister als hier für demo-Zwecke ist nicht perfekt, zum Beispiel hier.
- Das sollte eine richtige Antwort. Auch, es erfordert C++11-Unterstützung.
- Ich denke, Sie sollten die Verwendung von std::mt19937_64 für eine bessere Zufälligkeit.
- Nein, das wird nicht verbessern Zufall. Sie können versuchen, wenn es verbessert die Geschwindigkeit Ihrer Umgebung, das könnte möglicherweise funktionieren.
InformationsquelleAutor Baum mit Augen

Wenn Sie wollen, zu produzieren, unsigned long long Rückgabewert von rand() und kümmern sich nicht um die Merkmale der Ergebnis betrachten Sie die folgende Funktion werden müssen compiler-version und Plattform-unabhängig (da keine "magic numbers" verwendet werden):

//this header has RAND_MAX value
#include <stdlib.h>  
//and this header has ULLONG_MAX
#include <limits.h>

unsigned long long ullrand()
//Produces pseudo-random numbers from 0 to ULLONG_MAX
//by filling all bits of unsigned long long integer number
//with bits of several "small" integer numbers generated by rand()
{
    unsigned long long myrndnum = 0; //at the beginning just zero
    unsigned long long counter = ULLONG_MAX; //at the beginning we have all bits set as 1
    //... and while at least one bit is still set to 1
    while(counter > 0) {
           myrndnum = (myrndnum * (RAND_MAX + 1)) + rand(); //fill some bits from rand()
           counter /= (RAND_MAX + 1); //decrease number of 1-bits in counter
        }
    //Return the result
    return myrndnum;
}

Aber wenn Sie möchten, eine Sequenz von Zufallszahlen mit bestimmten Eigenschaften, sollten Sie sich in bestimmten Führern oder mathematische Bücher. E. g. https://www.gnu.org/software/gsl/manual/html_node/Random-number-generator-algorithms.html

InformationsquelleAutor VolAnd

0

Du nicht Fragen, für eine bestimmte OS und die Antworten hier sind wirklich gut, aber unter Linux (und wahrscheinlich auch auf anderen Betriebssystemen auch) kann man auch Lesen aus einer random-Gerät.

Beispiel:
```
#include <stdio.h>
#include <assert.h>

#define RANDDEV "/dev/urandom"

unsigned long long bigrand(void) {
    FILE *rdp;
    unsigned long long num;

    rdp = fopen(RANDDEV, "rb");
    assert(rdp);

    assert(fread(&num, sizeof(num), 1, rdp) == 1);

    fclose(rdp);

    return num;
}
```
Geschrieben auf mobile, können Fehler. 😛
- Vielleicht solltest du deaktivieren Sie die Pufferung, oder die Verwendung von read(), um zu vermeiden, dass zufällige bytes?
InformationsquelleAutor Bora M. Alper

Können Sie auch die boost-library (entnommen aus link):

#include <ctime>            //std::time
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/linear_congruential.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/generator_iterator.hpp>


int main()
{
    long long my_min = 1;
    long long my_max = 1e5;

    boost::mt19937 generator(static_cast<unsigned int>(std::time(0)));
    boost::variate_generator<boost::mt19937&, boost::uniform_real<> >
        die_gen(generator, boost::uniform_real<> (my_min, my_max));

    boost::generator_iterator<boost::variate_generator<boost::mt19937&, boost::uniform_real<> > > die(&die_gen);

    std::cout<<"Generated random numbers: \n";
    for (int i=0; i <10 ; i++)
    {
        std::cout<< static_cast<long long>(*die++) << std::endl;
    }

    return 0;
}

InformationsquelleAutor Sep

-1

versuchen Sie dies:
```
long N=1000000;
long randNumber;
for(long i=0;i<N;i++)
randNumber=i+rand()
```
- Während dieser code kann die Frage beantworten, wäre es besser, einige Kontext erklärt wie funktioniert es, und wenn zu verwenden. Code-nur die Antworten sind nicht nützlich im langen Lauf.
- Dies ist eine schreckliche Methode, um Zufallszahlen zu generieren. Es ist langsam, schlecht verteilt, und bewirkt Undefiniertes Verhalten aufgrund unterzeichnet überlauf.
InformationsquelleAutor HuaLiu01

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.