Generazione di numeri interi casuali da un intervallo

Ho bisogno di una funzione che generi un numero intero casuale in un determinato intervallo (compresi i valori dei bordi). Non ho irragionevoli requisiti di qualità / casualità, ho quattro requisiti:

• Ho bisogno che sia veloce. Il mio progetto deve generare milioni (o talvolta anche decine di milioni) di numeri casuali e la mia attuale funzione di generatore ha dimostrato di essere un collo di bottiglia.
• Ho bisogno che sia ragionevolmente uniforme (l'uso di rand () va benissimo).
• gli intervalli min-max possono essere compresi tra <0, 1> e <-32727, 32727>.
• deve essere seminabile.

Al momento ho il seguente codice C ++:

output = min + (rand() * (int)(max - min) / RAND_MAX)

Il problema è che non è davvero uniforme - viene restituito max solo quando rand () = RAND_MAX (per Visual C ++ è 1/32727). Questo è un grosso problema per piccoli intervalli come <-1, 1>, dove l'ultimo valore non viene quasi mai restituito.

Quindi ho preso carta e penna e ho trovato la seguente formula (che si basa sul trucco di arrotondamento intero (int) (n + 0,5)):

Ma non mi dà ancora una distribuzione uniforme. Ripetizioni ripetute con 10000 campioni mi danno un rapporto di 37:50:13 per valori valori -1, 0. 1.

Potresti suggerire una formula migliore? (o anche l'intera funzione del generatore di numeri pseudo-casuali)

È una soluzione distribuita veloce, un po 'migliore della tua, ma ancora non uniformemente distribuita

output = min + (rand() % static_cast<int>(max - min + 1))

Tranne quando la dimensione dell'intervallo è una potenza di 2, questo metodo produce numeri distribuiti non uniformi di parte indipendentemente dalla qualità di rand(). Per un test completo della qualità di questo metodo, leggi questo .

La risposta C ++ più semplice (e quindi migliore) (utilizzando lo standard 2011) è

#include <random>

std::random_device rd;     // only used once to initialise (seed) engine
std::mt19937 rng(rd());    // random-number engine used (Mersenne-Twister in this case)
std::uniform_int_distribution<int> uni(min,max); // guaranteed unbiased

auto random_integer = uni(rng);

Non c'è bisogno di reinventare la ruota. Non c'è bisogno di preoccuparsi dei pregiudizi. Non c'è bisogno di preoccuparsi di usare il tempo come seme casuale.

Se il tuo compilatore supporta C ++ 0x e il suo utilizzo è un'opzione per te, <random>è probabile che la nuova intestazione standard soddisfi le tue esigenze. Ha un'alta qualità uniform_int_distributionche accetterà limiti minimi e massimi (inclusi quelli di cui hai bisogno), e puoi scegliere tra vari generatori di numeri casuali da collegare a quella distribuzione.

Ecco il codice che genera un milione di casuali intdistribuiti uniformemente in [-57, 365]. Ho usato le nuove <chrono>strutture standard per cronometrarlo mentre hai menzionato che le prestazioni sono una delle principali preoccupazioni per te.

#include <iostream>
#include <random>
#include <chrono>

int main()
{
    typedef std::chrono::high_resolution_clock Clock;
    typedef std::chrono::duration<double> sec;
    Clock::time_point t0 = Clock::now();
    const int N = 10000000;
    typedef std::minstd_rand G;
    G g;
    typedef std::uniform_int_distribution<> D;
    D d(-57, 365);
    int c = 0;
    for (int i = 0; i < N; ++i) 
        c += d(g);
    Clock::time_point t1 = Clock::now();
    std::cout << N/sec(t1-t0).count() << " random numbers per second.\n";
    return c;
}

Per me (Intel Core i5 a 2,8 GHz) questo stampa:

2.10268e + 07 numeri casuali al secondo.

Puoi eseguire il seeding del generatore passando un int al suo costruttore:

    G g(seed);

Se successivamente scopri che intnon copre l'intervallo di cui hai bisogno per la tua distribuzione, questo può essere risolto cambiando in questo uniform_int_distributionmodo (es. A long long):

    typedef std::uniform_int_distribution<long long> D;

Se in seguito scopri che minstd_randnon è un generatore di qualità abbastanza alta, può anche essere facilmente sostituito. Per esempio:

    typedef std::mt19937 G;  // Now using mersenne_twister_engine

Avere il controllo separato sul generatore di numeri casuali e la distribuzione casuale può essere abbastanza liberatorio.

Ho anche calcolato (non mostrato) i primi 4 "momenti" di questa distribuzione (usando minstd_rand) e li ho confrontati con i valori teorici nel tentativo di quantificare la qualità della distribuzione:

min = -57
max = 365
mean = 154.131
x_mean = 154
var = 14931.9
x_var = 14910.7
skew = -0.00197375
x_skew = 0
kurtosis = -1.20129
x_kurtosis = -1.20001

(Il x_prefisso si riferisce a "previsto")

Dividiamo il problema in due parti:

• Genera un numero casuale nnell'intervallo da 0 a (max-min).
• Aggiungi min a quel numero

La prima parte è ovviamente la più difficile. Supponiamo che il valore di ritorno di rand () sia perfettamente uniforme. L'uso di modulo aggiungerà distorsione ai primi (RAND_MAX + 1) % (max-min+1)numeri. Quindi se potessimo cambiare magicamente RAND_MAXin RAND_MAX - (RAND_MAX + 1) % (max-min+1), non ci sarebbe più alcun pregiudizio.

Si scopre che possiamo usare questa intuizione se siamo disposti a consentire lo pseudo-non determinismo nel tempo di esecuzione del nostro algoritmo. Ogni volta che rand () restituisce un numero troppo grande, chiediamo semplicemente un altro numero casuale fino a quando non ne otteniamo uno sufficientemente piccolo.

Il tempo di esecuzione è ora distribuito geometricamente , con valore atteso 1/pdove pè la probabilità di ottenere un numero abbastanza piccolo al primo tentativo. Poiché RAND_MAX - (RAND_MAX + 1) % (max-min+1)è sempre inferiore a (RAND_MAX + 1) / 2, lo sappiamo p > 1/2, quindi il numero previsto di iterazioni sarà sempre inferiore a due per qualsiasi intervallo. Con questa tecnica dovrebbe essere possibile generare decine di milioni di numeri casuali in meno di un secondo su una CPU standard.

MODIFICARE:

Sebbene quanto sopra sia tecnicamente corretto, la risposta di DSimon è probabilmente più utile in pratica. Non dovresti implementare queste cose da solo. Ho visto molte implementazioni del campionamento del rifiuto ed è spesso molto difficile capire se è corretto o meno.

Che ne dici del Mersenne Twister ? L'implementazione di boost è piuttosto facile da usare ed è ben testata in molte applicazioni del mondo reale. L'ho usato io stesso in diversi progetti accademici come l'intelligenza artificiale e gli algoritmi evolutivi.

Ecco il loro esempio in cui fanno una semplice funzione per tirare un dado a sei facce:

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>

boost::mt19937 gen;

int roll_die() {
    boost::uniform_int<> dist(1, 6);
    boost::variate_generator<boost::mt19937&, boost::uniform_int<> > die(gen, dist);
    return die();
}

Oh, ed ecco un po 'più di sfruttamento di questo generatore nel caso in cui non sei convinto che dovresti usarlo su quello ampiamente inferiore rand():

Il Mersenne Twister è un generatore di "numeri casuali" inventato da Makoto Matsumoto e Takuji Nishimura; il loro sito web include numerose implementazioni dell'algoritmo.

Essenzialmente, il Mersenne Twister è un registro a scorrimento a feedback lineare molto ampio. L'algoritmo opera su un seed a 19.937 bit, memorizzato in un array di 624 elementi di numeri interi senza segno a 32 bit. Il valore 2 ^ 19937-1 è un numero primo di Mersenne; la tecnica per manipolare il seme si basa su un vecchio algoritmo di "torsione", da cui il nome "Mersenne Twister".

Un aspetto interessante di Mersenne Twister è il suo uso di operazioni binarie - al contrario della moltiplicazione che richiede tempo - per generare numeri. L'algoritmo ha anche un periodo molto lungo e una buona granularità. È rapido ed efficace per applicazioni non crittografiche.

int RandU(int nMin, int nMax)
{
    return nMin + (int)((double)rand() / (RAND_MAX+1) * (nMax-nMin+1));
}

Questa è una mappatura di 32768 numeri interi su (nMax-nMin + 1) numeri interi. La mappatura sarà abbastanza buona se (nMax-nMin + 1) è piccolo (come richiesto). Si noti tuttavia che se (nMax-nMin + 1) è grande, la mappatura non funzionerà (ad esempio, non è possibile mappare i valori 32768 su 30000 valori con uguale probabilità). Se sono necessari tali intervalli, è necessario utilizzare una sorgente casuale a 32 o 64 bit, anziché i risultati rand () a 15 bit, oppure ignorare i risultati rand () che non rientrano nell'intervallo.

Ecco una versione imparziale che genera numeri in [low, high]:

int r;
do {
  r = rand();
} while (r < ((unsigned int)(RAND_MAX) + 1) % (high + 1 - low));
return r % (high + 1 - low) + low;

Se il tuo intervallo è ragionevolmente piccolo, non c'è motivo di memorizzare nella cache il lato destro del confronto nel doloop.

Raccomando la libreria Boost.Random , super dettagliata e ben documentata, che consente di specificare esplicitamente quale distribuzione si desidera e in scenari non crittografici può effettivamente superare l' implementazione tipica di una libreria C.

supponiamo che min e max siano valori int, [e] significa includere questo valore, (e) significa non includere questo valore, usando sopra per ottenere il valore giusto usando c ++ rand ()

riferimento: per () [] definisci, visita:

https://en.wikipedia.org/wiki/Interval_(mathematics)

per la funzione rand e srand o RAND_MAX definisci, visitare:

http://en.cppreference.com/w/cpp/numeric/random/rand

[minimo Massimo]

int randNum = rand() % (max - min + 1) + min

(minimo Massimo]

int randNum = rand() % (max - min) + min + 1

[minimo Massimo)

int randNum = rand() % (max - min) + min

(minimo Massimo)

int randNum = rand() % (max - min - 1) + min + 1

In questo thread è stato già discusso il campionamento del rifiuto, ma volevo suggerire un'ottimizzazione basata sul fatto che rand() % 2^somethingnon introduce alcun pregiudizio come già menzionato sopra.

L'algoritmo è davvero semplice:

• calcola la potenza minima di 2 maggiore della lunghezza dell'intervallo
• randomizza un numero in quel "nuovo" intervallo
• restituisce quel numero se è inferiore alla lunghezza dell'intervallo originale
  • respingere altrimenti

Ecco il mio codice di esempio:

int randInInterval(int min, int max) {
    int intervalLen = max - min + 1;
    //now calculate the smallest power of 2 that is >= than `intervalLen`
    int ceilingPowerOf2 = pow(2, ceil(log2(intervalLen)));

    int randomNumber = rand() % ceilingPowerOf2; //this is "as uniform as rand()"

    if (randomNumber < intervalLen)
        return min + randomNumber;      //ok!
    return randInInterval(min, max);    //reject sample and try again
} 

Questo funziona bene soprattutto per piccoli intervalli, perché la potenza di 2 sarà "più vicina" alla lunghezza dell'intervallo reale, e quindi il numero di missioni sarà minore.

PS
Ovviamente evitare la ricorsione sarebbe più efficiente (non è necessario calcolare più e più volte il massimale del tronco ..) ma ho pensato che fosse più leggibile per questo esempio.

Si noti che nella maggior parte dei suggerimenti il ​​valore casuale iniziale ottenuto dalla funzione rand (), che in genere va da 0 a RAND_MAX, viene semplicemente sprecato. Stai creando un solo numero casuale da esso, mentre esiste una solida procedura che può darti di più.

Supponiamo di voler [min, max] regione di numeri casuali interi. Partiamo da [0, max-min]

Prendi base b = max-min + 1

Inizia da rappresentare un numero ottenuto da Rand () nella base b.

In questo modo hai il floor (log (b, RAND_MAX) perché ogni cifra nella base b, tranne forse l'ultima, rappresenta un numero casuale nell'intervallo [0, max-min].

Naturalmente lo spostamento finale su [min, max] è semplice per ogni numero casuale r + min.

int n = NUM_DIGIT-1;
while(n >= 0)
{
    r[n] = res % b;
    res -= r[n];
    res /= b;
    n--;
}

Se NUM_DIGIT è il numero di cifre nella base b che è possibile estrarre e cioè

NUM_DIGIT = floor(log(b,RAND_MAX))

quindi quanto sopra è una semplice implementazione dell'estrazione di NUM_DIGIT numeri casuali da 0 a b-1 su un numero casuale RAND_MAX che fornisce b <RAND_MAX.

La formula per questo è molto semplice, quindi prova questa espressione,

 int num = (int) rand() % (max - min) + min;  
 //Where rand() returns a random number between 0.0 and 1.0

La seguente espressione dovrebbe essere imparziale se non sbaglio:

std::floor( ( max - min + 1.0 ) * rand() ) + min;

Sto assumendo qui che rand () ti dia un valore casuale nell'intervallo tra 0,0 e 1,0 NON compreso 1,0 e che max e min siano numeri interi con la condizione che min <max.