Je suis à la recherche d'une explication. Je lis d'un fichier une valeur
"Single", donc 4 bytes.
Cette chaîne de caractères représente un nombre de la façon suivante:
Chaque caractère a une valeur Ascii et cette valeur peut être transposée en
8 bits (Binaire)
Si l'on concatène les 8 bits représentant chacun des 4 caractères de la
valeur "Single ", nous obtenons une chaîne de 32 bits.
Le premier bit représente le signe (0 : Positif, 1: Négatif)
Les 8 bits suivants permettent de trouver l'exposant en soustrayant la
valeur de ces 8 bits de 127.
Exemple: 127 - 81 (01010001) = 46 (exposant)
Les 23 bits qui restent sont la mantisse.
J'ai trouvé une formule sur Internet qui devrait permettre de retrouver mon
nombre de départ mais je n'y arrive pas. Voici la formule:
s: signe (0 ou 1)
e: exposant
m: mantisse
(-1)^s * m * 2^(e-127)
Elle est peut-être erronnée ou alors je ne la comprends pas bien.
Quelqu'un peut-il m'aider à comprendre le principe ?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
jm
"Pierre Archambault" wrote in message news:lv%eh.5161$
Bonsoir, ou bonjour selon le cas...
Hello,
Je suis à la recherche d'une explication. Je lis d'un fichier une valeur "Single", donc 4 bytes. J'ai trouvé une formule sur Internet qui devrait permettre de retrouver mon nombre de départ mais je n'y arrive pas. Voici la formule:
<snip>
s: signe (0 ou 1) e: exposant m: mantisse
(-1)^s * m * 2^(e-127) Elle est peut-être erronnée ou alors je ne la comprends pas bien.
Elle est correcte...
Quelqu'un peut-il m'aider à comprendre le principe ?
C'est du masochisme, mais bon allons-y ...
Well, pour bien comprendre, il faut savoir 2 choses:
a) On est sous Windows, dans une architecture Intel donc Little Endian => Les LSB sont en tête
b) Dans la norme utilisée (IEE754), la ruse c'est que la mantisse représentée est sur 23 bits, mais la mantisse réelle est sur 24, car on suppose la présence d'un bit (dit "bit implicite" à 1 (à la fin)).
Prenons le code suivant: n = 1 f = FreeFile Open "c:test.dat" For Binary As #f Put #f, , n Close #f
Editons notre fichier test.dat avec un éditeur hexa, on trouve: 00 00 80 3F
Maintenant, comme nous sommes en little endian, la valeur réelle est: 3F 80 00 00
En binaire, ça nous donne: 00111111100000000000000000000000 Si on redécoupe selon le format 1|8|23, on obtient 0 01111111 00000000000000000000000
Soit: S = 0 E = 7F (127) M = 0 (mais avec le bit implicite, M = 1)
on a bien Valeur = (-1)^0 * 1 * 2^(127-127) = 1 * 1 * 1 = 1 CQFD.
Même exercice avec n=3.5
le fichier test.dat va contenir: 00 00 60 40 <==> 40 60 00 00
soit en binaire 01000000011000000000000000000000
et après découpage S = 0 = 0 E = 10000000 = 0x80 = 128 et pour M, on prend les 23 bits, à l'envers: 11000000000000000000000 <=> 00000000000000000000011 et on ajoute le bit 1 (implicite) => 000000000000000000000111 000000000000000000000111 = 0x0007 = 7
"Pierre Archambault" <pierre.archambault@videotron.ca> wrote in message
news:lv%eh.5161$88.217588@weber.videotron.net...
Bonsoir, ou bonjour selon le cas...
Hello,
Je suis à la recherche d'une explication. Je lis d'un fichier une valeur
"Single", donc 4 bytes.
J'ai trouvé une formule sur Internet qui devrait permettre de retrouver
mon nombre de départ mais je n'y arrive pas. Voici la formule:
<snip>
s: signe (0 ou 1)
e: exposant
m: mantisse
(-1)^s * m * 2^(e-127)
Elle est peut-être erronnée ou alors je ne la comprends pas bien.
Elle est correcte...
Quelqu'un peut-il m'aider à comprendre le principe ?
C'est du masochisme, mais bon allons-y ...
Well, pour bien comprendre, il faut savoir 2 choses:
a) On est sous Windows, dans une architecture Intel donc Little Endian
=> Les LSB sont en tête
b) Dans la norme utilisée (IEE754), la ruse c'est que la mantisse
représentée est sur 23 bits, mais la mantisse réelle est sur 24, car
on suppose la présence d'un bit (dit "bit implicite" à 1 (à la fin)).
Prenons le code suivant:
n = 1
f = FreeFile
Open "c:test.dat" For Binary As #f
Put #f, , n
Close #f
Editons notre fichier test.dat avec un éditeur hexa, on trouve:
00 00 80 3F
Maintenant, comme nous sommes en little endian, la valeur réelle est:
3F 80 00 00
En binaire, ça nous donne:
00111111100000000000000000000000
Si on redécoupe selon le format 1|8|23, on obtient
0 01111111 00000000000000000000000
Soit:
S = 0
E = 7F (127)
M = 0 (mais avec le bit implicite, M = 1)
on a bien Valeur = (-1)^0 * 1 * 2^(127-127) = 1 * 1 * 1 = 1
CQFD.
Même exercice avec n=3.5
le fichier test.dat va contenir:
00 00 60 40 <==> 40 60 00 00
soit en binaire
01000000011000000000000000000000
et après découpage
S = 0 = 0
E = 10000000 = 0x80 = 128
et pour M, on prend les 23 bits, à l'envers:
11000000000000000000000 <=> 00000000000000000000011
et on ajoute le bit 1 (implicite) => 000000000000000000000111
000000000000000000000111 = 0x0007 = 7
"Pierre Archambault" wrote in message news:lv%eh.5161$
Bonsoir, ou bonjour selon le cas...
Hello,
Je suis à la recherche d'une explication. Je lis d'un fichier une valeur "Single", donc 4 bytes. J'ai trouvé une formule sur Internet qui devrait permettre de retrouver mon nombre de départ mais je n'y arrive pas. Voici la formule:
<snip>
s: signe (0 ou 1) e: exposant m: mantisse
(-1)^s * m * 2^(e-127) Elle est peut-être erronnée ou alors je ne la comprends pas bien.
Elle est correcte...
Quelqu'un peut-il m'aider à comprendre le principe ?
C'est du masochisme, mais bon allons-y ...
Well, pour bien comprendre, il faut savoir 2 choses:
a) On est sous Windows, dans une architecture Intel donc Little Endian => Les LSB sont en tête
b) Dans la norme utilisée (IEE754), la ruse c'est que la mantisse représentée est sur 23 bits, mais la mantisse réelle est sur 24, car on suppose la présence d'un bit (dit "bit implicite" à 1 (à la fin)).
Prenons le code suivant: n = 1 f = FreeFile Open "c:test.dat" For Binary As #f Put #f, , n Close #f
Editons notre fichier test.dat avec un éditeur hexa, on trouve: 00 00 80 3F
Maintenant, comme nous sommes en little endian, la valeur réelle est: 3F 80 00 00
En binaire, ça nous donne: 00111111100000000000000000000000 Si on redécoupe selon le format 1|8|23, on obtient 0 01111111 00000000000000000000000
Soit: S = 0 E = 7F (127) M = 0 (mais avec le bit implicite, M = 1)
on a bien Valeur = (-1)^0 * 1 * 2^(127-127) = 1 * 1 * 1 = 1 CQFD.
Même exercice avec n=3.5
le fichier test.dat va contenir: 00 00 60 40 <==> 40 60 00 00
soit en binaire 01000000011000000000000000000000
et après découpage S = 0 = 0 E = 10000000 = 0x80 = 128 et pour M, on prend les 23 bits, à l'envers: 11000000000000000000000 <=> 00000000000000000000011 et on ajoute le bit 1 (implicite) => 000000000000000000000111 000000000000000000000111 = 0x0007 = 7
