Bonjour
 
Je suis tres nul en assembleur, ca fait pas lgtps que l'on a commencé ca en cours,
J'ai deux prog a realiser.
Le premier c'est:
 
[quote]Pour une donnée representant un nombre reel positif, on vous demande, de rediger un programme qui calcul approximativement le logarithme d'un nombre
Le nombre peut etre quelconque (0.040=<X=<0.5)
 
On se limite aux 6 premiers termes du dev de Mac Laurin
 
ln(x+1)=X - x²/2! + 2(x*x*x)/3! - 6(x*x*x*x)/4! et etc...
 
Voici le programme que j'ai fait pour ca
 

 
Ca compile, ca link bien, mais a l'execution j'ai "Dépassement de divition "
 
Vous avez une idée? merci.

Quelle idée de forcer les gens à apprendre l'asm  

Oui je sais mais j'ai pas le choix, c'est pas moi qui decide de mes cours

ITM a écrit a écrit : Quelle idée de forcer les gens à apprendre l'asm

C'est une bonne idée.
Ok, ca n'a l'air de servir a rien, comme ca.
Ok, tu n'en feras probablement plus apres ces 2/3 cours.
Ok, tu te limites a quelques notions
 
N'empeche que j'ai eu droit a quelques tps et cours avant d'aborder le C, ben ca simplifie énormément. Pas besoin d'expliquer les pointeurs et les opérations associées, vu qu'on connait déja leur fonctionnement.
 
Par contre pour répondre a la question initiale, je ne sais pas. J'ai bien evidemment tout oublié
Essaye voir de regarder les flags dans un debugger a tout hasard, pour savoir au moins ou est l'erreur.

Apprendre l'assembleur est bien pratique... Quand je voyais en IUT les gus en chier pour percuter la notion de pointeur en C, je me marrais bien...
J'avais 2 ans d'asm Motorola dans les dents, et ça m'a permis de comprendre bien des choses !
Enfin bref !
 
Pour apporter un début de solution au problème :
 
Ce genre de truc est à éviter :

 
En effet : tu effectues une multiplication de 2 opérandes 16 bits, ce qui fait que ton résultat sera sur 32 bits, et sera donc stocké dans 2 registres : DX pour la partie forte et AX pour la partie faible.
 
Tu dois donc tenir compte dans ta division que l'opérande est sur 4 octets.
 
Je peux rien tester, vu que j'ai pas d'assembleur sous la main. Je vais m'installer nasm32 (coucou Lorill )

merci
des reponses
 
petites modif au prog
 

 
J'ai plus de depassement de division, mais je ne sais pas si le resultat est correcte

si tu veux je le fais en C et apres je t'envoie le resulat de mon gcc -S  

En C je sais aussi le faire
 
Mais maitnenant je me demande pq il m'arrive rien, positif, ou pas? Comment savoir si le resultat est correcte?

J'ai commencé par l'ASM 68k (si on exepte le basic) avant de commencer le C. J'avoue aussi que c'est excellent pour assimiler rapidement les notions de bases (pointers &Cie).
Seulement, j'ai oublié tellement de choses dessus!
Ce qui est sur, c'est que je ne recommencerai jamais à me lancer la dedans!

j'ai fait un td lmi2 et ds view cpu j'ia un beau divide by 0

personne ne maitrise ce langage archaique?

pour ma part, assembleur 8086 au graduat il y a une dizaine d'années (purée déjà!).  J'en ai fait un peu plus quand j'ai fait un programme de rip mais c'était du traitement de chaînes.  C'était gai, ça ressemble à une mécanique délicate à mettre au point, j'ai beaucoup aimé, d'autant que le programme a gagné énormément en performances (+400%)
 
Mais question arithmétique... non désolé

 
 
Je vais mettre sur ma copie "Projet impossible : meme ceux de hfr ne savent pas utiliser un tel langage"

La version d'un pote
 

 
Mais je comprends pas bien le CX, car cx prend la valeur de x, on multiplie CX par X et ensuite il va se stocker ou cx? Car on en parle plus apres Je comprends pas trop ca, le reste du prog je comprends.

si je me rappelle bien mes cours, chaque opération voit son résultat stocké dans DX:AX (comme l'a indiqué Harko plus haut).
 
Au fait c'est l'assembleur 8086 16 bits que tu emploies?  J'assume que tu sais que chaque registre a un rôle générique + un rôle particulier dans certaines opérations?

ben mul ecrit le resultat de l'operaton dans un des registres, mais je sais plus lequel...
 
ax et dx si besoin est je crois

alors deux remarques:
 
1) est-tu bridé au jeu d'instruction du 286 ?
tu peux très bien utiliser des instructions 32 bits pour éviter divers débordements. (pour les remarques ultérieures c'est même chaudement recommandé)
 
2) diviser par 2,4,8, une puissance de 2: 2^N reviens à décaler vers la droite de N rangs (gain de temps et évite des emmerdes)
 
3) tu est (ou tu dois travailler) en virgule fixe:
 
ton X qui peut être entre 0.040=<X=<0.5, est pré-multiplié par 1000 c'est ça ? vue le:
 

 
alors en virgule fixe, vo mieux pré-multiplier par une puissance de 2 ( because remarque 2) )
 
donc mettons que ton WORD (16bits) X soit prémultiplé par 1024, dans une multiplication du style: X²
 
tu auras: X*1024 * X*1024 => X*X * 1024²
 
il te faudra donc ramener ta valeur sous une forme X*X * 1024, en shiftant de 10 bits vers la droite.
 
 

Je ne pense pas que l'on soit bridé aux instructions du 286, On nous a rien dit, pour compiler on utilise tasm.
 
Ce que je ne comprends pas c'est ici
 

 
On met la valeur de X (cad 500) ds AX -> Ok
On met la valeur de X (cad 500) ds BX -> Ok
On met la valeur de X (cad 500) ds CX -> Ok
Ensuite on multiplie par CX (cad par 500) -> Mais on multiplie quoi par 500 ? AX? BX? CX ?
Car ensuite on disie par 1000, mais que divisis t on? AX je crois.
 
edit:Au fait merci de m'aider   , j'ai encore un ex qui m'attends demain

donc pour plus de précision dans ce que je t'ai dit:
je suppose que tu est avec TASM ou un truc du genre:
 
tu rajoutes ".386" dans la zone des .model / .stack.
 
là tu auras accès au jeu d'instruction 32 bits (même si tu est en mode réel, mais je pense pas que tu saches ce que c'est).
 
ax deviens donc EAX, bx EBX etc etc....
 
mul/imul:
 
par exemple:  
 
mul ebx
 
multiplie eax par ebx, donc a 32bits*32bits => ce qui donne 64 bits
 
les 64bits sont stoqués dans EDX:EAX (edx poids fort, eax poids faible)
 
idem:
 
div ebx
 
fait une division 64bits/32bits => 32 bits dans le reste, 32 bits dans le quotient
 
divise symétriquement EDX:EAX par EBX, après EAX contiens le quotient, EDX le reste.

j'approuve bjone à 100%, en te suggérant également une petite optimisation :
 
remplace
 
SUB DX,DX
 
par
 
XOR DX,DX
 
quelques cycles de gagné, et tu pourras faire le beau devant ton prof

bon, j'ai retrouvé mon poly
 

 
voila.

Mais je pense pas que je peux faire ca, car on ne l'a pas vu au cours, Je ne pense pas que le prof appréciera
 
J'ai l'impression de ne pas comprendre les roles et caracterisques propre a chacun des registres; AX,BX,CX,DX

Ca serait donc ca, mais alors pq ne pas faire  
 
MOV AX,X
MUL X
 
Ou encore  
MOV AX
MUL AX
 
On est obligé de prendre CX?

 
ben en fait c'est surtout savoir ce qui est utilisée par telle opérande. Mais normalement vous l'avez vu en cours, non ?

ben ton mul cx fait en fait ax = ax*cx
donc si tu as deja quelque chose dans ax, tu vas l'ecraser avec ton mov

Je ne me souviens plus tres bien ce que je faisais aux cours qd on a vu ca On un syllabus mais y a pas grand chose dedans, j'ai acheter le livre de microp app "savoir developper en assembleur" mais ca me semble bizzard ce livre, C'est pas trop.

Le Veilleur a écrit a écrit :   Je ne me souviens plus tres bien ce que je faisais aux cours qd on a vu ca On un syllabus mais y a pas grand chose dedans, j'ai acheter le livre de microp app "savoir developper en assembleur" mais ca me semble bizzard ce livre, C'est pas trop.

ben microapp c'est un editeur a éviter a tout prix, avec macmillan...

le .386 ne marchera qu'avec TASM32.  Et je doute qu'ils l'utilisent.  Les mécanismes inhérents au 80386 ne s'appliquent pas au 8086.  Je pense que c'est un fait exprès et que leur prof s'attend à ce que les élèves exploitent le 8086.  C'est cependant à vérifier avec le prof

exemple typique de calcul de pente d'une ligne à traçer:
 
tu traçes la ligne pas par pas sur le X, à la position [X,Y].
 
imaginons dans eax, tu ayes le delta sur Y, dans ebx le delta sur X (les deux positifs):
 
ça te donne un truc comme ça:
 
shl eax,10   ; on décalle de 10 bits => multiplication par 1024, on a une précision fractionnaire
 
xor edx,edx  ; edx mis à 0 à cause du fait qu'on va faire une division 64bits/32bits
 
div ebx
 
dans eax, on a la pente*1024
 
donc par tour de boucle on va faire:
 
pour chaque X
   temporaire <- Y/1024      ;  == Y>>10 => shr ...,10
   traçer à position X,temporaire
   Y <- Y + pente
fin pour
 
donc grosso modo en asm:
 
sachant que dans eax on a la pente, dans ebx: X (dumoins le delta X)
 
mov edx,eax ; copie de eax dans edx because eax sera notre temporaire
 
xor ecx,ecx ; on désigne comme Y
 
boucle:
  mov eax,ecx ; temp <- Y
  shr eax,10  ; temp <- temp / 1024
  .... traçer à position X,eax
  add ecx,edx , Y <- Y + pente
  dec ebx
  jnz boucle
 
-- ceci pour que tu comprennes bien la virgule fixe

oki pour la multiplication
 

 
Donc ax=ax*Cx  , je comprends
Je suppose que div, ca fait ax=ax/mil
mais alors le sub je ne comprends pas, car bx=x et ax=(ax*cx)/mil
 
A moins que le sub place la valeur ds le BX ?
Donc mul ca la placerait ds AX et SUB ds BX?

+1  g un prof qui déconseillait microapp parce qu'il y avait des fautes de traduction, mais plus grave, d'implémentation (dasn un bouquin d'asm en plus).  Et personnellement, je les trouve trop grand public.  C'est peut être leur plus gros défaut.

Drasche a écrit a écrit : le .386 ne marchera qu'avec TASM32.  Et je doute qu'ils l'utilisent.  Les mécanismes inhérents au 80386 ne s'appliquent pas au 8086.  Je pense que c'est un fait exprès et que leur prof s'attend à ce que les élèves exploitent le 8086.  C'est cependant à vérifier avec le prof

 
 
 
je faisais des routines 32 bits en BTS sous BC 3.1 (dos en mode réel)

autant pour moi

Vous avez une idée pour ca?
Surtout que div par deux encore en dessus, si on l'avait fait avant le SUB ok, mais la on le fait apres

merci, Tu sors ca d'ou? Un prog? du net? Car ca a l'air bien fait.

 
nan, un poly fait par des eleves, et effectivement, y'a la description de toutes les instructions, c'est bien pratique. Mais je sais pas si y'a l'equivalent sur le net

lorill a écrit a écrit :     nan, un poly fait par des eleves, et effectivement, y'a la description de toutes les instructions, c'est bien pratique. Mais je sais pas si y'a l'equivalent sur le net

Tu pourrais me dir le ADD aussi stp

 
   
 
mul CL, CL étant 8 bits, on a AX = AL * CL
mul CX, CX étant 16 bits, on a DX:AX (32 bits) = AX * CX
mul ECX, ECX étant 32 bits, on EDX:EAX (64 bits) = EAX * ECX
 
idem:
 
div CL, fait AX / CL => AL (quotient), AH (reste)
div CX, fait DX:AX (32bits) / CX => AX (quotient) DX (reste)
div ECX, fait EDX:EAX / ECX => EAX (quotient) EDX (reste)
 
http://www.geocities.com/SiliconVa [...] l1003.html
mul ECX

bjone a écrit a écrit :           mul CL, CL étant 8 bits, on a AX = AL * CL mul CX, CX étant 16 bits, on a DX:AX (32 bits) = AX * CX mul ECX, ECX étant 32 bits, on EDX:EAX (64 bits) = EAX * ECX   idem:   div CL, fait AX / CL => AL (quotient), AH (reste) div CX, fait DX:AX (32bits) / CX => AX (quotient) DX (reste) div ECX, fait EDX:EAX / ECX => EAX (quotient) EDX (reste)   http://www.geocities.com/SiliconVa [...] l1003.html mul ECX

j'imprime tout ca