Inversion de 8 bits en C

Version imprimable

14/02/2013, 15h31
MilyBass

Inversion de 8 bits en C

bonjour,

Pourriez-vous m'aider car en effet, je n'arrive pas a créer une permutation sur 8 bits de la manière suivante:

b7 b6 b5 b4 b3 b2 b1 b0 <- bits initiaux

b4 b5 b6 b7 b0 b1 b2 b3 <- ordre de bits voulu

Merci d'avance pour votre aide,

MilyBass
14/02/2013, 15h42
Obsidian

Bonjour et bienvenue,

Il n'y a pas de façon « simple » de le faire (en une seule opération), mais tu peux t'en sortir en quatre étapes avec un ET logique « & », les opérateurs de décalage « << » et « >> » et le OU logique « | ». Tu peux manipuler deux bits à chaque étape.

Est-ce un devoir scolaire ?
14/02/2013, 15h53
MilyBass

Non, c'est un test.

Je suis en alternance et sur mon projet j'avais nécessité de faire cette fonction mais mes connaissances sur les masques et le C sont limités.

Citation:

Envoyé par Obsidian

[...] Il n'y a pas de façon « simple » de le faire (en une seule opération) [...]

Challenge accepted

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int main(void)
{
  unsigned char a = 85;
 
  a = ((a & 0x01) << 3) +
      ((a & 0x02) << 1) +
      ((a & 0x04) >> 1) +
      ((a & 0x08) >> 3) +
      ((a & 0x10) << 3) +
      ((a & 0x20) << 1) +
      ((a & 0x40) >> 1) +
      ((a & 0x80) >> 3);
 
  printf ("%d\n", a);
 
  return (0);
}

:aie: patapay

14/02/2013, 16h08
Obsidian

Citation:

Envoyé par MilyBass

Non, c'est un test.

Je suis en alternance et sur mon projet j'avais nécessité de faire cette fonction mais mes connaissances sur les masques et le C sont limités.

— Le masque ET te permet de ne conserver que les bits qui sont à 1 dans les deux opérandes et par conséquent, c'est l'équivalent d'une « intersection » mathématique. « 10001000 » en binaire s'écrit 0x88 en hexadécimal. Ainsi « n & 0x88 » est une expression qui ne renvoie que les bits 7 et 4 de n (sans modifier la variable) ;
— L'opérateur de décalage permet de déplacer les bits d'un registre d'un certain nombre de positions à gauche ou à droite. Donc « n >> 1 » déplace tous les bits de n vers la droite. Attention au signe ! Si n est naturellement non signé, l'opérateur insérera un zéro par la gauche, sinon le bit de poids fort restera intact. En appliquant cet opérateur à l'expression entière ci-dessus (avec des parenthèses si nécessaire), les bits 7 et 4 se retrouvent en position 6 et 3 ;
— Le masque OU te permet ne conserver que les bits qui sont à 1 dans l'une ou l'autre des opérandes, ou les deux. Par conséquent, c'est l'équivalent d'une « union » mathématique. Tu peux t'en servir pour superposer tous les résultats de tes opérations intermédiaires.
14/02/2013, 16h14
MilyBass

Merci pour ces explications, je vais essayer de partir dans cette direction en procédant de la même manière pour tout les bits :)

Mais toutefois, un doute plane: les masques...:cry:
14/02/2013, 16h15
Obsidian
Citation:

Envoyé par SofEvans

Challenge accepted

C'est bien ce que je disais : ce n'est pas en une opération, même si le tout tient en une seule expression. Il faut extraire chaque paire de bit et les décaler individuellement (au passage, tu aurais pu utiliser moitié moins de lignes ;) )

Citation:

:aie: patapay

C'est surtout que ça ne lui rend pas vraiment service : l'objectif était de l'aider à trouver la solution seule, pas de faire son travail à sa place.

Citation:

Envoyé par MilyBass

Merci pour ces explications, je vais essayer de partir dans cette direction en procédant de la même manière pour tout les bits :)

Mais toutefois, un doute plane: les masques...:cry:

C'est plus clair avec un schéma :
001110110010 soit 0x3B2 ↓↓↓↓↓↓↓↓↓↓↓↓ & 011011011101 soit 0x6DD --------------- = 001000010000 soit 0x210
Dans cette opération ET, on compare les bits deux à deux et on ne conserve que ceux qui sont à 1 des deux côtés.

Citation:

Envoyé par Obsidian

C'est bien ce que je disais : ce n'est pas en une opération, même si le tout tient en une seule expression. Il faut extraire chaque paire de bit et les décaler individuellement (au passage, tu aurais pu utiliser moitié moins de lignes ;) )

Ah ... J'ai confondu "une seule opération" et "une seule expression".
Du coup ... je ne vois pas, dans l'état actuelle de mes connaissance, comment on pourrait faire cela en une seule opération.

Et oui, j'ai fait l'exemple a la va vite sasn reflexion, donc il y avait la place pour faire mieux :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 int main(void) { unsigned char a = 85; a = ((a & 0x11) << 3) + ((a & 0x22) << 1) + ((a & 0x44) >> 1) + ((a & 0x88) >> 3); printf ("%d\n", a); return (0); }
Citation:

Envoyé par Obsidian

C'est surtout que ça ne lui rend pas vraiment service : l'objectif était de l'aider à trouver la solution seule, pas de faire son travail à sa place.

Ben c'est vrai que j'aurai dû écrire ce que tu as écrit juste après mon message pour expliquer ce que j'ai fait, mais au final, tes explications sont très clair et l'exemple que j'ai donné (aussi mauvais soit-il) est finalement comprehensible.

14/02/2013, 16h34
Obsidian

Citation:

Envoyé par SofEvans

Ben c'est vrai que j'aurai dû écrire ce que tu as écrit juste après mon message pour expliquer ce que j'ai fait, mais au final, tes explications sont très clair et l'exemple que j'ai donné (aussi mauvais soit-il) est finalement comprehensible.

Ton exemple n'est pas « mauvais » du tout. ;) Cela dit, il aurait été presque parfait si tu avais utilisé des « | » à la place des « + ».
14/02/2013, 16h48
SofEvans

... oui, tant qu'à faire, si on fait des opération sur les bit, autant utiliser ce qu'il faut. :cry:

J'aurai dû utiliser | et non +
15/02/2013, 08h35
MilyBass

Merci beaucoup votre aide m'a été bénéfique ;)

Salut,

Bon, le PO a eu son déclic, c'est le principal. Pour simplement 8 bits, je créerais une table de conversion et à l'usage on n'utiliserait finalement qu'une opération très rapide. C'est certainement moins beau que de la manipulation de bits, mais on ne pourra pas nier que c'est plus efficace.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 #include <stdio.h> const unsigned char swapper[]= { 0x00, // 0x00 0x08, // 0x01 0x0c, // 0x02 // .../... 0xf7, // 0x00 0xff, // 0xff }; int main(void) { printf("%u\n", swapper[2]); return 0; }
Fabriquer la table n'est pas beaucoup plus dur. Pour ça, la manipulation de bits, c'est très bien. :aie: Personnellement j'utilise python pour ce genre de travail, mais en C c'est jouable aussi.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include <stdio.h> int main(void) { int value; unsigned char result; printf("const unsigned char swapper[]=\n{\n"); for(value=0;value<0x100;value++) { result = ((value & 0x11) << 3)+((value & 0x22) << 1)+((value & 0x44) >> 1)+((value & 0x88) >> 3); if(!(value %8)) printf(" "); printf("0x%02x,", result); if(value %8 == 7) printf("\n"); } printf("};\n"); return 0; }
A+

Pfeuh

Moi, ma première idée était de me contenter d'une table de 16.

Code:

1
2
3
4
5
unsigned char inverse(unsigned char v)
{
   static const unsigned char tab [] ={0,8,4,12,2,10,6,14,1,9,5,13,3,11,7,15};
   return tab[v%16]+16*tab[v/16];
}