Discussion :

[MilyBass]

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

[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 ?

[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.

[SofEvans]

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

Challenge accepted

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

patapay

[Obsidian]

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.

[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...

[Obsidian]

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 )

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.

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...

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.

[SofEvans]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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.

[Obsidian]

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 « + ».

[SofEvans]

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

J'aurai dû utiliser | et non +

[MilyBass]

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

[pfeuh]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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. Personnellement j'utilise python pour ce genre de travail, mais en C c'est jouable aussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[diogene]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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