Reprise du message précédent :

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

Ex2: ca me fait deja peur, c'est du meme genre que celui ci.
 
Pour le calcul de (1+x)^m, vous utiliserez la formule suivante:
 
(1+x)^m= 1 + x*m + x^2/2!*m(m-1) + x^3/3!*m*(m-1)*(m-2) ...
 
 

prenons le décimal:
 
99 : ça fait deux chiffres décimaux. (on va de 0 à 99)
 
quand on a fait 99*99 on a 9801, quatres chiffres décimaux.
 
donc quand on multiplies deux 8 bits, on a un 16 bits
deux 16 bits, un 32 bits.
deux 32 bits, un 64 bits.
 
le 386 était un "full" 32 bits. il obéissait à cette règle.
 
le 68000 qui était donné pour un être un 16/32 bits (le 16/32 parceque le bus externe de donnée était de 16 bits) obéissait à cette règle, il possédait des registres 32 bits, mais lorsque tu faisait une multiplication il ne pouvait que multiplier les 16 premiers bits des regitres sources (pour que ça rentre dans un registre 32 bits), il n'implémentais par la forme 32*32 => 64 et 64/32 => 32:32 (ce qui est pénalisant au niveau calculatoire, et ce qui est à mes yeux la vraie raison du 16/32 bits)

 
merci

Encore un truc que je ne comprends pas

les deux dernieres instructions concernent le AX, mais le AX quelle valeur? X ou bien (x^2)/2 ?

autre explication (exemple) pour la virugle fixe:
 
mettons on veux multiplier 2.125 par 78.56 en entier en assembleur.
 
on va maintenir ces variables sous la forme en virgule fixe 22:10. (22 bits entière, 10 bits fractionnaire).
 
on va donc maintenir dans un registre la valeur*1024.
on passage de paramètre en C/C++, on va passer dans chaque long int chaque valeur flottante * 1024.
 
on va considérer que le retour de la routine doit aussi sortie la valeur en 22:10.
 
extern long routine_asm(long, long);
 
yo()
{
  float a=2.125;
  float b=78.56;
  float résultat;  
 
  a*=1024;
  b*=1024;
 
  résultat=(float)routine_asm(a,b)/1024;
}
 
donc en asm:  
 
(eax et ebx contiennent les paramètres)
 
routine_asm:
         
        imul ebx
         
        ; on récupére eax*ebx dans edx:eax (signé)
        ; MAIS on avait deux valeurs 22:10
        ; donc on a une valeur 44:20 (44 bits entiers, 20 bits fractionnaires)
        ; et on veux une valeur 22:10 qui sortira sur 32 bits    (donc les 22 bits des 44 bits entiers suplémentaires => exit)
        ; donc:
 
        ; décallage à droite / division (insertion de 0)    
        shr eax,10 ; on a du 12:10 car on a inséré 10 bits à 0
         
        ; décallage à gauche  
        shl edx,22  
        ; on a ramené les 10 "perdus" à la position 22          
 
        ; on ajoute les 10 bits "perdus" (à partir du bit 22)
        ; aux 12:10 d'eax (qui se terminent au bit 21)
 
        or eax,edx  
 
        ; le or fontionne car edx à été décallé de 22 bits sur  
        ; la gauche pour pouvoir être collé devant les 22 bits
        ; significatifs d'eax
 
        ret  
 
on suppose que le compilo C récupère la valeur dans eax
 
       

 
alors on a X dans AX et dans CX
 
on a bine X² dans AX (attention DX est PERDU)

ensuite pour le DIV mil:
 
mil étant un WORD (16 bits)
 
le cpu va diviser le mot 32 bits formé par DX:AX par 1000.
 
alors:
 
si AX,CX,BX contiennent X * 1000
 
le mul CX te donnant alors X*X*1000*1000 dans DX:AX
 
le div mil te donnant alors DX:AX / 1000
 
récupérant alors dans AX X*X*1000 (DX est re-perdu pour le reste de la division)
 
------------------------------------------------
 
par contre il y a une erreur dans le code:
 

 
pour avoir x-(x^2)/2 dans le sens x-((x^2)/2)
 
la division doit être avant la soustraction !!!
 
 
(putain de protection anti-flood)
 
--------------------------------
 
si tu stoques dans tes registres X*1024 et non plus X*1000, le code deviens plus trivial & rapide:
 
pour x-((x^2)/2):
 
mov AX,X
mov BX,AX
mov CX,AX
 
mul CX
 
shr AX,11 ; division par 1024 (shift de 10 )  
          ; puis division par 2 (shift de 1 )
sub BX,AX
 
(idem )

je peux pas jouer avec 1024  car mes feuilles il est bien mis "ne pas oublier toutefois que vous n'allez pas manipuler x lui meme mais un nombre entier mille fois plus grand que x" On pourra certainement une fois que long sera plus loin ds la matiere.
 
il me semblait bien qu'il y avait une erreur ds le code
 
Ca a fait tilte merci
Maintenant je vais essayer de faire le code  
Pour le calcul de (1+x)^m, vous utiliserez la formule suivante:  
 
(1+x)^m= 1 + x*m + x^2/2!*m(m-1) + x^3/3!*m*(m-1)*(m-2) ...

hep: j'ai pas vérifié le reste du code

au fait, j'ai répondu complètement dans le désordre à tes postes, mais si tu veux savoir à quoi servent les registres:
 
comme tu as vu EDX et EAX (DX/DH/DL AX/AX/AL faisant partie de EDX & EAX) sont "liés" (cablés) pour la multiplication et la division.
 
histoiriquement:
 
A : accumulateur (là où on fait les calculs)
B : base (phylosophiquement dédié pour les accès mémoire indexés)
C : compteur (de boucles)
D : index (va avec B pour les accés mémoire tordus)
 
hormis A,D pour les "mul"/"div", C pour les intructions "loop", "rep", c'est plus une question de charte (on aurait presque pu les appeller r0,r1,r2.....
 
donc tu peux considérer, hormis les exemples donnés là (mul/div/loop/rep et quelques autres), tu peux utiliser les registres en vrac comme tu veux....
 
de plus depuis le pentium pro (qui est la base du pentium 2), tous les cpu x86 ont des gruges internes autour des la gestion des registres, qui fait que tu peux ne plus attacher d'importance aux dénominations historiques des registres (hormis les pointeur du code IP, et le pointeur de pile SP qui ont toujours la même fontionnalité quand même ).

et autres tip de base quand on parle perfs: (enfin bon )
échelles de performances à la louche (très très très à la louche)
 
addition/soustraction/comparaison/décalages: 1 cycle
multiplication: 8 cycles
division: 40 cycles  
 
( d'où la recherche de remplaçer les multiplications/divisions, par des déclages si possibles)
 
souvant on considère que la comparaison est -lente-, mais en fait elle est aussi rapide qu'un addition ou une soustraction, puisque une comparison c'est une soustraction (sans mise à jour des registres).
 
ce qui est "lent" dans la comparaison c'est le branchement/saut qui suit dérrière.
 
les accès mémoires sont variables, ça peut aller de 1 cycles à plusieurs milliers si la donné n'est ni dans le cache L1 ou L2.

bjone a écrit a écrit : hep: j'ai pas vérifié le reste du code

Je pense qu'il est correcte
 
Le je suis sur ex2, je pense faire un truc du genre

 
 
Ai je deja fait une erreur?

Le Veilleur a écrit a écrit :   Je pense qu'il est correcte   Le je suis sur ex2, je pense faire un truc du genre Code : MOV  AX,X MOV  BX,one MOV  CX,m MUL M          ; donc ax=x*m ADD BX,AX      ; donc bx=1+x*m SUB AX,X       ; donc ax=x*m-x DIV two        ; donc ax=((x*m)-x)/2 Ce qui fait en fait (x/2)*(m-1) SUB DX,DX DIV mil        ; necessaire ??? SUB DX,DX ADD BX,AX      ;pour obtenir bx=X^2/2! * m * (m-1)     Ai je deja fait une erreur?

 
alors ton X c'est x*1000 oki ?
 
alors ton "one" c'est 1*1000 ? (ça sert à rien de déclarer une variable en passant: mov bx,1000 est valable)
 
ton M est aussi pré-multiplié par 1000 ?
 
donc ton "mul M" (tu voulais ptet mettre mul CX en passant ?)
 
va te donner dans DX:AX = x*1000 * m * 1000
 
si tu veux conserver la "forme" valeur * 1000, il faut faire la division de suite....
 
mov AX,X
mul M
div Mille
 
et là tu as dans DX:AX = x*m*1000
 
ensuite:
 
mov AX,X
mul M
div Mille
add AX,One ; ou add AX,1000 puisque constante  
 
et là tu as dans AX = ( 1 + m*x ) * 1000
 
dans le cas ou tu sortirais de AX lors de l'addition, il fo faire:
 
mov AX,X
mul M
div Mille
add AX,One
adc DX,0    
 
si tu sors de "AX" lors de l'addition, le flags de retenue (Carry) seras mis.
 
si tu veux conserver ta valeur dans DX:AX (et rester en 32 bits le long des calculs), tu dois ajouter la retenue à DX, en faisant adc DX,0
 
adc DX,0 ça fait DX + 0 + la retenue, donc par exemple pour faire une addition 32 bits sur un cpu 16 comme l'est le 80x86:
 
valeur A constitué des WORDS (16bits) A0 et A1 (A1:A0, A0: poids faible)
valeur B constitué de B0 et B1
 
fo faire:
 
mov AX,A0
mov DX,A1
add AX,B0
adc DX,B1
 
on "segmente" l'addition 32bits en deux de 16 bits. (adc récupérant la retenue)
 
 

J'essaye de faire l'ex depuis tantot mais je me perds ds les forumules, le m est de l'ordre de 1/2 (/!\*1000) et le x de l'ordre de 0.5(/!\*1000).
 
jusque que la je comprends bien le raisonment

Mais ensuite ca ressemble au premiere ex mais pas moyen de combiner les deux

je pense faire comme ceci
 

alors dans ce cas:
 
DIV two peut être remplacé par un shift droit (shr ax,1)
 
le SUB DX,DX pour le mettre à 0 n'est pas nécessaire (et un XOR DX,DX est mieux je crois)
 
----
 
attention:
mov AX,CX copie CX dans AX et non l'inverse !!!
 
(en assembleur intel la destination est à gauche et la source à droite, en assembleur motorolla c'est l'inverse, et les outils de dev unix/linux utilisent généralement la convention motorolla au niveau de l'écriture de l'asm)
 
sinon pour obtenir l'opposé d'un registre tu as "neg AX" qui est plus court. (enfin semble )
 
----
 
et pour la division par 8 puis par 1000, conserve DX, et divise par 8000.
 
 
----
 
choses à prendre en compte, les domaines de calculs:
 
Ensuite attention: si ton X peut être négatif, il faut utiliser imul & idiv pour prendre en compte le signe.
(les additions/soustractions/comparaisons sont indépendantes du type signé/non signé des valeurs)
 
comme ton X est multiplié par 1000, dans un registre 16bits tu vas de 0 à 65535 non signé et de -32768 à +32767 en signé, les calculs temporaire impliquant ton X doivent tenir dans -32.768 et 32.767.
 
à la sortie d'un carré ou tu multiplies deux 16 bits, que tu va faire tenir dans un 32 bits (DX:AX), dans un 32 bits tu vas de 0 à 4 milliard en non signé ou de -2 à +2 milliards signés, comme tu est multiplié par 1000*1000, le X "équivalent" aura comme domaine -2000.0 à +2000.0 et des brouettes.
 
(là je peux me planter dans ce que je t'explique)
 
----------
ce qui donne plus:
 
; terme 1
mov AX,X
sar AX,1    ; décallage à droite signé
add AX,1000 ; One
mov t1,AX
 
mov AX,X
imul X      ; attention est à conserver si on veut prendre  
            ; en compte le signe
idiv MoinsHuitMille ; -8000
 
mov t2,AX   ; en espérant que la valeur tienne dans AX
 
etc...
etc...
 
à la sortie d'un mul/imul, tu est en 32 bits, en 1000*1000, il vaux mieux donc tout de suite enchainer par la division par 1000 (+ autres coefs issus des factorielles) afin de maximizer la précision et les problèmes de domaines.
 
attention aussi si après un imul, tu "oublies" vonlontairement DX, tu peux perdre l'information de signe.
 
et d'ailleurs comme après un carré par mul/imul, ton X² est multiplié par 1000*1000, tu sors complètement de AX (qui va de 0 à 65535 ou de -32768 à +32767) ce qui implique que tu DOIS conserver DX qui contient les bits "utiles" de ton calcul de carré.
 
tu peux penser aussi à précalculer le carré si il est utilisé plusieurs fois en amont de la routine.
 
du style:
 
mov AX,X
imul X
mov CarreBas,AX
mov CarreHaut,DX
 
CarreBas et CarreHaut maintiennent ton carré en 1000*1000  
ou sinon:
 
mov AX,X
imul X
idiv Mille
mov CarreX,AX
 
CarreX maintiens le carré en 1000 (et comme dans un 16 bits, le carré doit rester dans -32.768 et 32.767 (enfin 0 & 32.767 ) )
 
...
 
et si tu réutilises plusieures fois le carré tu peux faire
 
mov AX,CarreX
add AX,constanteàlacon
cwd  
idiv constante à la con ; 16 bits
 
tu remarqué "cwd", cette instructions étends le signe de AX dans DX, comme ça IDIV fait un calcul cohérent avec une opérande 16bits.
 
-----------------
 
autre remarque:
 
si ton X peut être négatif, il faut utiliser imul pour le carré ou les puissances.
 
si tu est sûr à un moment donné que ta valeur est positive et qu'elle en *1000 et donc qu'elle tiens dans un registres 16 bits, tu peux faire alors un XOR DX,DX, div truc.

bjone a écrit a écrit : alors dans ce cas:   DIV two peut être remplacé par un shift droit (shr ax,1)   le SUB DX,DX pour le mettre à 0 n'est pas nécessaire (et un XOR DX,DX est mieux je crois)   ----   attention: mov AX,CX copie CX dans AX et non l'inverse !!!   (en assembleur intel la destination est à gauche et la source à droite, en assembleur motorolla c'est l'inverse, et les outils de dev unix/linux utilisent généralement la convention motorolla au niveau de l'écriture de l'asm)   sinon pour obtenir l'opposé d'un registre tu as "neg AX" qui est plus court. (enfin semble )

merci
arf je me suis planté ds la notation, faudra vite que je corrige demain matin avant de le rendre...on a recu l'ennoncé de notre 3e labo, ca va etre la joie,
Faire apparaitre un rond, un triangle, un carrée, coloré en plus et qd on click avec la souris ca fait je ne sais plus quoi

j'ai rajouté des trucs

oki, ton X est toujours positif (j'ai re-regardé le début du post), donc les remarques à propos du problème de signe, tu peux les oublier, mais garde les dans un coin de ta tête c'est toujours utile.....
 
ce qui re-donne en ignorant le signe:
 
; terme 1
mov AX,X
shr AX,1    ; décallage à droite non signé
add AX,1000 ; One
mov t1,AX
 
mov AX,X
mul X      
idiv MoinsHuitMille ; -8000, idiv quand même à cause du -8000
 
mov t2,AX  
 
et les sub DX,DX pour mettre DX à 0 ne servent à rien si tu n'as rien derrière qui le prendra en compte (ça fait des instructions dans le vent)

Un grand merci , je modifie ma feuille et je pense que c'est tout bon

Voila, on a recu un autre projet on en a encore plein.
ici j'essaye de faire afficher une petite phrase.
 
code source

 
le resultat a l'execution
 

 
 
ton Message doit être dans le segment DATA et non dans le code.
 
soit tu fais:
 
.data
 
Message DB .....
 
.code  
 
mov AX,@DATA
mov DS,AX
....
....
 
-----
 
soit tu fais:
 
.data
 
; rien
 
.code
 
push CS
pop  DS
 
....
....
 
....
 
Message DB ......

enfin je pense...
 
tu linkes quoi un .exe ou un .com ?

merci je vais tester ca
Je link un *.exe

Ca marche, pour ecriture un 2e msg je fais comme ce ci
 

 
Y a t il une autre maniere plus adaptée? Et comment puis je faire pour passer a la ligne?

Je n'arrive pas a afficher le second texte help
 

J'ai reussi

Je voudrais tracer des lignes  pour faire une sorte de rectangle, quelq'un a une idée comment faire?

Le but est de pouvoir allumer un pixel en 0,0 et faire un lop jusque 0,300 par exemple pour faire une ligne, ensuite faire les colonne pour obtenir un premier rectangle.
 
mais je galere sur le code, j'ai testé un truc ds le genre

Neeeeeeeeeeeeeeeed  Helllllllllllllllllp Maintenant je suis a l'utilisation de la souris.
 
Voilà l'exe
http://forum.leveilleur.net/LEVEILLEUR.EXE
Source
http://forum.leveilleur.net/a.asm
 
Qd on clique avec la souris ds le rectangle sous une des formes, il doit afficher cette forme ds le grand rectangle 3 et lorsque je click sur une des 3 couleurs, il doit colorier la forme choisi qui se trouve ds le grand rectangle3
 
et si on click ailleurs, cad ailleurs d'un couleur ou d'un rectangle sous les diff formes me prrog doit sortir.