Discussion :

[iflot]

Bonjour,

Je suis un novice en Assembleur (étudiant) et j'ai des problèmes en qui concerne la virgule flottante, voilà :

comment transformer un entier (16 bits) signé ou non en virgule flottante( la mantisse sur 12 bits 5 pour le biais et 1 pour le signe.

Quelqu'un peut m'aider , au moins des indications?

Merci.

[Neitsa]

Bonjour,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
.data?
MonReelAConvertir dw ? ; 16 bits alloués et non-initialisés
MonReel dw ?
 
.code
; en supposant que l'entier soit dans le low word d'EAX
mov MonReelAConvertir,ax
FINIT ;operation sur les FPU's
FILD MonReelAConvertir ; pousse sur le pile FPU
FIST MonReel ; "POP" le reel en mémoire

il est imprtant de mettre la valeur à convertir en mémoire avant de la poussé sur la pile FPU. Il est impossible de faire un FILD avec un registre:

Code :

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

1
2
 
FILD eax ; IMPOSSIBLE !

la taille de récupération dépend de la taille de l'emplacement où l'on récupère.(voir ce sujet pour plus de précision: Sujet sur les réels )

FIST ne sert que pour les entiers (sa contrepartie pour les réels est FSTP). L'instruction FISTP est semblable à FIST mais permet aussi de récupérer sur un Quadword.

Voilà.

Neitsa

[Blustuff]

Si tu tiens à travailler sur de la virgule flottante, l'indispensable, est d'avoir une référence du fpu. Tu aurais toutes les instructions fpu, et tu pourrais voir les différentes voies pour arriver à cette conversion. Ceux qui ont crée le fpu ne sont pas illogiques non plus, ton problème est un problème qui se pose à tous ceux qui utilisent le fpu. Donc il y a une instruction rien que pour cela. Seulement, le format des données qu'elle attend n'est pas aussi simple lui. Le post de Neitsa répond parfaitement à ta question.

[iflot]

marci beaucoup de m'aider
moi je cherche le prog qui transforme un entier en virgule flottante sur assembleur 8086
( la mantisse sur 12 bits 3 pour le biais et 1 pour le signe. .

aider moi stp c urgent merci

[Blustuff]

il n'y a pas de fpu ?

N'aurait-ce pas un rapport avec cela :

http://www.developpez.net/forums/viewtopic.php?t=191962

?

Je veux dire, tu veux convertir à la cro magnon ?
Je ne connais pas du tout les réel 16 bits, suis-ce les mêmes règles que le format IEEE 32, 64 et 80 bits ?

[iflot]

oui c les même règle ( norme IEEE,)

[Blustuff]

Alors, si c'est une simple conversion de format, c'est relativement facile.

tu as un nombre 16 bits, que tu dois transformer en une mantisse 12 bits, donc, supprimer quatre bits les moins significatifs. Mais règle très importante, le premier chiffre doit être un 1. A vrai dire, les autres chiffres ne t'intressent que peu. Donc, déterminer où est le premier 1. Exemple :

001a bcde fghi jkl (base 2)

(a, b, c, d, e, f, g, h, i, j, k, l = {0, 1})

devra être converti en

1,abcdefghijkl (base 2)

le 1 sera implicite, mais il reste 13 x à écrire. La mantisse ne peut contenir que 12 chiffres. Il faut donc suppimer le moins important le dernier.

1,abcdefghijk (base 2)

Deuxième exemple :

0000 0001 abcd efgh
sera converti de même en

1,abcdefgh

Mais il y a trop peu de x. Peu importe, ca tombe juste, remplacons les chiffres manquant par des 0 :

1,abcdefgh0000


L'algorithme est donc simple :

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
 
Exposant = 16
 
; Trouver le premier bit non nul 
 
Décaler de 1 bit vers la gauche, en insérant un 0 à droite
|
| Exposant = Exposant - 1
| 
Tant que le bit sortant n'est pas 1
 
 
; Revenir sur 12 bits :
 
Décaler vers la droite de 4 bits

Remarquons que la boucle risque de ne jamais finir, si le nombre est nul, donc il faut insérer un test au préalable.

L'exposant, obtenu doit juste être "biased" (connais pas la traduction française), donc lui ajouter 16 si je ne me trompe pas, puisque si l'on prend un nombre ou le bit de poid fort est à 1 on à :

1abc defg hijk lmno

que l'on décale d'un bit vers la gauche :

abcd efgh ijkl mno0

on a obtenu un 1 donc la boucle va s'arreter et l'exposant est 16 décrémenté de 1 soit 15, ce qui nous donne :

1,abcdefghijkl * 2 ^ 15

soit

1abcdefghijkl000

ce qui est bien notre nombre emputé de ses derniers chiffres.


Maintenant, il faut s'occuper du signe. La méthode que j'ai écrite marche pour des nombres non signés. On peut généraliser aux nombres signés, en notant le signe en récupérant le bit de signe, et en prenant la valeur absolue. (Je triche dans mon écriture d'algorithme pour que ce soit directment retranscriptible en asm ^^)

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
25
26
27
28
29
30
31
32
33
34
 
Si (Nombre = 0)
|
| Fin de la fonction, plus rien à faire, la représentation IEEE est 0
 
Si (Nombre < 0)
|
| Signe = Négatif
| Nombre = -Nombre
|
Sinon
|
| Signe = Positif 
 
 
Exposant = 16
 
; Trouver le premier bit non nul
 
Décaler de 1 bit vers la gauche, en insérant un 0 à droite
|
| Exposant = Exposant - 1
| 
Tant que le bit sortant n'est pas 1
 
 
; Revenir sur 12 bits :
 
Décaler vers la droite de 4 bits
 
 
; Biased Exponant 
 
Exposant = Exposant + 16

soit en asm

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
25
26
27
28
29
30
 
  xor ax, ax ; Resultat
  mov bx, Nombre
  test bx, bx
  jz Zero
  mov cx, 20h ; Biased Exponant
  jns Boucle
 
  ; Nombre Négatif
  or bx, 8000h ; Bit de signe
 
Boucle:
  dec cx ; Exposant = Exposant - 1
  shl bx, 1
  jnc Boucle
 
 
  ; Revenir sur 12 bits :
 
  shr bx, 4
 
 
  ; Composition du nombre :
 
  shl cx, 12
  or ax, cx
  or ax, bx
 
Zero:
  ret

Bon, j'espère que c'était la question :/ En tout cas, il y a certainement une dizaine d'erreur, donc à bien comprendre pour vérifier.