Multiplication et overflow
Résolu
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
-
23 janv. 2006 à 01:57
cs_Nasman Messages postés 202 Date d'inscription mardi 17 mai 2005 Statut Membre Dernière intervention 29 septembre 2008 - 24 janv. 2006 à 08:24
cs_Nasman Messages postés 202 Date d'inscription mardi 17 mai 2005 Statut Membre Dernière intervention 29 septembre 2008 - 24 janv. 2006 à 08:24
A voir également:
- Overflow ph
- Problème de stack overflow avec classe - Forum C++ & C++ .NET
- Stack overflow !!!! ✓ - Forum C++ & C++ .NET
- Erreur de stack overflow à cause de tableaux trop volumineux - Forum C / C++ / C++.NET
- Document.getElementById('body').style.overflow='hidden' - Forum Javascript / DHTML
- Overflow-y dans div et balises - Forum PHP
12 réponses
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
24 janv. 2006 à 00:34
24 janv. 2006 à 00:34
bon j'ai résolu mon problème mais pour le moment c'est très très barbare voici le code
multiplication:
CALL newline
CALL newline
MOV DX, 0
affichmes resmult
MOV AX, nb1
MUL nb2
CMP DX, 0
JNE multipover
CALL affichage
JMP division
multipover:
MOV nbdx, DX
MOV DX, 0
MOV mult, AX
MOV BX, 10
MOV retenu, 0
MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, mult
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
MOV AX, DX
PUSH DX
MOV AX, 3
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
multiplication:
CALL newline
CALL newline
MOV DX, 0
affichmes resmult
MOV AX, nb1
MUL nb2
CMP DX, 0
JNE multipover
CALL affichage
JMP division
multipover:
MOV nbdx, DX
MOV DX, 0
MOV mult, AX
MOV BX, 10
MOV retenu, 0
MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, mult
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
MOV AX, DX
PUSH DX
MOV AX, 3
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 5
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
MOV DX, 0
DIV BX
MOV retenu, AX
PUSH DX
MOV AX, 6
MUL nbdx
MOV tempo1, AX
MOV AX, tempo2
MOV DX, 0
DIV BX
MOV tempo2, AX
MOV AX, tempo1
ADD AX, DX
ADD AX, retenu
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
POP AX
CALL affichage
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
23 janv. 2006 à 08:50
23 janv. 2006 à 08:50
Bonjour piopium,
Effectivement les instructions de multiplication mul et imul,
multiplient le contenu de al, ax ou eax par un nombre de même capacité
(octet, word, Dword) et mettent le résultat dans:
- ax si l'octet multiplié est al
- dx:ax (soit 65536*dx+ax) pour ax
- edx:eax (soit 4294967296*edx+eax) pour eax
Tu dispose de deux instructions, mul et imul.
mul effectue la multiplication d'entiers non signés soit si al=128
(10000000b ou 80h) et l'autre octet vaut 4 (00000100b) tu auras ax=512
(0000001000000000b ou 200h).
Avec l'instruction imul (pour les entiers signés), al=10000000b sera
considéré comme négatif et vaudra -128. Le résultat sera -512 soit
ax=1111111000000000b ou FE00h.
Daus le cas qui te concerne, tu effectue probablement une conversion
décimal/hexa lors de la saisie de tes nombres. Tu mets alors un entier
dans ax (de 0 à 270Fh), l'autre (16bits) ou bon te semble, le résultat
sera dans dx:ax. dx:ax constitue un "registre 32 bits" qui sera signé
si tu utilise imul et non signé si tu utilise mul.
Dans les deux cas l'ensemble dx:ax représentera un nombre positif
puisqu'il sera inférieur ou égal à 5F592E1h (99980001), la limite étant
7FFFFFFFh.
Nota: ax pourra sembler négatif mais l'ensemble dx:ax sera positif (bit 15 de dx=0)
A+
Effectivement les instructions de multiplication mul et imul,
multiplient le contenu de al, ax ou eax par un nombre de même capacité
(octet, word, Dword) et mettent le résultat dans:
- ax si l'octet multiplié est al
- dx:ax (soit 65536*dx+ax) pour ax
- edx:eax (soit 4294967296*edx+eax) pour eax
Tu dispose de deux instructions, mul et imul.
mul effectue la multiplication d'entiers non signés soit si al=128
(10000000b ou 80h) et l'autre octet vaut 4 (00000100b) tu auras ax=512
(0000001000000000b ou 200h).
Avec l'instruction imul (pour les entiers signés), al=10000000b sera
considéré comme négatif et vaudra -128. Le résultat sera -512 soit
ax=1111111000000000b ou FE00h.
Daus le cas qui te concerne, tu effectue probablement une conversion
décimal/hexa lors de la saisie de tes nombres. Tu mets alors un entier
dans ax (de 0 à 270Fh), l'autre (16bits) ou bon te semble, le résultat
sera dans dx:ax. dx:ax constitue un "registre 32 bits" qui sera signé
si tu utilise imul et non signé si tu utilise mul.
Dans les deux cas l'ensemble dx:ax représentera un nombre positif
puisqu'il sera inférieur ou égal à 5F592E1h (99980001), la limite étant
7FFFFFFFh.
Nota: ax pourra sembler négatif mais l'ensemble dx:ax sera positif (bit 15 de dx=0)
A+
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
23 janv. 2006 à 10:58
23 janv. 2006 à 10:58
je ne peux pas utilisé les registres de 32bits car, je tourne en dos et donc 16bits maximum mais merci quand même
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
23 janv. 2006 à 13:14
23 janv. 2006 à 13:14
je me suis trompé, en rajoutant .386 j'ai accès à ces registre mais ça ne marche toujours pas
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
23 janv. 2006 à 13:36
23 janv. 2006 à 13:36
Quel est ton problème exactement ? C'est normal que tu ais un overflow
mais ce n'est pas dramatique. Le résultat de 65536*dx+ax est-il correct
? Es tu sur que les nombres saisis soient convertis correctement avant
traitement de la multiplication ? Comment est restitué le résultat.
Le calcul de la multiplication n'est pas le plus délicat (si les
calculs sont effectués en hexa), je pense plutôt que le problème est au
niveau des conversions hexa/décimal et la conversion en caractères
ascii.
Pour t'aider il faudrait que tu en dise plus (en mettant le code en question). Bon courage
mais ce n'est pas dramatique. Le résultat de 65536*dx+ax est-il correct
? Es tu sur que les nombres saisis soient convertis correctement avant
traitement de la multiplication ? Comment est restitué le résultat.
Le calcul de la multiplication n'est pas le plus délicat (si les
calculs sont effectués en hexa), je pense plutôt que le problème est au
niveau des conversions hexa/décimal et la conversion en caractères
ascii.
Pour t'aider il faudrait que tu en dise plus (en mettant le code en question). Bon courage
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
23 janv. 2006 à 14:01
23 janv. 2006 à 14:01
oui le résultat est correcte et la conversion aussi, j'ai vérifié les valeurs des registres en cas d'overflow.
Pour l'affichage, j'ai une fonction qui décompose le registre AX et affiche ce qu'il y a dedans caractère par caractère et si je fais 5000*5000 il va me mettre le contenu de AX soit 30 784 et non pas 25 000 000 comme prévu
alors pour le code voici la parti de conversion (que je répète 2 fois pour mes 2 nombres)
MOV DX, offset val_ascii1
MOV AH, 0Ah
INT 21h
LEA DI, val_ascii1 ;on charge la variable sur laquelle on travaille
INC DI ;on met le pointeur sur le nombre de caractère contenu (sans le CR)
MOV BX, 0 ;initialisation de BX à 0
MOV BL, [DI] ;on place dans BX la valeur sur laquelle pointe BI
MOV var1, BX ;et on met BX dans var pour pouvoir travailler avec par la suite
ADD DI, var1 ;on ajoute le nombre de caractère à DI pour ce placer entre le dernier caractère et le CR
MOV CX, var1 ;on place var dans CX pour faire une boucle
MOV coeff1, 1 ;initialisation du coefficiant
MOV nb1, 0 ;initialisation de la variable de sortie à 0
convertion:
MOV DX, 0
MOV AX, 0
MOV AL, [DI]
;on compare le code ASCII du caractère traité et celui de 3OH (0) s'il est inférieur
;c'est que ce n'est pas un chiffre
CMP AL, 30H
JB erreur_saisie
;on recompare avec 39H (9)
CMP AL, 39H
JA erreur_saisie
DEC DI
SUB AX, 30h
MUL coeff1 ; AX := AX x coeff1
ADD nb1, AX
MOV AX,10
MUL coeff1
MOV coeff1 ,AX
LOOP convertion
et l'affichage:
affichage: ; affiche AX sous forme de string
PUSH BX
PUSH CX
PUSH DX
MOV BX, 10
MOV CX, 0
decompose_nb:
MOV DX, 0
DIV BX ; AX := AX div 10
INC CX
PUSH DX ; empile le reste
CMP AX, 0
JNE decompose_nb
affiche_digit:
POP AX
MOV DL, 30h
ADD DL, AL
MOV AH, 02H ; fonction d'affichage
INT 21h
LOOP affiche_digit
POP DX
POP CX
POP BX
RET
la multiplication est juste constituée pour le moment d'un MUL tout simple (d'où l'overflow)
Pour l'affichage, j'ai une fonction qui décompose le registre AX et affiche ce qu'il y a dedans caractère par caractère et si je fais 5000*5000 il va me mettre le contenu de AX soit 30 784 et non pas 25 000 000 comme prévu
alors pour le code voici la parti de conversion (que je répète 2 fois pour mes 2 nombres)
MOV DX, offset val_ascii1
MOV AH, 0Ah
INT 21h
LEA DI, val_ascii1 ;on charge la variable sur laquelle on travaille
INC DI ;on met le pointeur sur le nombre de caractère contenu (sans le CR)
MOV BX, 0 ;initialisation de BX à 0
MOV BL, [DI] ;on place dans BX la valeur sur laquelle pointe BI
MOV var1, BX ;et on met BX dans var pour pouvoir travailler avec par la suite
ADD DI, var1 ;on ajoute le nombre de caractère à DI pour ce placer entre le dernier caractère et le CR
MOV CX, var1 ;on place var dans CX pour faire une boucle
MOV coeff1, 1 ;initialisation du coefficiant
MOV nb1, 0 ;initialisation de la variable de sortie à 0
convertion:
MOV DX, 0
MOV AX, 0
MOV AL, [DI]
;on compare le code ASCII du caractère traité et celui de 3OH (0) s'il est inférieur
;c'est que ce n'est pas un chiffre
CMP AL, 30H
JB erreur_saisie
;on recompare avec 39H (9)
CMP AL, 39H
JA erreur_saisie
DEC DI
SUB AX, 30h
MUL coeff1 ; AX := AX x coeff1
ADD nb1, AX
MOV AX,10
MUL coeff1
MOV coeff1 ,AX
LOOP convertion
et l'affichage:
affichage: ; affiche AX sous forme de string
PUSH BX
PUSH CX
PUSH DX
MOV BX, 10
MOV CX, 0
decompose_nb:
MOV DX, 0
DIV BX ; AX := AX div 10
INC CX
PUSH DX ; empile le reste
CMP AX, 0
JNE decompose_nb
affiche_digit:
POP AX
MOV DL, 30h
ADD DL, AL
MOV AH, 02H ; fonction d'affichage
INT 21h
LOOP affiche_digit
POP DX
POP CX
POP BX
RET
la multiplication est juste constituée pour le moment d'un MUL tout simple (d'où l'overflow)
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
23 janv. 2006 à 15:40
23 janv. 2006 à 15:40
J'ai repris ton code, ton calcul 5000x5000 = 25000000 correspond en hexa à:
1388hx1388h = 17D7840h
or tu trouves 30784d soit 7840h
La partie haute du résultat est passée à l'as. Soit dx:ax =7840h, soit dx=0 et ax=7840h
Il semble que celà provient de l'instruction MOV DX,0 qui écrase la partie haute
decompose_nb:
MOV DX, 0
DIV BX ; AX : = AX div 10
INC CX
PUSH DX ; empile le reste
CMP AX, 0
JNE decompose_nb
l'opération div, divise un nombre de 32 bits (16 + 16) dx:ax par un
nombre de 16 bitset met le quotient dans ax et le reste dans dx.
Cependant il y a un pb si
(65536dx+ax)/10 > 65535 car le quotient ne tient pas dans ax et dx
est sensé contenir le reste de la division. En 32 bit le problème se
résout facilement en mettant dx et ax dans eax et en initialisant edx à
zéro. Si on se limite aux registres 16 bits le pb est plus compliqué.
1388hx1388h = 17D7840h
or tu trouves 30784d soit 7840h
La partie haute du résultat est passée à l'as. Soit dx:ax =7840h, soit dx=0 et ax=7840h
Il semble que celà provient de l'instruction MOV DX,0 qui écrase la partie haute
decompose_nb:
MOV DX, 0
DIV BX ; AX : = AX div 10
INC CX
PUSH DX ; empile le reste
CMP AX, 0
JNE decompose_nb
l'opération div, divise un nombre de 32 bits (16 + 16) dx:ax par un
nombre de 16 bitset met le quotient dans ax et le reste dans dx.
Cependant il y a un pb si
(65536dx+ax)/10 > 65535 car le quotient ne tient pas dans ax et dx
est sensé contenir le reste de la division. En 32 bit le problème se
résout facilement en mettant dx et ax dans eax et en initialisant edx à
zéro. Si on se limite aux registres 16 bits le pb est plus compliqué.
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
23 janv. 2006 à 16:06
23 janv. 2006 à 16:06
non DX ne vaut pas 0, si je l'affiche il me met dans le cas présent 3
or 65536*3 + 30784 me donne le bon résultat.
j'avais pensé utilisé l'addition et l'affichage caractère par caractère (je change d'exmple pour que ce soit plus rapide) par exemple si on prend:
7000 * 10 70 000> AX = 4464 et DX = 1
Donc faire
65536
+ 4464
et empiler les résultats successif des additions (6+4 => empile 0 et la retenu passe dans l'opération suivante: 3+6+1 => empile 0 etc etc)
après il suffit de dépiler et d'affiche les caractères
or 65536*3 + 30784 me donne le bon résultat.
j'avais pensé utilisé l'addition et l'affichage caractère par caractère (je change d'exmple pour que ce soit plus rapide) par exemple si on prend:
7000 * 10 70 000> AX = 4464 et DX = 1
Donc faire
65536
+ 4464
et empiler les résultats successif des additions (6+4 => empile 0 et la retenu passe dans l'opération suivante: 3+6+1 => empile 0 etc etc)
après il suffit de dépiler et d'affiche les caractères
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
23 janv. 2006 à 16:31
23 janv. 2006 à 16:31
Quel est le résultat que tu souhaite avoir ? Si c'est 25000000d =
17D7840h alors je ne vois pas comment tu obtient le résultat avec
65536*3+30784. Pour moi celà fait 227392
Le résultat devrait être 65536*381 + 30784, soit en hexa
17Dh*10000h + 7440h
17D7840h alors je ne vois pas comment tu obtient le résultat avec
65536*3+30784. Pour moi celà fait 227392
Le résultat devrait être 65536*381 + 30784, soit en hexa
17Dh*10000h + 7440h
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
23 janv. 2006 à 16:37
23 janv. 2006 à 16:37
lol je viens de me rendre compte que je me suis trompé de calcul, j'ai tellement de papier devant moi que je fais plus gaffe, donc le calcul était 5000*40 = 200 000 et on a bien
AX = 3392
DX = 3
et 65536*3 + 3392 = 200 000 et là c'est juste
AX = 3392
DX = 3
et 65536*3 + 3392 = 200 000 et là c'est juste
piopium
Messages postés
22
Date d'inscription
samedi 14 juin 2003
Statut
Membre
Dernière intervention
24 janvier 2006
24 janv. 2006 à 00:36
24 janv. 2006 à 00:36
et encore merci pour ton aide Nasman
cs_Nasman
Messages postés
202
Date d'inscription
mardi 17 mai 2005
Statut
Membre
Dernière intervention
29 septembre 2008
3
24 janv. 2006 à 08:24
24 janv. 2006 à 08:24
Bonjour,
Je n'ai pas analysé ton dernier commentaire mais j'ai trouvé une solution. La voici :
Le problème réside dans la division de dx:ax par dix puisque dx:ax peut
atteindre 5F592E1h (9999x9999d) et le résultat ne tient pas sur 16 bits.
Le "truc" consiste à diviser dx:ax par 10000d. Ainsi le quotient sera
forcément inférieur à 10000d et le reste aussi (compte tenu que dx:ax
est le produit de deux nombres inférieurs à 10000). Les deux nombres ax
et dx tiendront donc sur 16 bits.
Il ne reste plus qu'à sauvegarder provisoirement dx, mettre ce registre
à zéro et diviser dx:ax par 10d de façon successive en extrayant les
différents restes.
Pour 25000000d tu auras ainsi:
17D7840h/2710h = 9C4h (ax) et dx=0 (nota dx pourrait être non nul mais 25000000 est divisible par 10000)
9C4h/Ah = FAh (reste 0)
FAh/Ah = 19h (reste 0)
19h/Ah = 2h (reste 5)
2h/Ah = 0h (reste 2h)
La décomposition donne donc 2 5 0 0 pour ax. On procède de même pour la sauvegarde de dx (0) pour avoir 0 0 0 0.
Le résultat global est donc 2500 x 10000 + 0000 = 25000000
Je pense que tu pourras coder cet algorithme sans difficulté.
Bonne prog
Je n'ai pas analysé ton dernier commentaire mais j'ai trouvé une solution. La voici :
Le problème réside dans la division de dx:ax par dix puisque dx:ax peut
atteindre 5F592E1h (9999x9999d) et le résultat ne tient pas sur 16 bits.
Le "truc" consiste à diviser dx:ax par 10000d. Ainsi le quotient sera
forcément inférieur à 10000d et le reste aussi (compte tenu que dx:ax
est le produit de deux nombres inférieurs à 10000). Les deux nombres ax
et dx tiendront donc sur 16 bits.
Il ne reste plus qu'à sauvegarder provisoirement dx, mettre ce registre
à zéro et diviser dx:ax par 10d de façon successive en extrayant les
différents restes.
Pour 25000000d tu auras ainsi:
17D7840h/2710h = 9C4h (ax) et dx=0 (nota dx pourrait être non nul mais 25000000 est divisible par 10000)
9C4h/Ah = FAh (reste 0)
FAh/Ah = 19h (reste 0)
19h/Ah = 2h (reste 5)
2h/Ah = 0h (reste 2h)
La décomposition donne donc 2 5 0 0 pour ax. On procède de même pour la sauvegarde de dx (0) pour avoir 0 0 0 0.
Le résultat global est donc 2500 x 10000 + 0000 = 25000000
Je pense que tu pourras coder cet algorithme sans difficulté.
Bonne prog
