PRNG para gerar números com n bits definidos exatamente

Atualmente, estou escrevendo algum código para gerar dados binários. Eu preciso especificamente gerar números de 64 bits com um determinado número de bits definidos; mais precisamente, o procedimento deve levar cerca de e retornar um número pseudo-aleatório de 64 bits com exatamente n bits definido como 1 e o restante definido como 0.$0 < n < 64$$n$$1$

Minha abordagem atual envolve algo como isto:

1. Gere um número pseudo-aleatório de 64 bits .$k$
2. Conte os bits em , armazenando o resultado em b .$k$$b$
3. Se , produza k ; caso contrário, vá para 1.$b = n$$k$

Isso funciona, mas parece deselegante. Existe algum tipo de algoritmo PRNG que pode gerar números com bits definidos de maneira mais elegante que isso?$n$

Você precisa de um número aleatório entre 0 e . O problema então é transformar isso no padrão de bits.${ 64 \choose n } - 1$

Isso é conhecido como codificação enumerativa e é um dos algoritmos de compactação implantados mais antigos. Provavelmente o algoritmo mais simples é de Thomas Cover. É baseado na simples observação de que se você tem uma palavra com bits de comprimento, em que os bits definidos são x k … x 1 na ordem de bits mais significativa, a posição dessa palavra na ordem lexicográfica de todas as palavras com esse propriedade é:$n$$x_k \ldots x_1$

Então, por exemplo, para uma palavra de 7 bits:

i(0001011)= (

...e assim por diante.

Para obter o padrão de bits do ordinal, basta decodificar cada bit por vez. Algo assim, em uma linguagem 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;
}

Observe que, como você só precisa de coeficientes binomiais de até 64, pode pré-calculá-los.

• Cover, T., codificação de fonte enumerativa . IEEE Transactions on Information Theory, Vol. IT-19, No 1, Jan 1973.

Muito semelhante à resposta do pseudônimo, obtida por outros meios.

O número total de combinações disponíveis é acessível pelo método de estrelas e barras , portanto, ele terá que ser . O número total de números de 64 bits dos quais você tentaria amostrar seu número seria obviamente muito maior que isso.$c=\binom{64}{n}$

O que você precisa então é de uma função que possa levar você de um número pseudoaleatório , variando de 1 a c , à combinação de 64 bits correspondente.$k$$1$$c$

O triângulo de Pascal pode ajudá-lo com isso, porque o valor de cada nó representa exatamente o número de caminhos desse nó até a raiz do triângulo, e todo caminho pode ser feito para representar uma das cadeias de caracteres que você está procurando, se todas as curvas à esquerda forem rotulado com e, a cada curva à direita, com 0 .$1$$0$

Portanto, seja o número de bits restantes para determinar e y seja o número de bits restantes a serem utilizados.$x$$y$

Sabemos que , e podemos usá-lo para determinar adequadamente o próximo bit do número em cada etapa:$\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$

Outro método bastante elegante é usar a bissecção conforme descrito nesta resposta do stackoverflow . A idéia é manter duas palavras, uma conhecida por ter no máximo k bits definidos e outra conhecida por ter pelo menos k bits definidos, e usar a aleatoriedade para mover uma delas para ter exatamente k bits. Aqui está um código-fonte para ilustrá-lo:

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;
}

Fiz uma comparação de desempenho de vários métodos e este é geralmente o mais rápido, a menos que se saiba que o k é muito pequeno.

Você pode fazer o seguinte:

1) Gere um número aleatório,$k$ entre $1$ e $64$.

2) Definir $k$ º $0$ para $1$.

3) Repita as etapas 1 e 2 $n$ vezes

$A[]$ é $64$ matriz de bits com todos $0$s

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;
}