Litlle-Endian?

[gr4ph0s]

Salut tout le monde je recherche en effet le moyen de passer du nombre de droite au nombre de gauche et inversement ^^

Donc voici la liste :
[spoiler]

Code :

1 8
2 64
3 72
4 512
5 520
6 576
7 584
8 32768
9 32776
10 32832
11 32840
12 33280
13 33288
14 33344
15 33352
16 2
17 10
18 66
19 74
20 514
21 522
22 578
23 586

[/spoiler]

Suite au conseil de Ark sur IRC j'ai donc pensé que c'étais qu'une simple histoire de litlle-endian(qui en sois n'est pas sorcier)
Mais c'est la que viens mon problème...

Pour 1 et 8 pas de problème => 8 en binaire = 10 00 donc sa donne 00 01 en litlle endian donc 1

Pour 2 et 64 la non plus => 64 en binaire = 01 00 00 00 donc sa donne 00 00 00 10 en litlle endian donc 2

Mais par contre pour 3 et 72... si je suis la même méthode 72 en binaire = 01 00 10 00 donc sa donne 00 01 00 01 en litlle sois 17 et non 3...


Donc je ne vois pas trop ai-ce ma technique qui n'est pas bonne? Bref merci d'avance et surtout un truc que je n'ai pas compris pourquoi tout les système ne lisse pas pareil le binaire? ^^'

[ark]

Ah, tu cherches donc une opération qui marche pour pour toute ta liste ?

Apres, pour le little / big endian, c'est juste une notation, 0b1000 en big endian ca fait 8(10). Mais 0b0001 en little endian c'est toujours 8(10) :p C'est juste la notation qui change.

[gr4ph0s]

Oui je recherche une opération(qui normalement est la même, je verrais pas pourquoi ça ne serais pas la même ^^) pour toute la liste. En effet les nombres de gauche sont les données dans la base de donné et les nombres de droites ceux dans un fichier.

Mon but étant de faire un programme pour gérer la mise à jour automatique de la BDD en fonction du fichier

Oui ce n'est qu'une notation mais bon transformer 0b1000 en binaire big endian ne donnera pas(logiquement) la même chose que 0b0001 en big endian :p

[gruik]

pour effectuer une conversion vers du gros indien l'instruction movbe fait ça très bien sur 16, 32 ou 64 bits

sinon pour essayer d'y voir un peu plus clair :

Code PYTHON :


>>> liste = [ (1, 8), (2, 64), (3, 72), (4, 512), (5, 520), (6, 576), (7, 584),
... (8, 32768), (9, 32776), (10, 32832), (11, 32840), (12, 33280), (13, 33288),
... (14, 33344), (15, 33352), (16, 2), (17, 10), (18, 66), (19, 74), (20, 514),
... (21, 522), (22, 578), (23, 586) ]
>>> print '\n'.join(['{:016b} => {:016b}\t({:5d} => {:5d})'.format(i,j,i,j) for i,j in liste])
0000000000000001 => 0000000000001000    (    1 =>     8)
0000000000000010 => 0000000001000000    (    2 =>    64)
0000000000000011 => 0000000001001000    (    3 =>    72)
0000000000000100 => 0000001000000000    (    4 =>   512)
0000000000000101 => 0000001000001000    (    5 =>   520)
0000000000000110 => 0000001001000000    (    6 =>   576)
0000000000000111 => 0000001001001000    (    7 =>   584)
0000000000001000 => 1000000000000000    (    8 => 32768)
0000000000001001 => 1000000000001000    (    9 => 32776)
0000000000001010 => 1000000001000000    (   10 => 32832)
0000000000001011 => 1000000001001000    (   11 => 32840)
0000000000001100 => 1000001000000000    (   12 => 33280)
0000000000001101 => 1000001000001000    (   13 => 33288)
0000000000001110 => 1000001001000000    (   14 => 33344)
0000000000001111 => 1000001001001000    (   15 => 33352)
0000000000010000 => 0000000000000010    (   16 =>     2)
0000000000010001 => 0000000000001010    (   17 =>    10)
0000000000010010 => 0000000001000010    (   18 =>    66)
0000000000010011 => 0000000001001010    (   19 =>    74)
0000000000010100 => 0000001000000010    (   20 =>   514)
0000000000010101 => 0000001000001010    (   21 =>   522)
0000000000010110 => 0000001001000010    (   22 =>   578)
0000000000010111 => 0000001001001010    (   23 =>   586)
 

les choses apparaissent mieux, on voit clairement qu'il s'agit pas d'une conversion little/big endian, on dirait que chaque bit est comme séparé par '00', au début j'ai cru à un truc genre 8^bitnum, mais ca tombe vite à l'eau, on dirait également qu'il y a une sorte de wrap des bits, ou alors il s'agit peut être juste d'une transformation bit à bit
en tous cas j'ai plutot l'impression que la transformation n'est pas simpliste comme une conversion xyz ou une opération standard, à voir...

btw t'aurais moyen de choper les valeurs pour 32, 64 et 128 stp ?

[gr4ph0s]

32 dans la BDD me donne 256 dans le fichier.
64 dans la BDD me donne 2097152 dans le fichier.
L'ID 128 n'existe pas(va savoir pourquoi?..) mais 256 dans la BDD me donne 4 dans le fichier

Selon mes recherche a creuser peut être mais sa me parait bien compliqué.
1 = 8 => 8
2 = 64 => 8*8
3 = 72 => 8*8+8

4 = 512 => (8*8*8)
5 = 520 => (8*8*8) + 8
6 = 576 => (8*8*8) + (8*8)
7 = 584 => (8*8*8) + (8*8+8)

8 = 32768 => (8*8*8) *8*8
9 = 32776 => ((8*8*8) *8*8) + 8
10 = 32832 => ((8*8*8) *8*8) + 8*8
11 = 32840 => ((8*8*8) *8*8) + 8*8+8

12 = 33280 => ((8*8*8) *8*8) + (8*8*8)
13 = 33288 => (((8*8*8) *8*8) + (8*8*8)) + 8
14 = 33344 => (((8*8*8) *8*8) + (8*8*8)) + 8*8
15 = 33352 => (((8*8*8) *8*8) + (8*8*8)) + 8*8+8

Et la Dafuck....
16 = 2
17 = 10 => 2+8
18 = 66 => 2+8*8
19 = 74 => 2+8*8+8

En effet il semblerais que toute les 16 ID on recommence au début... Mais bon c'est bizarre et je reste persuadé qu'il s'agit d'une opération sur les bits car ça serais complètement illogique de devoir refaire à chaque fois une suite mathématique pour obtenir l'ID 9082006 par exemple.


En tout cas merci de ta réponse

[gruik]

comme ça au pif je dirais que c'est de la pure permutation de bits, alors peut-être qu'il y a une formule magique derrière évidement...

actuellement on aurait donc la table de permutations suivante :

Code PYTHON :


bit 0 :   1 => 8
bit 1 :   2 => 64
bit 2 :   4 => 512
bit 3 :   8 => 32768
bit 4 :  16 => 2
bit 5 :  32 => 256
bit 6 :  64 => 2097152
bit 7 : 128 => non défini (impossible/inexistant ?)
bit 8 : 256 => 4
 

ça se vérifie bien, par exemple 19 en décimal donne 10011 en binaire, passé à la permutation de bits on obtient 2*1 + 32768*0 + 512*0 + 64*1 + 8*1 soit 2 + 64 + 8 = 74, comme prévu

il serait donc intéressant d'avoir les valeurs pour 512,1024,2048,4096,8192,16384,32768,65536 etc. voire jusqu'à 2^24 ou 2^32 possiblement (puisque 2097152 = 2^21)

toujours au pifomètre je verrais bien le bit 12 (4096) correspondre à 1, une intuition...