Discussion :

[xxkirastarothxx]

Bonjour à tous.

Pour la petit histoire, je suis en train de retaper un vieux prog fait en JS vers Python.
Quasiement tout est terminé, sauf pour une chose qui ne veux pas fonctionner: la manipulation de bit.

Précisement, c'est l'operateur "<<" qui me casse les bonbons ^^

En théorie:

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

donc, en théorie (et c'est le cas en python):
1751007518 << 1 = 3502015036

le soucis c'est qu'avec des nombres aussi grand, en javascript ça "déconne" puisque, si j'ai bien compris, on touche au 32em bit, qui est reservé au bit du signe.
Si bien que, en javascript:
1751007518 << 1 = -792952260

comparaison des nombre binaire:

Code :

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

1
2
3
4
0 1101000010111100100000100011 110  (1751007518)
1 1010000101111001000001000111 100 (3502015036) (res python)
1 0101111010000110111110111000 100  (-792952260) (res js)

J'ai aussi remarqué que les deux partie en rouge (le resultat en python et le restulat en js) sont des inverse (NON), je comprends pas exactement pourquoi m'enfin...

Bref, ma question, c'est de savoir comment faire pour reproduire ce "bug" en python pour que la comparaison des nombres enregistrée via l'ancienne application JS coresponde toujours en Python
Pour ceux qui voudrais plus de précision, j'ai déjà pausé quelques question sur ce comportement dans le forum javascript: http://www.developpez.net/forums/d11...e/#post6408962


Edit: Aucune urgence: je viens de me rendre compte que la fonction que j'essayai de recoder est simplement la fonction sha1 mdr ^^
Par contre, par curiosité j'aimerai bien connaître la réponse quand même

[fred1599]

Peut-être avec le module struct, il me semble avoir déjà eu à faire à cette question

[plxpy]

Bonjour

pour struct, je pense que "ça ne passe pas". Dès qu'on soumet, avec un format i, un entier qui ne peut pas être stocké, classiquement, sur 4 octets, ça couine :

Code :

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

1
2
3
4
5
6
7
8
>>> from struct import pack
>>> pack('i',2**31-1)
'\xff\xff\xff\x7f'
>>> pack('i',2**31)
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    pack('i',2**31)
error: long too large to convert to int

Alors, penser à faire un truc dans le genre aller-retour, ...

Certains modules le font peut-être mais "à la main", c'est faisable. Une façon de faire (pour 4 octets/32 bits) :

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
>>> def decalage_gauche_sauce_js(entier):
	# je ne conserve que les 32 bits des puissances de 2 les plus petites
	binary = [((2*entier)>>(31-i)) & 1 for i in range(32)]
	# a decoder comme un positif	
	if binary[0] == 0:
		return sum(map(lambda (i,b):(2**(30-i))*b,enumerate(binary[1:])))
	else:
		# inversion des 31 bits de droite
		inverse = map(lambda b:0 if b else 1,binary[1:])
		# calcul de la somme
		valeur = sum(map(lambda (i,b):(2**(30-i))*b,enumerate(inverse)))
		# resultat : oppose de somme+1
		return -1 * (valeur+1)
>>>
>>> decalage_gauche_sauce_js(1751007518)
-792952260
>>> decalage_gauche_sauce_js(123)
246
>>> decalage_gauche_sauce_js(-123)
-246
>>> decalage_gauche_sauce_js(2**30-1)
2147483646
>>> decalage_gauche_sauce_js(0)
0

[dividee]

Il y a plus simple:

Code :

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

1
2
3
>>> import ctypes
>>> ctypes.c_int32(1751007518 << 1).value
-792952260

Et aussi, je pense que ta conversion en binaire est incorrecte, c'est pourquoi le résultat n'est pas le même en binaire. La valeur binaire que tu donnes pour Python est la valeur correcte, même en javascript. La valeur que tu donnes pour Javascript est un 1 suivi de 31 bits qui représentent 792952260, mais ce n'est pas la façon dont les nombres négatifs sont représentés (ce n'est pas -792952260 mais -1354531388). Les nombres négatifs sont représentés en complément à 2, qui correspond à l'inversion de tous les bits et à l'ajout de 1. Si tu inverses les bits de ta valeur JS (sauf le bit de signe), et que tu ajoutes 1, tu retombes bien sur la valeur correcte.