PRNG pour générer des nombres avec n bits définis exactement

J'écris actuellement du code pour générer des données binaires. J'ai spécifiquement besoin de générer des nombres 64 bits avec un nombre donné de bits définis; plus précisément, la procédure devrait prendre quelque $0 < n < 64$ et retourner un nombre pseudo-aléatoire de 64 bits avec exactement $n$ bits définis sur $1$ , et le reste réglé sur 0.

Mon approche actuelle implique quelque chose comme ceci:

1. Générez un nombre pseudo-aléatoire de 64 bits $k$ .
2. Comptez les bits en $k$ , en stockant le résultat en $b$ .
3. Si $b = n$ , sortie $k$ ; sinon, passez à 1.

Cela fonctionne, mais cela semble inélégant. Existe-t-il une sorte d'algorithme PRNG qui peut générer des nombres avec $n$ bits définis plus élégamment que cela?

Ce dont vous avez besoin est un nombre aléatoire compris entre 0 et . Le problème est alors de transformer cela en motif binaire.${ 64 \choose n } - 1$

C'est ce que l'on appelle le codage énumératif, et c'est l'un des plus anciens algorithmes de compression déployés. L'algorithme le plus simple est probablement celui de Thomas Cover. Il est basé sur la simple observation que si vous avez un mot de bits, où les bits définis sont dans l'ordre de bits le plus significatif, puis la position de ce mot dans l'ordre lexicographique de tous les mots avec cette propriété est:x k … x $n$$x_k \ldots x_1$

Ainsi, par exemple, pour un mot de 7 bits:

i(0001011)= (

...etc.

Pour obtenir le modèle de bits de l'ordinal, il vous suffit de décoder chaque bit à son tour. Quelque chose comme ça, dans un langage de type 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;
}

Notez que comme vous n'avez besoin que de coefficients binomiaux jusqu'à 64, vous pouvez les précalculer.

• Cover, T., Enumerative Source Encoding . Transactions de l'IEEE sur la théorie de l'information, vol IT-19, no 1, janvier 1973.

Très similaire à la réponse du pseudonyme, obtenue par d'autres moyens.

Le nombre total de combinaisons disponibles est accessible par la méthode des étoiles et des barres , il devra donc être . Le nombre total de nombres 64 bits à partir duquel vous tenteriez d'échantillonner votre numéro serait évidemment beaucoup plus élevé que cela.$c=\binom{64}{n}$

Il vous faut alors une fonction qui peut vous conduire d'un nombre pseudo-aléatoire , allant de à , à la combinaison 64 bits correspondante.$k$$1$$c$

Le triangle de Pascal peut vous aider, car la valeur de chaque nœud représente exactement le nombre de chemins de ce nœud à la racine du triangle, et chaque chemin peut être fait pour représenter l'une des chaînes que vous recherchez, si tous les virages à gauche sont étiqueté avec un , et chaque tour à droite avec un .$1$$0$

Soit donc le nombre de bits restant à déterminer et le nombre de bits restant à utiliser.$x$$y$

Nous savons que , et nous pouvons l'utiliser pour déterminer correctement le bit suivant du nombre à chaque étape:$\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$

Une autre méthode assez élégante consiste à utiliser la bissection comme décrit dans cette réponse stackoverflow . L'idée est de garder deux mots, l'un connu pour avoir au plus k bits définis et l'autre connu pour avoir au moins k bits définis, et utiliser l'aléatoire pour déplacer l'un de ces derniers vers exactement k bits. Voici du code source pour l'illustrer:

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

J'ai fait une comparaison des performances de différentes méthodes et celle-ci est généralement la plus rapide, sauf si k est connu pour être très petit.

Vous pouvez effectuer les opérations suivantes:

1) Générez un nombre aléatoire, compris entre et .$k$$1$$64$

2) Réglez th sur .$k$$0$$1$

3) Répétez les étapes 1 et 2 fois$n$

$A[]$ est un tableau de bits avec tous les 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;
}