Discussion :

[Spout]

Bonjour à tous,

Je viens de faire un bout de code calculant les codes de Gray utilisés en aviation (infos sur le codage de Gray ici, infos sur le codage "Mode C" (altitude) ici et les différents codes obtenus ici).
Peu importe si vous ne comprenez pas le but, seule m'intéresse ici la manière dont il est obtenu.

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
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
unsigned short Code_Mask = 0x0FFF;
unsigned short tab[1280];
 
unsigned short i=0;
unsigned short j=0;
// Parcours des 2^12 valeurs possibles pour les codes, mais on ajoute dans le tableau seulement les valeurs autorisées
while(i<4096)
{
	// Calcul du code de Gray à partir du code binaire
	unsigned short N = i;
	unsigned short N2 = (i << 1) & Code_Mask;
	unsigned short Gray = (N ^ N2) >> 1;
 
	bool D1 = (Gray & 0x0800);		// D1 = 1?
	unsigned short c = (Gray & 0x0007);							
	if((c != 0) && (c != 5) && (c != 7) && !D1)	// Valeurs interdites de C + D1 doit toujours être 0
	{
                // On obtient alors DABC
		tab[j] = Gray & 0x07FF;
		if(j<1280)
			j++;
		else 
			break;
	}
	i++;
}
 
// Inversion des poids des bits 1 et 4 de chaque digit
for(unsigned int k=0; k<1280;k++)
{
	bool C4 = tab[k] & 0x0001; 
	bool C1 = tab[k] & 0x0004;
	if(C4)
		tab[k] |= 0x0004;
	else
		tab[k] &= 0x0FFB;
	if(C1)
		tab[k] |= 0x0001;
	else
		tab[k] &= 0x0FFE;
 
	bool B4 = tab[k] & 0x0008; 
	bool B1 = tab[k] & 0x0020;
	if(B4)
		tab[k] |= 0x0020;
	else
		tab[k] &= 0x0FDF;
	if(B1)
		tab[k] |= 0x0008;
	else
		tab[k] &= 0x0FF7;
 
	bool A4 = tab[k] & 0x0040; 
	bool A1 = tab[k] & 0x0100;
	if(A4)
		tab[k] |= 0x0100;
	else
		tab[k] &= 0x0EFF;
	if(A1)
		tab[k] |= 0x0040;
	else
		tab[k] &= 0x0FBF;
 
	// Rappel : D1 doit être 0
	bool D4 = tab[k] & 0x0200;
	if(D4)
		tab[k] |= 0x0800;
	else
		tab[k] &= 0x07FF;
 
	tab[k] &= 0x0DFF;
 
}
 
// Association de l'altitude au code correspondant
// Note : tPair est une paire de deux paires de int pour les digits (A,B) et (C,D) du code d'altitude
std::map<int,tPair> mapCode; 
int altitude = -1200;				// -1200 est la première valeur d'altitude, puis évolue de 100 en 100
for(unsigned int p=0; p<1280;p++)
{
	int A = (tab[p] & 0x01C0) >> 6;
	int B = (tab[p] & 0x0038) >> 3;
	int C = (tab[p] & 0x0007);
	int D = (tab[p] & 0x0E00) >> 9;
 
	mapCode.insert(std::make_pair(altitude,std::make_pair(std::make_pair(A,B),std::make_pair(C,D))));
	altitude += 100;
}

N'étant pas une star du C++, je cherche à optimiser ce bout de code. Donc n'hésitez pas à vous déchaîner si vous voyez des choses qui vous choquent carrément ou qui pourraient être améliorées.
Je suis toute ouïe, en vous remerciant d'avance

[ram-0000]

Pourquoi est ce que tu cherches à optimiser ton code ?
* Parce qu'il n'est pas assez rapide ?
* Parce qu'il n'est pas assez concis ?

Si ton problème est uniquement un problème de concision, je ne pense pas qu'il faille y toucher car tu risque de le rendre incompréhensible.

Dans l'état actuel, il est parfaitement lisible (même si je ne comprends pas ce que tu y fais car ce sont des données que je ne comprends pas pas)

[yan]

Salut.
Pourquoi utiliser une map??? un vector sera plus rapide
pour faire une pair de pair?? une structure sera sûrement plus simple à gérer

[Spout]

Pourquoi est ce que tu cherches à optimiser ton code ?
* Parce qu'il n'est pas assez rapide ?
* Parce qu'il n'est pas assez concis ?

J'ai fait ça en un jet un peu à la va-vite. Je n'ai pas de problèmes de rapidité, c'est juste que je pense qu'il doit y avoir moyen de ne pas perdre de temps inutile sur certaines actions (comme les boucles par exemple), mais je vois pas trop comment m'y prendre.

Pourquoi utiliser une map??? un vector sera plus rapide
pour faire une pair de pair?? une structure sera sûrement plus simple à gérer

J'utilise une map pour accéder directement aux valeurs A, B, C et D en rentrant l'altitude en paramètre. Si j'utilise un vecteur, je perds cet accès direct non?
Mais plutôt qu'une paire de paires pour stocker A, B, C et D, je suis d'accord, une structure devrait mieux faire l'affaire. Je vais faire ça.
d'ores et déjà pour ces commentaires!

[Kujara]

Le truc atroce au milieu avec des |= et des &= doit etre possible en genre 3 lignes avec un temporaire, des masques et des decalages.

J'irai jeter un coup d'oeil ce soir, si j'ai le temps.

[yan]

J'utilise une map pour accéder directement aux valeurs A, B, C et D en rentrant l'altitude en paramètre. Si j'utilise un vecteur, je perds cet accès direct non?

Non et rechercher l'altitude la plus proche est coûteuse.
vu que tu as un min et un pas, un vector est plus adapter.
en gros :

Code :

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

1
2
3
4
5
gray convertAltitudeToGray(float altitude);
{
int id =(altitude - min)/pas +.5;
return vect[id];
}

[Kujara]

Ok, j'avais tort.

4 lignes, pas 3

Code :

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

1
2
3
4
unsigned short l_temp = tab[k] & 0x0492;
l_temp |= ( tab[k] & 0x0249 ) << 2;
l_temp |= ( tab[k] & 0x0124 ) >> 2;
tab[k] = l_temp;

[Spout]

Hey!! C'est pas du tout mal vos idées! C'est exactement le genre de simplifications que je recherchais.
Merci à Mongaulois pour le stockage et merci à Kujara pour les masques