Calcul bit de parité

Version imprimable

30/09/2019, 20h24
vito27v5

Calcul bit de parité

Bonjour, à toutes et à tous

je voudrais savoir si quelqu'un connaissait un programme c# sur visual studio community 2019 avec ou sans modulo mais en priorité avec qui me permettrait de calculer la parité d'un octet car j'essaye de faire sa personnellement et je n'y arrive vraiment pas j'ai du mal avec visual studio

Le programme permet de saisir 7 valeurs binaires et à un contrôle de saisie, il doit permettre d'afficher la parité de l'octet donc soit pair soit impair et d'afficher ma valeur du 8eme bit à ajouter
Merci de votre aide par avance
02/10/2019, 11h25
phil.o

Calcul du bit de parité
Vous pouvez calculer le bit de parité sur un octet de cette manière (en assumant que le bit de parité sera celui le plus à droite dans l'octet):
Code:

1 2 3 4 5 6 7 8 byte data; int result = 0; for (int i = 0; i < 7; ++i) { result += (data >> (7 - i)) & 1; } // Le bit de parité est: int parity = result % 2;
Concrètement, ces quelques lignes font la somme des sept bits les plus significatifs d'un octet, puis renvoient le résultat modulo 2 (i.e., 0 ou 1).

Edit: il y a une seconde solution qui utilise la fonction XOR et qui permet de s'affranchir de la dernière ligne:
Code:

1 2 3 4 5 6 7 byte data; int result = 0; for (int i = 0; i < 7; ++i) { result ^= (data >> (7 - i)) & 1; } // Le bit de parité est la valeur de la variable result.
02/10/2019, 12h50
StringBuilder
Bonjour,

Pas eu le temps de vérifier que l'algo était correct, mais j'ai trouvé cette fonction C.

Au type de donnée près, le code est transposable au C#, donc à tester...

Si on peut éviter de bosser sur une boucle et tout un tas de variables et opérations, ça me semble mieux ;)

L'idée est apparemment de passer sur 4 bits en faisant un XOR des 4 bits de poids fort et ceux de poids faible
Puis on recommance pour passer sur 2 bits
Et enfin sur 1 bit... puis on n'a plus qu'à comparer avec 1 pour voir si c'est pair ou impair.
Code:

1 2 3 4 5 6 7 8 int parity(unsigned char b) { b ^= b >> 4; b ^= b >> 2; b ^= b >> 1; return b & 1; }

bonjour
Si tu es mal à l'aise avec les XOR et les Shifting de bits,l'api net t'offre un moyen plus simple de faire ce travail : le Class BitArray qui offre le moyen de manipuler les buts des type standard: byte ;int,double etc...

exemple code behind.cs :
1/ BitArray est initialise avec un tableau de byte dont l'unique élément est ton nombre ( byte data à saisir)
1/ BitArray affiche ton nombre -data--comme une suite de 0 et 1( false =>0 true => 1 dans le class BitArray )
3/ La parity est calculée et affichée ...
4/ le bit de parité est positionné au 8 ieme bit (le bit de poids fort est le plus à gauche) suivant la parité calculée ( true si parity paire,false si impaire).
5/ le "nouveau data" est restitué comme un byte avec le bit de parité grâce à la méthode d'instance Copy du BitArray

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
 
namespace WinCRC8
{
    public partial class Form3 : Form
    {
        private StringBuilder sb1 = new StringBuilder();
        public Form3()
        {
            InitializeComponent();
        }
 
         private void textBox1_Validated(object sender, EventArgs e)
        {
                byte data;
                try 
	            {
                    sb1.Clear(); 
                    data = Convert.ToByte(textBox1.Text);
                    DisplayBits(data);
                    ComputeParity(data);
 
                }
	            catch (Exception)
	            {
 
		            MessageBox.Show("o,balid byte");
                    data=0;
	            }
 
        }
        private void DisplayBits(byte data)
        {
 
            int n = 0;
            BitArray bitarray = new BitArray(new byte[1] { data });
 
            for (int i = bitarray.Length-1; i >=0; i--)
            {
                if (bitarray[i])
                {
                    n = 1;
                    sb1.Append(n.ToString());
                }
                else
                {
                    n = 0;
                    sb1.Append(n.ToString());
                }
            }
            sb1.AppendLine();
        }
 
        private void ComputeParity(byte data)
        {
            BitArray bitarray = new BitArray(new byte[1] { data });
            int result = FindParity(bitarray);
 
            string parity= result % 2 ==0 ? "Odd Parity":"Even Parity";
 
            sb1.AppendLine(parity);
 
            // sette le bit de parité à gauche
            // le bit de poids fort est le 8 ieme soit indice 7) 
            // 7 6 5 4 3 2 1 0
            if (result % 2 == 0)
                bitarray[bitarray.Length - 1] = true;
            else
                bitarray[bitarray.Length - 1] = false;
 
 
            // recupere notre "byte" 
            byte[] dataWithParity = new byte[1] ;
            bitarray.CopyTo(dataWithParity, 0);
           // et on l'affiche
            DisplayBits(dataWithParity[0]);
            textBox2.Text = sb1.ToString();
        }
        int FindParity(BitArray bitarray)
        {
            int count = 0;
            for (int i = 0; i < bitarray.Length; i++)
            {
                if (bitarray[i])
                {
                    count++;
                }
            }
            return count;
        }
 
 
 
 
    }
}

bon code....

03/10/2019, 12h39
phil.o

Calcul du bit de parité

Citation:

Envoyé par StringBuilder

Bonjour,...

Il semble qu'effectivement ce soit la solution la plus efficace.

:bravo:

Bit dans expr1	Bit dans expr2	Bit dans result
1	1	1
1	0	0
0	1	0
0	0	0

bonjour

Au lieu du class BitArray pour compter les "maudits bits" voici une version qui compte les bits de TonByte en utilisant la table AND et en Shiftant ses bits à droite(les fait défiler vers la droite):

Rappel de la table And

Bit dans expr1 Bit dans expr2 Bit dans result

1 1 1

1 0 0

0 1 0

0 0 0

la boucle de comptage tourne tant que TonByte n'est pas nul:

Step 1 on "ande" TonByte avec le nombre 1 (le teste et stocke le résultat dans la variable counte)...
Step 2 on shifte TonByte d'une position (ce qui élimine le bit testé car traité) et il est réassigné Tavec sa nouvelle valeur.
step3 aller au Step 1

A la sortie de cette boucle on aura le nombre de bit à 1 dans TonByte :soit pair soit impair...

Le class BitArray est utilisé uniquement pour afficher TonByte...
Le code exemple qui suit illustre cette méthode archi simple pour compter les bits en 2 versions pour le type Byte et le type Int32...

code behind .cs pour Int32:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
//rappel de la table And
// Bit dans expr1  Bit dans expr2 Bit dans result
// 1               1              1
// 1               0              0
// 0               1              0
// 0               0              0
 
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Collections;
 
namespace WinCRC8
{
    public partial class FormSetBitInt : Form
    {
        StringBuilder sb = new StringBuilder();
        public FormSetBitInt()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            int data;
            int count;
            string s;
            try
            {
                sb.Clear();
                data = Convert.ToInt32(textBox1.Text);
                s =  DisplayBits(data);
                sb.AppendLine("myInt :" + s);
                sb.AppendLine();
                count = CountIntBits(data);
                if (count % 2 == 0)
                    s = "odd";
                else
                    s = "even";
 
                sb.AppendLine();
                sb.AppendLine("Parity :" + s);
            }
            catch (Exception)
            {
 
                MessageBox.Show("invalid int");
                data = 0;
            }
            textBox2.Text = sb.ToString();
        }
 
        // la boucle decale à droite notre nombre de 1 position
        // simplement dit on pousse les bits vers la droite et
        // on "ande"  le plus à droite avec avec le nombre 1(binaire 00000001 pour un byte) 
        // le resulta est soit 1 soit 0 qu'on stocke dans count
        private int CountIntBits(int n)
        {
            int count = 0;
            while (n > 0)
            {
                count += n & 1;
                n = n >> 1;
            }
            return count;
        }
        private string DisplayBits(int data)
        {
            int n = 0;
            string byteString ;
            StringBuilder builder=new StringBuilder(); 
            BitArray bitarray = new BitArray(new int[1] { data });
 
            for (int i = bitarray.Length - 1; i >= 0; i--)
            {
                if (bitarray[i])
                {
                    n = 1; builder.Append(n.ToString());
                }
                else
                {
                    n = 0; builder.Append(n.ToString());
                }
            }
            builder.AppendLine();
            byteString = builder.ToString();
            return byteString;
        }
    }
}

code behind .cs pour Byte:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
namespace WinCRC8
{
    public partial class FormSetBitByte : Form
    {
        StringBuilder sb = new StringBuilder();
        public FormSetBitByte()
        {
            InitializeComponent();
        }
 
        private void button1_Click(object sender, EventArgs e)
        {
            byte data;
            int count ;
            string s;
            try
            {
                sb.Clear();
                data = Convert.ToByte(textBox1.Text);
                s=DisplayBits(data);
                sb.AppendLine("myByte :" + s);
                sb.AppendLine(); 
                count = CountByteBits(data);
                if (count % 2 ==0) 
                    s = "odd";
                else
                    s = "even";
 
                sb.AppendLine();
                sb.AppendLine("Parity :" + s);
            }
            catch (Exception)
            {
 
                MessageBox.Show("invalid byte");
                data = 0;
            }
            textBox2.Text = sb.ToString();
        }
 
 
        private int CountByteBits(Byte b)
        {
            int count = 0;
            int nBits = 8;// necessaire dans le cas du byte
            while (b > 0)
            {
                count += b & 1;
                b >>= 1;
                b -= 1;
            }
            return count;
        }
        private string DisplayBits(byte data)
        {
            int n = 0;
            string byteString;
            StringBuilder builder = new StringBuilder(); 
            BitArray bitarray = new BitArray(new byte[1] { data });
 
            for (int i = bitarray.Length - 1; i >= 0; i--)
            {
                if (bitarray[i])
                {
                    n = 1; builder.Append(n.ToString());
                }
                else
                {
                    n = 0; builder.Append(n.ToString());
                }
            }
            builder.AppendLine();
            byteString = builder.ToString();
            return byteString;
        }
    }
}

Abondance de biens ne nuit pas...
bon code