ENIB LANG-C Ex_0901 - Opérations bit-à-bit

Avant d'aborder cet exercice, veuillez étudier avec attention le chapitre 09_BitWise.

Connaissances requises pour cet exercice

ce calcul appliqué aux trois valeurs 5, 3 et 14 donne le résultat 7,
ce calcul appliqué aux trois valeurs 15, 204 et 170 donne le résultat 142.

1 et 2147483648 ont des motifs de bits symétriques,
2 et 1073741824 ont des motifs de bits symétriques,
256 et 8388608 ont des motifs de bits symétriques,
257 et 2155872256 ont des motifs de bits symétriques,
258 et 1082130432 ont des motifs de bits symétriques...

relever l'état du bit 31✍
En supposant que nous les numérotons de 0 (poids faible) à 31 (poids fort).
,
réaliser le décalage,
forcer l'état du bit 0 selon l'état relevé précédemment.

cette rotation appliquée à 2147483648 donne 1,
cette rotation appliquée à 1073741824 donne 2147483648,
cette rotation appliquée à 2155872256 donne 16777217,
cette rotation appliquée à 1082130432 donne 2164260864...

relever l'état du bit 0✍
En supposant que nous les numérotons de 0 (poids faible) à 31 (poids fort).
,
réaliser le décalage,
forcer l'état du bit 31 selon l'état relevé précédemment.

cette rotation appliquée à 1 donne 2147483648,
cette rotation appliquée à 2147483648 donne 1073741824,
cette rotation appliquée à 16777217 donne 2155872256,
cette rotation appliquée à 2164260864 donne 1082130432...

Les règles de mise en œuvre et d'écriture recommandées dans toutes nos réalisations doivent impérativement être respectées.
(#ifndef..., fichiers d'en-tête, programmation modulaire...)
Seule la fonction de test produit des affichages (la fonctionnalité testée rend son service silencieusement) ; un examen attentif des affichages produits doit permettre de vérifier le bon fonctionnement de la fonctionnalité testée.
L'utilisation des opérations bit-à-bit conventionnelles constitue l'essentiel de l'exercice ; il n'est pas question de recourir à une formulation alternative qui produirait malgré tout un résultat équivalent.

Lors d'une épreuve, au moment de livrer le travail, il sera impératif de s'assurer du fait que la fabrication du programme exécutable se produit sans le moindre message d'erreur ni d'avertissement✍
Que ce soit dans le cadre de cet enseignement ou dans un contexte professionnel, toute livraison de code qui ne respecte pas ce critère n'est tout simplement pas recevable.
.

Code source résultant

Si vous suivez scrupuleusement les énoncés et les consignes, vous devez obtenir des fichiers de code source semblables à ceux-ci :

Fichier bitwise.h✎

Fichier bitwise.c✎

Fichier prog_ex0901.c✎

Contenu du fichier prog_ex0901.c

//----------------------------------------------------------------------------

#include "bitwise.h"

#include <stdio.h>

void
test_bitVote(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const uint32_t word1=5, word2=3, word3=14;
  printf("vote of %u, %u and %u gives %u\n",
         word1, word2, word3, bitVote(word1, word2, word3));
  const uint32_t word4=15, word5=204, word6=170;
  printf("vote of %u, %u and %u gives %u\n",
         word4, word5, word6, bitVote(word4, word5, word6));
}

void
test_bitMirror(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const uint32_t words[]={(1u<<0),
                          (1u<<1),
                          (1u<<8),
                          (1u<<8)|(1u<<0),
                          (1u<<8)|(1u<<1),
                          (1u<<31),
                          (1u<<30),
                          (1u<<23),
                          (1u<<23)|(1u<<31),
                          (1u<<23)|(1u<<30)};
  const int count=(int)(sizeof(words)/sizeof(words[0]));
  for(int i=0; i<count; ++i)
  {
    const uint32_t word=words[i];
    printf("mirror of %u gives %u\n", word, bitMirror(word));
  }
}

void
test_rotateLeft(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const uint32_t words[]={(1u<<0),
                          (1u<<1),
                          (1u<<8),
                          (1u<<8)|(1u<<0),
                          (1u<<8)|(1u<<1),
                          (1u<<31),
                          (1u<<30),
                          (1u<<23),
                          (1u<<23)|(1u<<31),
                          (1u<<23)|(1u<<30)};
  const int count=(int)(sizeof(words)/sizeof(words[0]));
  for(int i=0; i<count; ++i)
  {
    const uint32_t word=words[i];
    printf("left rotation of %u gives %u\n", word, rotateLeft(word));
  }
}

void
test_rotateRight(void)
{
  printf("\n~~~~ %s() ~~~~\n", __func__);
  const uint32_t words[]={(1u<<0),
                          (1u<<1),
                          (1u<<8),
                          (1u<<8)|(1u<<0),
                          (1u<<8)|(1u<<1),
                          (1u<<31),
                          (1u<<30),
                          (1u<<23),
                          (1u<<23)|(1u<<31),
                          (1u<<23)|(1u<<30)};
  const int count=(int)(sizeof(words)/sizeof(words[0]));
  for(int i=0; i<count; ++i)
  {
    const uint32_t word=words[i];
    printf("right rotation of %u gives %u\n", word, rotateRight(word));
  }
}

int
main(void)
{
  test_bitVote();
  test_bitMirror();
  test_rotateLeft();
  test_rotateRight();
  return 0;
}

//----------------------------------------------------------------------------