Discussion :

[xxkirastarothxx]

Bonjour � tous,

je suis entrain de retaper une application Javascript en python, et je suis tomb� sur un probl�me:
� un moment dans le script, je tombe sur un ligne:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

return (x<<n)

alors, je farfouille un peu et je trouve ceci sur un autre site :

<< :: Rotation � gauche :: D�cale les bits vers la gauche (multiplie par 2 � chaque d�calage). Les z�ros qui sortent � gauche sont perdus, tandis que des z�ros sont ins�r�s � droite

Okay... alors, on refait le truc a la mano ensemble,
pour x = 1751007518
et n = 1

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
(dec)1751007518 = (bin)1101000010111100100000100011110
on d�calle le bit : 11010000101111001000001000111100
(bin)11010000101111001000001000111100 = (dec)3502015036

Donc, okay, �a correspond bien � une multiplication par 2.
et c'est d'ailleur ce que python me reponds si je lui demande "1751007518<<1"

Alors.... pourquoi en javascript "alert(1751007518<<1)" me renvoie -792952260 ???? oO
en regardant d'un peu plus pres, Si on compare un peu les deux valeur binaire:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
1101000010111100100000100011110  (1751007518)
__101111010000110111110111000100  (-792952260)

j'ai remarquer que les valeur en rouge �tait des inverses, mais c'est la seule piste que j'ai...
Ou peut �tre un probl�me avec le bit du signe ?

Donc voila, si quelqu'un � une explication, voir un bout de code (python) qui me permetrai de faire quelque chose l'�quivalent �a serrait super ^^

[TheGwy]

Parce qu'en javascript il n'y a pas de nombres entiers.

Tout les nombres sont des Doubles IEEE 754 de 32 bits.

Donc quand tu fais un shift sur un grand nombre comme �a qui occupe d�j� les 31 bits de ta mantisse et de ton exposant, tu d�bordes sur le 32�me bit qui sert au signe.

Enfin bon en gros : faire des op�rations binaires en JS c'est la merde et c'est impr�visible.

http://fr.wikipedia.org/wiki/IEEE_75..._.2832_bits.29

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
var num = 1<<29;
//                                                     signe     exp               mantisse
//                                                          |       |                      |
//                                                         21098765432109876543210987654321
console.log(num, num.toString(2));         //   536870912    100000000000000000000000000000
console.log(num<<1, (num<<1).toString(2)); //  1073741824   1000000000000000000000000000000
console.log(num*2, (num*2).toString(2));   //  1073741824   1000000000000000000000000000000
 
num = 1<<30;
console.log(num, num.toString(2));         //  1073741824   1000000000000000000000000000000
console.log(num<<1, (num<<1).toString(2)); // -2147483648 -10000000000000000000000000000000
console.log(num*2, (num*2).toString(2));   //  2147483648  10000000000000000000000000000000

[TheGwy]

PS : de toute �vidence c'est un bug dans ton programme d'origine, ne cherche pas � le reproduire.
Ou alors c'est r�ellement volontaire, mais alors c'est vraiment un gros hack bien sale et tu devrais r��crire quelque chose de plus stable que ce bricolage.

[Willpower]

Donc quand tu fais un shift sur un grand nombre comme �a qui occupe d�j� les 31 bits de ta mantisse et de ton exposant, tu d�bordes sur le 32�me bit qui sert au signe.

+1

Enfin bon en gros : faire des op�rations binaires en JS c'est la merde et c'est impr�visible.

Pour une fois, je ne suis pas d'accord avec toi, dieu du js, il faut juste savoir ce qu'on fait, comme pour tout code d'ailleurs.


Je travaille actuellement sur un code, qui compactes des donn�es de tailles connues dans des nombres binaires avant des les convertir dans une autre bases pour les envoyer sous forme d'une chaine compact�e.

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
// sauvegarde de 8 variables entières codées respectivement sur 6, 2, 1, 1, 2, 2, 4 et 6 bits sur les 32 bits d'une seule variable numérique
 
var varBin = 0;
varBin |= (donnee1_6bits & 63) << 18;
varBin |= (donnee2_2bits & 3) << 16;
varBin |= (donnee3_1bit & 1) << 15;
varBin |= (donnee4_1bit & 1) << 14;
varBin |= (donnee5_2bits & 3) << 12;
varBin |= (donnee6_2bits & 3) << 10;
varBin |= (donnee7_4bits & 15) << 6;
varBin |= (donnee8_6bits & 63);
 
// conversion de variable numérique en chaine de caractère base64 (6 bits) :
 
var _base64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
var code = '';
code += _base64.charAt((varBin >> 18) & 63);
code += _base64.charAt((varBin >> 12) & 63);
code += _base64.charAt((varBin >> 6) & 63);
code += _base64.charAt((varBin) & 63);

[TheGwy]

Oui tu as raison.
�a ne sert � rien de se dire c'est de la merde sans essayer de comprendre.

D'ailleurs je pense que je me suis un peu plant� plus haut quand je dis "Donc quand tu fais un shift sur un grand nombre comme �a qui occupe d�j� les 31 bits de ta mantisse et de ton exposant, tu d�bordes sur le 32�me bit qui sert au signe."

Quand tu fais un shift, ton Double doit �tre convertit en int sign� de 32 bits, et c'est dans cet int temporaire que tu d�borde sur le 32�me bit de poids fort qui sert au signe.
Car faire un shift sur la repr�sentation binaire d'un flottant cela n'a pas trop de sens.
Et cela explique aussi pourquoi une multiplication marche mais pas un shift : quand on multiplie, on ne convertit pas en int, et l'on reste dans dans une amplitude de valeurs exprimable avec un Double.

PS : de plus un Double c'est 64 et non 32 bits.

[xxkirastarothxx]

Merci pour ces explications, je pensais bien � quelque chose comme �a, sans v�ritablement savoir.

Mais alors, du coup, comment reproduire se "bug" dans un autre langage, car, effectivement, j'ai besoin de le reproduire, puisque les valeurs qui ont �t� calcul�es au pr�alable avec JS sont enregistr�es, il faut donc que je puisse toujours faire la transition en python.

Peux �tre mieux faut il que je pause la question dans la partie python ?

encore merci

[TheGwy]

Merci pour ces explications, je pensais bien � quelque chose comme �a, sans v�ritablement savoir.

Mais alors, du coup, comment reproduire se "bug" dans un autre langage, car, effectivement, j'ai besoin de le reproduire, puisque les valeurs qui ont �t� calcul�es au pr�alable avec JS sont enregistr�es, il faut donc que je puisse toujours faire la transition en python.

Peux �tre mieux faut il que je pause la question dans la partie python ?

encore merci

Bah du coup pour le reproduire c'est simple, il faut que tu utilise le m�me type de donn�e interm�diaire : c'est � dire un integer sign� de 32 bits.

Apr�s la vrai question c'est de savoir si Python � ce type de donn�e ou si tu dois faire appel � un package tiers qui l'impl�menterais... pour �a effectivement, mieux vaut demander dans la section Python.

[xxkirastarothxx]

Et bien merci pour tout, je vais all� me renseigner de ce cot�

[Willpower]

2 petites pr�cisions en plus :

- es-tu certain que ton code atteint de valeurs extr�mes comme celle que tu as utilisais pour provoquer le bug ? parce que rotation binaire ou non, c'est �trange(inhabituel) d'utiliser d'aussi grandes valeurs.

- en fait :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
1101000010111100100000100011110  (1751007518)
__101111010000110111110111000100  (-792952260)

792952260 = 2 * 1751007518 (mod 2^30)
(2^30 = plus grande puissance de 2 stockable sur 31 bits[0->30]... vu que le 32�me sert au signe)


1751007518 * 2 = 3502015036
2^30 = 1073741824

3502015036 mod 1073741824 = 280789564
280789564 - 1073741824 = -792952260


car si "101111010000110111110111000100" est bien la repr�sentation binaire de 792952260 sa valeur n�gative n'est en r�alit� pas stock�e sous cette forme en m�moire.

comme tu peux le voir ici, la repr�sentation n�gative d'un nombre en machine se fait en compl�ment � deux : http://fr.wikipedia.org/wiki/Syst%C3..._n.C3.A9gatifs

c'est pour cette raison que tu te retrouves avec tous les bits invers�e (apr�s troncage de ceux qui ont d�pass� le 31 bit)