Calculer la parité paire d'un char

Version imprimable

03/09/2003, 16h55
James_

Calculer la parité paire d'un char

Bonjour,

Je souhaiterai trouver un algorithme ou du code sur le calcul de la parité paire d'une variable char (8bits).

exemple si char = %0001001 Parité paire = 0,
si char = %1001001 Parité paire = 1.
Merci
03/09/2003, 16h59
KORTA

Peux tu m'expliquer ce qu'est la parité paire ?
03/09/2003, 17h01
barthelv

Citation:

Envoyé par KORTA

Peux tu m'expliquer ce qu'est la parité paire ?

Tu prends la somme des bits, si le résultat est paire, la parité paire l'est aussi. Si le résultat est impaire, elle l'est aussi.

[EDIT] Code corrigé :

Code:

1
2
3
4
5
6
7
 
char octet = 0x15;
int i;
int parite = 0;
for (i = 0; i < 8; i++)
  if ((octet >> i) & 1)
    parite ^= 1;

Dans ce cas :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
 
int parite_paire(unsigned char nombre);
 
int main(void) {
	unsigned char nbr=45;
	int pp=parite_paire(nbr);
 
	printf("Parite paire de 45 : %d", pp);
	getchar();
	return 0;
}
 
 
int parite_paire(unsigned char nombre) {
	int ret=0;
 
	while(nombre) {
		ret^=nombre & 1;
		nombre>>=1;
	}
	return ret;
}

Si tu as besoin d'explications... :wink:

EDIT : ton code ne donne pas le bon résultat Anomaly

Salut

Je te propose une autre manière pour trouver la parité d'un octet

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
#include <stdio.h>
 
// Table des nombres de bits à '1' de 0x00 à 0xFF
const unsigned char TabNumberOfOne[] =
  {
  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
  4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
  } ;
 
void main(void)
  { unsigned char octet = 0x15 ;
 
  if(TabNumberOfOne[octet]&1)   // Test si le nombre de bit à '1' est paire
    printf("Parité impaire\n") ;
  else
    printf("Parité paire\n") ;
  }

Enfin de compte, la table te renvoie le nombre de bits à '1' dans l'octet demandé, et ensuite on vérifie si la valeur renvoyé est paire ou pas.

Voila...

03/09/2003, 17h58
Anomaly

Exact leneuf22 j'avais fait une bêtise, il fallait remplacer & 2 par & 1. Code corrigé dans le premier post.
03/09/2003, 18h07
James_

La parité paire vaut 0 si la somme des 1 du char est paire et vaut 1 si la somme du char est impaire.

J'ai oublié de préciser que c'est pour de l'électronique embarqué donc je ne veux pas d'include.
03/09/2003, 18h34
hegros

De toute façon que tu inclus ou pas les includes en C le compilateur s'en moque tu auras des warning a la rigueur

D'ailleurs vire le stdio.h en C ca sert a rien c une ligne tapée en trop...

Voilà un code sans #include et modulable à souhaits :
Code:

1 2 3 4 5 6 7 8 9 int parite_paire(unsigned char nombre) { //retourne 0 si paire, 1 si impaire unsigned int ret=0; while(nombre) { ret^=nombre & 1; nombre>>=1; } return ret; }
L'include c'était pour afficher le résultat du test.

03/09/2003, 21h49
Elijha

Salut

Citation:

Envoyé par James_

J'ai oublié de préciser que c'est pour de l'électronique embarqué donc je ne veux pas d'include.

Je te propose ma solution que j'ai adopté pour de l'embarqué avec pas mal de contrainte de temps. Avec le principe du tableau tu n'est pas obligé de parcourir les 8 bits de ton octet. Le résultat est direct, il te suffit de testet le bit 0 de la valeur renvoyée. De plus le tableau peut être stocké en rom (économie de ram).
Donc du source ci-dessus, tu garde que le tableau et le test et ça marche :wink: (le #include n'était là que pour le test sur pc).

Voila....

Citation:

Envoyé par Elijha

Salut

Citation:

Envoyé par James_

J'ai oublié de préciser que c'est pour de l'électronique embarqué donc je ne veux pas d'include.

Je te propose ma solution que j'ai adopté pour de l'embarqué avec pas mal de contrainte de temps. Avec le principe du tableau tu n'est pas obligé de parcourir les 8 bits de ton octet. Le résultat est direct, il te suffit de testet le bit 0 de la valeur renvoyée. De plus le tableau peut être stocké en rom (économie de ram).
Donc du source ci-dessus, tu garde que le tableau et le test et ça marche :wink: (le #include n'était là que pour le test sur pc).

Voila....

Dans ce cas, autant faire plus rapide :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
const unsigned char tab_parite[] = 
  { 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 
  };
 
  int parite = tab_parite[nombre_a_tester];

03/09/2003, 23h11
Elijha

Salut

Encore +++rapide :wink: . J'espère que cette méthode te conviendra ?
(J'utilisais cette méthode non pas pour calculer la parité d'un octet, mais pour vérifier la bonne continuité de l'incrémentation d'un code Gray.)

Voila...

Citation:
Envoyé par leneuf22
Voilà un code sans #include et modulable à souhaits :
Code:

1 2 3 4 5 6 7 8 9 10 11 Code: int parite_paire(unsigned char nombre) { //retourne 0 si paire, 1 si impaire unsigned int ret=0; while(nombre) { ret^=nombre & 1; nombre>>=1; } return ret; }
L'include c'était pour afficher le résultat du test.
Je pense que ce code permet de remplacer int ret par un char ret non?
En fait ayant un petit µc je n'ai pas bcp de RAM et de ROM, un int me réserve 2 octets au lieu d'1...

Citation:

Envoyé par Elijha

Je te propose ma solution que j'ai adopté pour de l'embarqué avec pas mal de contrainte de temps. Avec le principe du tableau tu n'est pas obligé de parcourir les 8 bits de ton octet. Le résultat est direct, il te suffit de testet le bit 0 de la valeur renvoyée. De plus le tableau peut être stocké en rom (économie de ram).

Ben le problème est que je n'ai que peu de place en ROM mais c'est intéressant!

Citation:

Envoyé par Elijha

Encore +++rapide . J'espère que cette méthode te conviendra ?
(J'utilisais cette méthode non pas pour calculer la parité d'un octet, mais pour vérifier la bonne continuité de l'incrémentation d'un code Gray.)

Qu'est ce qui est encore plus rapide :?:

N'existe t-il pas d'autres moyen (via des divisions ou autre?)

Citation:
Envoyé par James_
Citation:
Envoyé par leneuf22
Voilà un code sans #include et modulable à souhaits :
Code:

1 2 3 4 5 6 7 8 9 10 11 Code: int parite_paire(unsigned char nombre) { //retourne 0 si paire, 1 si impaire unsigned int ret=0; while(nombre) { ret^=nombre & 1; nombre>>=1; } return ret; }
L'include c'était pour afficher le résultat du test.
Je pense que ce code permet de remplacer int ret par un char ret non?
En fait ayant un petit µc je n'ai pas bcp de RAM et de ROM, un int me réserve 2 octets au lieu d'1...
Oui bien sur, tu peux utiliser un char.

Citation:

Citation:

Envoyé par Elijha

Je te propose ma solution que j'ai adopté pour de l'embarqué avec pas mal de contrainte de temps. Avec le principe du tableau tu n'est pas obligé de parcourir les 8 bits de ton octet. Le résultat est direct, il te suffit de testet le bit 0 de la valeur renvoyée. De plus le tableau peut être stocké en rom (économie de ram).

Ben le problème est que je n'ai que peu de place en ROM mais c'est intéressant!

Citation:

Envoyé par Elijha

Encore +++rapide . J'espère que cette méthode te conviendra ?
(J'utilisais cette méthode non pas pour calculer la parité d'un octet, mais pour vérifier la bonne continuité de l'incrémentation d'un code Gray.)

Qu'est ce qui est encore plus rapide :?:

Le code d'Elijha que j'ai modifié, avec le tableau tab_parite est la solution la plus rapide que tu puisse utiliser, seulement elle prend 256 octets en mémoire.

Citation:

N'existe t-il pas d'autres moyen (via des divisions ou autre?)

On t'as donné pas mal de choix. Une division est très longue à réaliser par un processeur.
Si tu as les moyens de stocker la table de 256 octets, c'est parfait. Sinon je te conseille la fonction parite_paire() en remplaçant int par char comme tu l'as proposé. (le code proposé par Anomaly est plus lent).

03/09/2003, 23h55
James_

Merci pour vos réponses! ;-)