On souhaite écrire une application de manipulation interne des bits d'une variable entière non signée sur 8 bits. Le but de l'exercice est de construire une famille de méthodes de travail sur un ou plusieurs bits d'une mémoire. L'application à construire contiendra 9 méthodes :
Spécifications des méthodes :
- Une méthode BitSET permettant de mettre à 1 un bit de rang fixé.
- Une méthode BitCLR permettant de mettre à 0 un bit de rang fixé.
- Une méthode BitCHG permettant de remplacer un bit de rang fixé par son complément.
- Une méthode SetValBit permettant de modifier un bit de rang fixé.
- Une méthode DecalageD permettant de décaler les bits d'un entier, sur la droite de n positions (introduction de n zéros à gauche).
- Une méthode DecalageG permettant de décaler les bits d'un entier, sur la gauche de n positions (introduction de n zéros à droite).
- Une méthode BitRang renvoyant le bit de rang fixé d'un entier.
- Une méthode ROL permettant de décaler avec rotation, les bits d'un entier, sur la droite de n positions (réintroduction à gauche).
- Une méthode ROR permettant de décaler avec rotation, les bits d'un entier, sur la gauche de n positions (réintroduction à droite).
Exemples de résultats attendus :
Prenons une variable X entier (par exemple sur 8 bits) X = 11100010
1. BitSET (X,3) = X = 11101010
2. BitCLR (X,6) = X = 10100010
3. BitCHG (X,3) = X = 11101010
4. SetValBit(X,3,1) = X = 11101010
5. DecalageD (X,3) = X = 00011100
6. DecalageG (X,3) = X = 00010000
7. BitRang (X,3) = 0 ; BitRang (X,6) = 1 ... 8. ROL (X,3) = X = 00010111
9. ROR (X,3) = X = 01011100
using System; namespace CsExosAlgo1
{
class Application8Bits
{
// Int32.MAX_VALUE : 32 bit = 2147483647
// Int64.MAX_VALUE : 64 bits = 9223372036854775808
static void Main(string[] args){ int n,p,q,r,t;
n =9;// 000...1001
System.Console.WriteLine("n=9 : n="+toBinaryString(n));
p = BitCLR(n,3);// p=1
System.Console.WriteLine("BitCLR(n,3) ="+toBinaryString(p));
q = BitSET(n,2);// q=13 System.Console.WriteLine("BitSET(n,2) ="+toBinaryString(q));
r = BitCHG(n,3);// r=1
System.Console.WriteLine("BitCHG(n,3) ="+toBinaryString(r));
t = BitCHG(n,2);// t=13 System.Console.WriteLine("BitCHG(n,2) ="+toBinaryString(t));
System.Console.WriteLine("p = "+p+", q = "+q+", r = "+r+", t = "+t);
n =-2147483648;//1000. 00 entier minimal
System.Console.WriteLine("n=-2^31 : n="+toBinaryString(n)); p=ROL(n,3);// 000 000100 = p=4
System.Console.WriteLine("p = "+p);
n =-2147483648+1;//1000. 01 entier minimal+1
System.Console.WriteLine("n=-2^31+1 : n="+toBinaryString(n)); p=ROL(n,3);// 000 0001100 = p=12
System.Console.WriteLine("p = "+p); n =3;//0000. 0 11
System.Console.WriteLine("n=3 : n="+toBinaryString(n)); p=ROR(n,1);//100000...001 = p=-2147483647
System.Console.WriteLine("ROR(n,1) = "+p+"= "+toBinaryString(p)); p=ROR(n,2);// 11000...000 = p= -1073741824
System.Console.WriteLine("ROR(n,2) = "+p+"= "+toBinaryString(p)); p=ROR(n,3);// 011000 000 = p= +1610612736 =2^30+2^29
System.Console.WriteLine("ROR(n,3) = "+p+"= "+toBinaryString(p));
}
static string toBinaryString ( int n )
{ // renvoie l'écriture de l'entier n en représentation binaire
string [ ] hexa = { "0000","0001","0010","0011","0100",
"0101","0110","0111","1000","1001","1010",
"1011","1100","1101","1110","1111" };
string s = string.Format("{0:x}",n), res = "";
for ( int i = 0; i < s.Length; i++ )
{ char car=(char)s[i];
if ((car <= '9')&&(car >= '0'))
res = res+hexa[(int)car-(int)'0'];
if ((car <= 'f')&&(car >= 'a'))
res = res+hexa[(int)car-(int)'a'+10];
}
return res;
}
static int BitSET(int nbr, int num)
{ // positionne à 1 le bit de rang num
int mask;
mask =1<< num; return nbr | mask;
}
static int BitCLR(int nbr, int num)
{ // positionne à 0 le bit de rang num
int mask;
mask = ~ (1<< num); return nbr & mask;
}
static int BitCHG(int nbr, int num)
{ // complémente le bit de rang num (0 si bit=1, 1 si bit=0)
int mask;
mask =1<< num; return nbr ^ mask;
}
static int DecalageD (int nbr, int n)
{ // décalage sans le signe de n bits vers la droite
return nbr >> n ;
}
static int DecalageG (int nbr, int n)
{ // décalage de 2 bits vers la gauche
return nbr << n ;
}
static int BitRang (int nbr, int rang)
{ //renvoie le bit de rang fixé
return(nbr >> rang ) %2;
}
static int SetValBit (int nbr, int rang,int val)
{ //positionne à val le bit de rang fixé
return val ==0 ? BitCLR( nbr , rang) : BitSET( nbr , rang) ;
}
static int ROL (int nbr, int n)
{ //décalage à gauche avec rotation
int C;
int N = nbr;
for(int i=1; i<=n; i++)
{
C = BitRang(N,31); N = N <<1;
N = SetValBit(N,0,C);
}
return N ;
}
static int ROR (int nbr,int n)
{ //décalage à droite avec rotation
int C;
int N = nbr;
for(int i=1; i<=n; i++)
{
C = BitRang (N,0);
N = N >> 1;
N = SetValBit (N,31,C);
}
return N ;
}
} //--Application8Bits
}
Ajouter un commentaire
Veuillez vous connecter pour ajouter un commentaire.
Pas encore de commentaires.