Mettre à 0 le 1 de poids faible

On peut aussi se demander ce que donne le calcul ${\displaystyle x.(x-1)}$ quand il est appliqué à un nombre quelconque, pas forcément à une puissance de deux. Si vous faites quelques tests, vous allez remarquer que ce calcul met toujours un bit à 0 dans le nombre initial : pas un de plus, pas un de moins. De plus, ce bit est un bit qui est initialement à 1 : il s'agit même du 1 qui est le plus à droite dans l'écriture binaire, à savoir le 1 de poids faible. C'est pour cela que ce calcul permet de vérifier si un nombre est une puissance de deux : par définition, une puissance de deux n'a qu'un seul bit à 1. Si ce bit est mis à 0, alors on obtient bien un zéro.

${\displaystyle x}$	${\displaystyle x.(x-1)}$
1111 1111	1111 1110
1111 1110	1111 1100
1111 1000	1111 0000
0010 1000	0010 0000
0010 0000	0000 0000

Pour comprendre pourquoi cela fonctionne, reprenons l'écriture binaire du nombre x. Si celui-ci est non-nul, il y aura un 1 qui sera le plus à droite de tous les autres. Celui-ci codera une puissance de deux, peu importe laquelle. Il aura un ou plusieurs zéros à sa droite, potentiellement zéro. Dit autrement, on peut décomposer ce nombre en deux parties : une partie gauche contenant les bits à gauche du 1 de poids faible et une partie droite de la forme 10000, avec un nombre de zéro variable, potentiellement nul. En clair, le nombre est de la forme XXXXX...XXXX 100000...000.

On remarque que la partie droite est une puissance de deux : sa représentation binaire est celle d'une puissance de deux. Si on soustrait 1, la partie droite sera donc un nombre de la forme ${\displaystyle 2^{n}-1}$. On obtiendra donc une partie droite de la forme 011111...11111, et donc un nombre de la forme XXXXX...XXXX 011111...11111. On remarque que ${\displaystyle x-1}$ et ${\displaystyle x}$ ont la même partie gauche. Si on fait un ET entre ces deux nombres, la partie la partie gauche sera intouchée. Par contre, ${\displaystyle x-1}$ et ${\displaystyle x}$ n'ont aucun bit en commun, ce qui fait que le ET va donner 0. Si on compare le résultat avec ${\displaystyle x}$, on remarque que le résultat est le même que le nombre ${\displaystyle x}$ de départ, sauf que le 1 de poids faible est mis à 0.

Cette opération permet de vérifier qu'un nombre est une puissance de 2. On remarque que les nombres ${\displaystyle 2^{n}}$ et ${\displaystyle 2^{n}-1}$ n’ont pas de bit à 1 en commun. Dit autrement, si on effectue un ET logique entre ces deux nombres, on obtient 0 : les 0 dans un nombre vont annuler les 1 qui sont dans l'autre. Ce qui signifie que si x est une puissance de deux, alors ${\displaystyle x.(x-1)=0}$. Et la réciproque est vraie : si ${\displaystyle x.(x-1)=0}$, alors x est une puissance de deux. Attention toutefois : avec cette technique, zéro est considéré comme une puissance de deux. Faites donc attention.

Mettre à 0 les 1 de poids faible

Le code précédent peut s'adapter afin de mettre à 0 non pas le 1 de poids faible, mais tous les 1 de poids faibles consécutifs s'ils sont plusieurs. Par exemple, pour le nombre 0101011111, on peut vouloir mettre à 0 les 5 1 de poids faible. Pour cela, il faut utiliser la formule suivante :

${\displaystyle x.(x+1)}$

Mettre à 1 le 0 de poids faible

On peut aussi vouloir inverser non pas le 1 de poids faible, mais le 0 de poids faible, le mettre à 1. Pour cela, il faut utiliser la formule suivante :

${\displaystyle x|(x+1)}$

Mettre à 1 le ou les 0 de poids faible

On peut maintenant se demander ce qui se passe quand on effectue non pas un ET, mais un OU entre ${\displaystyle x}$ et ${\displaystyle x-1}$. Dans ce cas, on remarque que les 0 de poids faibles sont mis à 1. Précisément, si on prend un nombre de la forme XXXXX...XXXX 100000...000, celui-ci devient de la forme XXXXX...XXXX 11111...1111. En clair, tous les bits qui se situe à droite du 1 de poids faible sont mis à 1. Par exemple, le nombre 0110 1010 0011 1000 deviendra 0110 1010 0011 1111. Pour résumer, voici la formule adéquate :

${\displaystyle x|(x-1)}$

Il faut signaler que cette formule ne modifie pas les bits qui ne sont les 0 de poids faible. Mais il est possible d'isoler ceux-ci et de mettre tout autre bit à 0. Par exemple, le nombre 0110 1100 1111 0000 deviendra : 0000 0000 0000 1111. Ou encore, le nombre 0101 1000 deviendra 0000 0111. Pour cela, diverses formules peuvent être utilisées. Les voici :

• ${\displaystyle {\overline {x}}.(x-1)}$ ;
• ${\displaystyle {\overline {x+(-x)}}}$ ;
• ${\displaystyle (x.-x)-1}$.

Isoler le 1 de poids faible

Isoler le 1 de poids faible signifie mettre à 0 tous les autres bits du nombre. Seul le 1 de poids faible restera à 1, les autres bits étant effacés. Cette opération est très simple : il s'agit d'un simple ET entre ${\displaystyle x}$ et ${\displaystyle -x}$ :

${\displaystyle x.(-x)}$.

Le logarithme binaire

Maintenant, nous allons voir comment déterminer la position du 1 le plus significatif dans l'écriture binaire du nombre. En clair, la position du 1 le plus à gauche. Mine de rien, ce calcul a une interprétation arithmétique : il s'agit du logarithme en base 2 d'un entier non-signé. Dans tout ce qui va suivre, nous allons numéroter les bits à partir de zéro : le bit le plus à droite d'un nombre (son bit de poids faible) sera le 0-ème bit, le suivant le 1er bit, et ainsi de suite.

Nous allons commencer par voir un cas simple : le cas où notre nombre vaut ${\displaystyle 2^{n}}$. Dans ce cas, un seul bit est à 1 dans notre nombre : le n-ième bit. On peut en faire une démonstration par récurrence. Déjà, on remarque que la propriété est vraie pour ${\displaystyle 2^{0}}$ : le 0-ème bit du nombre est mis à 1. Supposons maintenant que cette propriété soit vraie pour ${\displaystyle n}$ et regardons ce qui se passe pour ${\displaystyle n+1}$. Dans ce cas, ${\displaystyle 2^{n+1}=2\times 2^{n}=2^{n}<<1}$. Donc, le bit suivant sera à un si on augmente l'exposant d'une unité : la propriété est respectée !

Maintenant, qu'en est-il pour n'importe quel nombre ${\displaystyle x}$, et pas seulement les puissances de deux ? Prenons n'importe quel nombre, écrit en binaire. Si celui-ci n'est pas une puissance de deux, alors il est compris entre deux puissances de deux : ${\displaystyle 2^{n}\leq x<2^{n+1}}$. En prenant le logarithme de l'inégalité précédente, on a : ${\displaystyle \log _{2}{2^{n}}\leq \log _{2}{x}<\log _{2}{2^{n+1}}}$. Par définition du logarithme en base 2, on a : ${\displaystyle n\leq \log _{2}{x}<n+1}$. Dit autrement, le logarithme en base 2 d'un nombre est égal à ${\displaystyle n}$, qui est la position de son 1 de poids fort, celui le plus à droite. Plus précisément, il s'agit de la partie entière du logarithme.

int log_2 (int a)
{
    unsigned int r = 0;
    while (a >>= 1)
    {
        r++;
    }
    return r ;
}

int log_2 (int x)
{
    unsigned log = 0 ;

    if (x > 0xFFFFFFFF)
    {
        log += 32 ;
        x = x >> 32 ;
    }
    if (x > 0xFFFF)
    {
        log += 16 ;
        x = x >> 16 ;
    }
    if (x > 0xFF)
    {
        log += 8 ;
        x = x >> 8 ;
    }
    if (x > 0xF)
    {
        log += 4 ;
        x = x >> 4 ;
    }
    if (x > 3)
    {
        log += 1 ;
        x = x >> 2 ;
    }
    log = x >> 1 ;

    return log ;
}

int log_2 (int a)
{
    int n = NextPowerOf2 (a) ;
    return HammingWeight(n) ;
}

Count Leading Zeros

Dans un ordinateur, les nombres sont de taille fixe. Un nombre est ainsi stocké sur 8, 16, 32, 64 bits. Si jamais un nombre peut être représenté en utilisant moins de bits que prévu, les bits qui restent sont mis à zéro. Par exemple, sur une architecture 8 bits, le nombre 5 ne sera pas stocké comme ceci : 101, mais comme ceci : 00000101. On voit donc que ce nombre contient un certain nombre de zéros non-significatifs. Ces zéros sont placés à gauche du nombre. Plus précisément, notre nombre aura certains de ses bits à 1. Parmi ceux-ci, il y aura un de ces bits qui sera plus à gauche que tous les autres 1. A gauche de ce 1, on peut éventuellement trouver un certain nombre de zéros non-significatifs. L'instruction Count leading zeros a pour objectif de compter ces zéros non-significatifs. Pour un nombre de N bits, le nombre de ces zéros à gauche peut varier entre 0 et N. Si on a 0 zéros non-significatif, dans ce cas, le bit de plus à gauche est un 1. Si jamais on a N de ces zéros, c'est que tous les bits du nombre sont à zéro. En matériel, cette opération est souvent utilisée dans certaines unités de calcul à virgule flottante, dans les opérations de normalisation et d'arrondis du résultat. Néanmoins, il faut préciser que seules les unités de calcul à faible performance ont besoin de déterminer le nombre de zéros les plus à gauche.

On peut calculer ce nombre de zéros à gauche simplement à partir de l'indice du 1 de poids fort, en utilisant l'équation ${\displaystyle \log _{2}{(n)}+clz(n)=n-1}$. On a vu plus haut comment trouver l'indice de ce 1 le plus à gauche. Le nombre de 0 à gauche est simplement égal au nombre de bits de notre nombre, auquel on soustrait la position de ce 1 : ${\displaystyle clz(n)=n-\log _{2}{(n)}-1}$.

Une autre méthode consiste à réutiliser le code qui calcule la puissance de 2 immédiatement supérieure. Pour rappel, la première étape de cet algorithme consiste à remplir les bits à droite du 1 de poids fort par des 1, avec des décalages successifs. Les seuls bits à rester à 0 sont les 0 de poids forts, qu'on souhaite compter. Une fois qu'on a appliqué l'algorithme, on n'a plus qu'à effectuer un calcul de population count et de soustraire le résultat de ${\displaystyle n}$.

unsigned NextPowerOf2 (unsigned n)
{
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    x = population_count( n ) ;

    return WORDBITS - x ;
}

Une autre solution consiste à effectuer la première étape, à inverser les bits et à calculer la population count. L'inversion des bits garanti que seuls les 0 de poids forts seront à 1, d'où le fait que la population count donne le bon résultat.

unsigned NextPowerOf2 (unsigned n)
{
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;

    return population_count( ! n ) ;
}

Find First Set

Passons maintenant à l'opération Find First Set, qui donne la position du 1 de poids faible. On a vu plus haut que l'on peut isoler ce bit, faire en sorte de mettre tous les autres bits à 0 : il faut utiliser le calcul ${\displaystyle x.(-x)}$. Une fois ce bit isolé, on peut trouver sa position en calculant son logarithme binaire. On a donc :

unsigned ffs (unsigned n)
{
    return log_2( x & -x ) ;
}