Discussion :

[miminou]

je ne sais pas si je suis ds le bon sujet, mais j'ai un petit probleme avec l'inversement de bit. je doit faire une fonction qui inverse les bits et je ne sais pas comment faire. j'ai comme un aide,un alogithme pour m'aider, mais je le comprend pas...si qq1 peut m'aider, svp. je suis en train de péter un cable...merci d'avance

voici l'ago:

Algorithme détaillé de la fonction init_spectre :

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
void init_spectre(float signal_discret[N],float spectre[N][2])
{
	int i,i2,j,k;
 
	for(i=0;i<N;i++)
	{
/************* Sauvegarde de i dans i2 *************/
 
/********** Calcul de l'indice j **********/
	j=0;
	for(k=1;k<=P;k++)
	{
/* Décalage de j de 1 bit vers la gauche */
 
/* Recopie du bit le plus à droite de i2 dans j */
 
/* Décalage de i2 de 1 bit vers la droite */
 
                }
 
 	}
}

[Neitsa]

Bonjour,

j'ai du mal à comprendre ce que fait l'algo en vérité... On voit bien les tableaux de flottants passés mais i, j , i2, etc. sont des entiers (integers).
Je ne comprend pasl'intérêt de manipulé les bits ici. Un peu plus d'explications serait bienvenu...

attention P semble être une constante magique sortant de nul part...

Indépendamment de l'algo :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* Décalage de j de 1 bit vers la gauche */
j =<< 1; // j = j << 1
 
/* Recopie du bit le plus à droite de i2 dans j */ 
//passage par une variable temp pour garder i2 dans son état initial
int temp = 0;
temp = i2;
temp &= 1; // temp = temp & 1; garde le bit le + à droite
j |= temp; // j = j | temp; OU binaire (bitwise OR)
 
/* Décalage de i2 de 1 bit vers la droite */
i2 =>> 1;// i2 = i2 >> 1;

[miminou]

oui je sais, c'est un algo que j'ai trouvé sur le net... c'est dc bien incompréhensible...auriez-vous une autre idée pr faire cet inversement : lire de droite a gauche? ex : 001 devient 100

[Aurelien.Regat-Barrel]

Je déplace vers le forum C.

[granquet]

il me semble que l'operateur ~ fait une inversion bit a bit ...
precision: sur des entiers !

[Neitsa]

auriez-vous une autre idée pr faire cet inversement : lire de droite a gauche? ex : 001 devient 100

Ca n'est pas très complexe en soit, mais cela demande quand même de connaitre la façon dont les ordinateurs "stockent" les nombres. Ainsi en C on ne manipule les bits qu'avec les opérateurs binaires (bitwise AND, OR, NOT, XOR) ou avec des champs de bits (méthode non portable).

On ne peut donc stocker un nombre que dans une "unité" minimale : l'octet (8 bits). Sur un PC, l'unité maximale est "long long" soit 64 bits.

Si je reprend ton exemple, de 001 , j'inverse tout les bits, pour obtenir 100, cela n'est pas directement possible, car je doit me conformer à l'unité minimale de 8 bits, ainsi 001 devient 00000001 et là l'inversion du sens de lecture pose problème puisque j'obtiens 10000000

Pour résoudre ce problème tu devra coder une fonction dans laquelle tu passera un nombre ayant un type maximal (8, 16, 32, 64 bits) et aussi quel est le nombre de bit représentatif du nombre en question (en effet, pour une inversion du sens de lecture de bits, 001 est différent de 01 ).

Dans le corps de ta fonction tu n'aura besoin que des opérateurs binaires AND ( & ), OR ( | ) et SHIFT (<< ; >>).

Je te laisse faire pour ce qui est du code en lui-même. N'hésite pas si tu as des problèmes.

Attention, une inversion du sens de lecture est différent d'un changement d'endianess !

il me semble que l'operateur ~ fait une inversion bit a bit ...

Il cherche à faire une inversion de lecture et non un complément bit à bit.

Code :

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

1
2
3
 
unsigned int Nombre= 4; /*   4 = 0000 0100 */  
Nombre = ~ Nombre; /* 251 = 1111 1011 */

[miminou]

en fait, j'ai un tableau de valeur et je veux les trier de la facon suivante:
mon tableau a pour valeur f0,f1,f2,f3,f4,f5,f6,f7 par exemple et je veux mettre les valeur ayant l'indice pair d'un coté, et l'indice impair de l'autre coté. pour cela, on m'a conseillé l'inversement des bits:
0->000->000->0
0->001->100->4
0->010->010->2
0->011->110->6
0->100->001->1
0->101->101->5
0->110->011->3
0->111->111->7
et mais valeur prennent la position f0,f4,f2,f6,f1,f5,f3,f7.
donc enfait je travialle sur les indice de mes valeurs...comment je fait ca?
merci pr vos aides ci-dessus

[diogene]

je veux mettre les valeur ayant l'indice pair d'un coté, et l'indice impair de l'autre coté. pour cela, on m'a conseillé l'inversement des bits:

Ce n'est pas la même chose.
L'inversion des bits est utilisée dans certains algorithmes de FFT (Transformée de Fourier discrète de Cooley-Tukey) pour réarranger les données avant ou après le calcul proprement dit.
Voici un exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
unsigned int inv( unsigned int n, unsigned int max)
{
 unsigned int b=0;
 while(max)
 {
  if(n&1) b |= max ;
  max >>=1;
  n >>=1;
 }
 return b;
}

Où n est la valeur à inverser et max est une valeur (constante) qui est égale à la valeur de 1 inversée ( ce qui est une indication sur le nombre de bits que doit avoir le nombre après inversion, 4 dans ton exemple)
Si tes valeurs sont dans un tableau Tab de N éléments, avec N une puissance de 2, on a max = N/2. On a alors

Code :

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

1
2
3
4
5
6
7
8
for(i=1; i<N-1; i++)
 {
     j = inv(i,N/2);
     if(i>j) 
       {
         // inverser Tab[i] et Tab[j]
       }
  }

[Emmanuel Delahaye]

il me semble que l'operateur ~ fait une inversion bit a bit ...
precision: sur des entiers !

... non signés, pour être portable.