Discussion :

[James_]

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

[KORTA]

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

[barthelv]

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.

[Anomaly]

[EDIT] Code corrigé :

Code :

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

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;

[leneuf22]

Dans ce cas :

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

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

[Elijha]

Salut

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

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

[Anomaly]

Exact leneuf22 j'avais fait une bêtise, il fallait remplacer & 2 par & 1. Code corrigé dans le premier post.

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

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

[leneuf22]

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

Code :

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

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.

[Elijha]

Salut

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 (le #include n'était là que pour le test sur pc).

Voila....

[leneuf22]

Salut

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 (le #include n'était là que pour le test sur pc).

Voila....

Dans ce cas, autant faire plus rapide :

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

[Elijha]

Salut

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

Voila...

[James_]

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

Code :

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

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

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!

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

[leneuf22]

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

Code :

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

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.

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!

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.

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

[James_]

Merci pour vos réponses! ;-)