PRNG per generare esattamente numeri con n bit impostati

Attualmente sto scrivendo del codice per generare dati binari. Ho specificamente bisogno di generare numeri a 64 bit con un dato numero di bit impostati; più precisamente, la procedura dovrebbe richiedere alcuni $0 < n < 64$ e restituire un numero pseudo-casuale a 64 bit con esattamente $n$ bit impostati su $1$ e il resto impostato su 0.

Il mio approccio attuale prevede qualcosa del genere:

1. Genera un numero pseudocasuale di 64 bit $k$ .
2. Contare i bit in $k$ , memorizzando il risultato in $b$ .
3. Se $b = n$ , output $k$ ; altrimenti vai a 1.

Funziona, ma sembra non elegante. Esiste un qualche tipo di algoritmo PRNG che può generare numeri con $n$ bit impostati in modo più elegante di questo?

Ciò di cui hai bisogno è un numero casuale compreso tra 0 e . Il problema è quindi quello di trasformarlo nel modello di bit.${ 64 \choose n } - 1$

Questo è noto come codifica enumerativa ed è uno dei più antichi algoritmi di compressione distribuiti. Probabilmente l'algoritmo più semplice è di Thomas Cover. Si basa sulla semplice osservazione che se si dispone di una parola lunga bit, in cui i bit impostati sono nell'ordine dei bit più significativo, la posizione di questa parola nell'ordinamento lessicografico di tutte le parole con questa proprietà è:x k … x $n$$x_k \ldots x_1$

Quindi, ad esempio, per una parola a 7 bit:

i(0001011)= (

...e così via.

Per ottenere il modello di bit dall'ordinale, basta decodificare ogni bit a turno. Qualcosa del genere, in un linguaggio di tipo C:

uint64_t decode(uint64_t ones, uint64_t ordinal)
{
    uint64_t bits = 0;
    for (uint64_t bit = 63; ones > 0; --bit)
    {
        uint64_t nCk = choose(bit, ones);
        if (ordinal >= nCk)
        {
            ordinal -= nCk;
            bits |= 1 << bit;
            --ones;
        }
    }
    return bits;
}

Si noti che poiché sono necessari solo coefficienti binomiali fino a 64, è possibile pre-calcolarli.

• Cover, T., Codifica della fonte enumerativa . Transazioni IEEE sulla teoria dell'informazione, vol IT-19, n. 1, gennaio 1973.

Molto simile alla risposta dello pseudonimo, ottenuta con altri mezzi.

Il numero totale di combinazioni disponibili è accessibile con il metodo stelle e barre , quindi dovrà essere . Il numero totale di numeri a 64 bit da cui proveresti a campionare il tuo numero sarebbe ovviamente molto più alto di quello.$c=\binom{64}{n}$

Ciò di cui hai bisogno allora è una funzione che può portarti da un numero pseudocasuale , che va da a , alla corrispondente combinazione a 64 bit.$k$$1$$c$

Il triangolo di Pascal può aiutarti in questo, perché il valore di ogni nodo rappresenta esattamente il numero di percorsi da quel nodo alla radice del triangolo e ogni percorso può essere fatto per rappresentare una delle stringhe che stai cercando, se tutte le curve a sinistra sono etichettato con un e ogni giro a destra con uno .$1$$0$

Quindi lascia che sia il numero di bit rimasti da determinare e sia il numero di bit rimasti da usare.$x$$y$

Sappiamo che e possiamo usarlo per determinare correttamente il prossimo bit del numero ad ogni passo:$\binom{x}{y}=\binom{x-1}{y}+\binom{x-1}{y-1}$

$\mathtt{while}\;\;\; x>0$

$\quad \mathtt{if}\;\;\; x>y$

$\qquad \mathtt{if}\;\;\;k>\binom{x-1}{y}: \;\;\;s \leftarrow s\; + \mathtt{"1"}, \;k\leftarrow k-\binom{x-1}{y}, \;y \leftarrow y-1$

$\qquad \mathtt{else}:\; \;s \leftarrow s\; + \mathtt{"0"}$

$\quad \mathtt{else}: \;\;s \leftarrow s\; + \mathtt{"1"}, \;y \leftarrow y-1$

$\quad x \leftarrow x-1$

Un altro metodo abbastanza elegante è usare la bisection come descritto in questa risposta di StackOverflow . L'idea è di mantenere due parole, una nota per avere al massimo k bit impostati e una nota per avere almeno k bit impostati, e usare la casualità per spostare una di queste verso esattamente k bit. Ecco un po 'di codice sorgente per illustrarlo:

word randomKBits(int k) {
    word min = 0;
    word max = word(~word(0)); // all 1s
    int n = 0;
    while (n != k) {
        word x = randomWord();
        x = min | (x & max);
        n = popcount(x);
        if (n > k)
            max = x;
        else
            min = x;
    }
    return min;
}

Ho fatto un confronto delle prestazioni di vari metodi e questo è in genere il più veloce a meno che k non sia noto per essere molto piccolo.

Puoi fare quanto segue:

1) Genera un numero casuale, compreso tra e .$k$$1$$64$

2) Impostare ° al .$k$$0$$1$

3) Ripetere i passaggi 1 e 2 volte$n$

$A[]$ è un array a bit con tutti gli s$64$$0$

for(i=1 to n)
{
    k=ran(1,65-i) % random number between 1 and 65-i
    for(x=1;x<65;x++)
    {
        if(A[x]==0)k--;
        if(k==0)break;
    }
    A[x]=1;
}