Quand je prends 4 bits c'est à titre d'exemple, c'est plus simple.
a+
Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter
Mul
Quand je prends 4 bits c'est à titre d'exemple, c'est plus simple.
a+
ça ne change rien...l'algo reste le même.
Mul
Tq B pair
Decal A gauche
Decal B droite
Fin tq
Si B impair
A=A+Ainit
decal B droite
Cela ne fonctionne pas ci-dessous le contre exemple
A | B
______
7 | 10
14 | 5
21 | 4
42 | 2
84 | 1
91 | 0
J'ai également essayé en faisant B=B-1 (lorsque B impair) mais cela ne fonctionne pas non plus.
a+
Si tu décales vers la droite tes bits, ils perdent aussi leur poids et pourtant la multiplication (rotation) a toujours le même poids : 2 ...
et puis ce n'est pas tout...
ROR et MUL
un indice ??
Je t'avoue que je sèche, là...
a+
C'est pas les algos qui manquent, un relativement simple et adapté à ce que tu sais faire : SHL/SHR donc 35 * 19 = 665
Tu as compris le problème avec le traitement des "poids" impairs...
Le multiplicande et le multiplicateur sont placés respectivement en A et en B. Dans la colonne A, on inscrit la partie entière des quotients successifs de la division par 2 jusqu'à l'unité. Dans la colonne B, on inscrit les produits successifs de la multiplication par 2. Dans la colonne C on reporte les nombres de B qui sont associés à un nombre impair en A. La somme des nombres de la colonne C est le produit de 35 × 19, soit 665.
Code : Sélectionner tout - Visualiser dans une fenêtre à part
2
3
4
5
6
7
8
9A B C 35 19 19 17 38 38 8 76 -- 4 152 -- 2 304 -- 1 608 608 665
Mul
Celà a l'air de fonctionner je vais le tester ce soir avec des exemples et je te dirais si celà fonctionne.
Merci.
Mais tu fais quoi comme taf, tu programmes en assembleur ?
a+
chut...
Mul
Voici l'algo qui irai avec ton exemple
Tq B pair
DCAL A gauche
DCAL B droite
Ftq
Si B impair
C=C+A
DCAL A gauche
DCAL B droite
Ftq
Mon pb maintenant est que je n'ai que 2 registres où je puisent stocker des valeurs AC et RDO.
Donc je ne crois pas que celà fonctionne avec ma machine.
Il me semble, mais avec l'age...
Es-tu sûr d'être obligé de stocker, tu ne peux pas tester / addition si LSBit 1 :
En évitant les boucles et en déroulant le code comme d'hab.
Si AND A 00 01 hex -> ADD (C) A
SHL B 1
SHR A 1
Si AND A 00 01 hex -> ADD (C) A
SHL B 1
SHR A 1
etc...
Pas moyen d'économiser du registre ?
Pas de pile disponible dans laquelle tu pourrais push/pop C ?
Pas de MAJs de flag disponibles non plus ?
N'importe comment si le problème à été posé c'est que c'est possible
De plus, croire qu'il existe une solution c'est être assuré de trouver tôt ou tard (si si).
je ne sais pas ci cela t´aideras
ROR
move les bits d'operando1 une position vers la droite, y compris le carry.
Dans le bit 7 on chargera ce que nous avons en C.
En C on chargera le bit 0.
1.- Hacemos ROR 27
-Si hay carry 1001 1101
-Si NO hay carry 0001 1101
ror-> rota a la droite -> met le carry x la gauche
2.- Hacemos ROL 27
-Si hay carry 0111 0101
-Si NO hay carry 0111 0100
rol-> rota a la gauche -> met le carry x la droite
C'est peut-être une très bonne solution si cela ne t'oblige pas à rajouter des tests supplémentaires.
Pas 0
multiplication de 1 x 1 byte
donc le résultat sera de 2 bytes
donc dans un registre nous chargeons le multiplicateur
et dans un autre le multipliant comme le multipliant nous allons roté
en déplaçant bit à bit vers la gauche nous avons besoin d'avoir un autre registre à 0.
Par conséquent nous aurons en commençant
Multiplicando = 00000000 01111011 (dos bytes, 16 bits, dos registros)
Multiplicador = 10100101
Resultado = 00000000 00000000
Ils seront maintenant 8 rondes, parce qu'on fait 8 multiplications (8 x 8 bits bits)
Ronda 1
C'est une multiplication, donc nous multipliions normalement :
Code:
01111011 7B Multiplicando deux registres
x 10100101 A5 MULTIPLICADOR
-----------------
0000000001111011
Dans cette ronde nous avons multiplié le MULTIPLICADOR par 1,
puisque c'est le bit qui reste plus à droite du multiplicateur
égal que en décimale de toute la vie
La meilleure façon de le savoir est de roté le MULTIPLICADOR à droite
avec l'instruction LSR alors aurons que le bit0 de du MULTIPLICADOR
passe au carry et dans le bit7 du MULTIPLICADOR on place un 0
par conséquent le MULTIPLICADOR reste ainsi 01010010 - Carry - 1.
comme c´est 1 il faut ajouter, parce que nous ajoutons le multipliant au résultat.
Mais tu ne dois pas directement ajouter parce que tu sais déjà qu'il est un 1
pour cela tu utilises une instruction
de telle sorte que si cést un 1 tu somme et si c´est un 0 non
MULTIPLICADOR = 01010010
puisque nous l'avons roté à droite, il se sont déplacé tout les bits une position
Multiplicando= 00000000 01111011
Resulta .....= 00000000 00000000
Sumamos Multiplicando + Resultado:
Nuevo resultado = 00000000 01111011
Avant de sortir de cette ronde on rote le Multiplicando à gauche pour avoir
ce qui est déjà préparé pour la ronde suivante
et par conséquent le Multiplicando maintenant
Multiplicando= 00000000 11110110
Pour roté le Multiplicando un bit à gauche
au byte lsb du Multiplicando et un rol au byte msb on obtient puisque
byte bas LSB = 01111011
byte haut MSB = 00000000
- LSL byte bas est roté à gauche le registre avec ce que le bit7 passe au carry
et dans le bit0 est placé un 0
par conséquent il reste le byte bas après le LSL 11110110 et dans le carry
nous aurons le 0 qui etait avant dans le bit 7, par conséquent Carry=0
- ROL byte haut c´est roté à gauche le registre le bit7 passe au carry
(qu'il nous donne égal où il va)
et dans le bit0 se met el bit que etait dans le carry
qui est un 0 parce que carry prend la valeur du bit7 du byte bajo en lui faisant le LSL
par conséquent en enchaînant ces deux instructions tu obtiens que le bit7
du byte bas passe au bit0 du haut byte.
Si tu prends le multiplicando comme 2 bytes (16 bits) tu passe le bit7 au bit8.
Il reste par conséquent le haut byte après le ROL 00000000 Et
le multiplicando complet reste 00000000.11110110 ce que lons cherche
Ronda 2
Code:
0000000011110110 ->tras ronda anterior
x 01010010 ->tras ronda anterior
-----------------
0000000001111011
0000000000000000 +
-----------------
0000000001111011
Nous faisons le même processus : on rote le multipliant à droite -> 00101001 C-> 0
le bit0 est passé au carry
s'il est zéro il ne faut pas ajouter rien
il foudrais lui ajouter 00000000.00000000 puisqu'il est de multiplier par 0
et il est la même chose que n'ajouter rien par conséquent nous ne faisons rien
avant de sortir on rote de nouveau le multipliant à gauche avec le ROL LSL
MULTIPLICADOR = 00101001 puisque ont la roté a la droite
ont a deplacé tout les bit a droite une posicion
Multiplicando= 0000000 111101100
Résultat est encore ce dernier nous n'avons pas ajouté 00000000.01111011
Ronda 3
Code:
0000000111101100 ->tras ronda anterior
x 00101001 ->tras ronda anterior
----------------
0000000001111011
0000000000000000
0000000111101100 +
-----------------
0000001001100111
Nous faisons le même processus : on rote le multipliant à droite -> 00010100 C-> 1 el bit0
et nous voyons qu'il est 1
il est passé au carry donc nous le contrôlions avec les ins brcc ou brcs
par conséquent il faut ajouter le multipliant comme ce plus le résultat accumulé
Multiplicando 00000001 11101100
Resultat .....00000000 01111011
on calcule
Nouveau resultat 00000010 01100111
avant de sortir on rote de nouveau le multipliant à gauche avec le ROL LSL
Multiplicando 00000011 11011000
MULTIPLICADOR 00010100 puisque ont la roté a la droite
ont a deplacé tout les bit a droite une posicion
Ronda 4
Code:
0000001111011000 ->tras ronda anterior
x 00010100 ->tras ronda anterior
----------------
0000000001111011
0000000000000000
0000000111101100
0000000000000000 +
----------------
0000001001100111
Nous faisons le même processus : on rote le multipliant à droite
-> 00001010 C-> 0 le bit0 est passé au carry
s'il est zéro il ne faut pas ajouter rien
Multiplicando 00000111 10110000
MULTIPLICADOR 00001010
resultat na pas varié 00000010 01100111
Ronda 5
Code:
0000011110110000 ->tras ronda anterior
x 00001010 ->tras ronda anterior
----------------
0000000001111011
0000000000000000
0000000111101100
0000000000000000
0000000000000000 +
----------------
0000001001100111
Nous faisons le même processus : on rote le multipliant à droite
-> 00000101 C-> 0 le bit0 est passé au carry
s'il est zéro il ne faut pas ajouter rien
Multiplicando 00001111 01100000
MULTIPLICADOR 00000101 puisque ont la roté a la droite
resultat na pas varié 00000010 01100111
Ronda 6
Code:
0000111101100000 ->tras ronda anterior
x 00000101 ->tras ronda anterior
----------------
0000000001111011
0000000000000000
0000000111101100
0000000000000000
0000000000000000
0000111101100000 +
----------------
0001000111000111
Nous faisons le même processus : on rote le multipliant à droite
-> 00000010 C-> 1
et nous voyons qu'il est 1
il est passé au carry donc nous le contrôlions avec les ins brcc ou brcs
par conséquent il faut ajouter le multipliant comme ce plus le résultat accumulé
Multiplicando 00001111 01100000
Resultat 00000010 01100111
on calcule
Nouveau resultat 00010001 11000111
avant de sortir on rote de nouveau le multipliant à gauche avec le ROL LSL
Multiplicando 00011110 11000000
MULTIPLICADOR 00000010 puisque ont la roté a la droite
ont a deplacé tout les bit a droite une posicion
total serait 8 rondes
Toutes ces rondes peuvent être résumées une boucle de cette manière plus ou moins
Code :
Inicializon registres (ce qui est qui serait le pas 0)
en en tenant compte du fait que nous devons en outre habiliter un registre
comme comptable de rondes
Boucle :
Rotamos MULTIPLICADOR à droite
Contrôlons carry -
Si C=1 nous sautons alors ajouter en multipliant + résultat -
Si C=0 nous sautons roté en multipliant
Saut d'ajouter en multipliant + résultat et suit
Saut de roté à gauche le multipliant
Decrementamos comptable de rondes avons terminé ?
si nous n'avons pas terminé nous suivons dans la boucle
Si nous avons terminé FIN
jai fait mon possible pour faire la traducion de la meilleure facon possible
voila je te montre un exemple avec un micro avr
Code : Sélectionner tout - Visualiser dans une fenêtre à part
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
Humm... tu n'as pas oublié quelque chose (d'assez limitatif) dans le problème
PS: Quand tu édites tes message, une option en haut de page te permet d'effacer...
Salut !
On suppose que le nombre est dans le registre A et que les deux instructions shift
procèdent logiquement au sens où c'est un 0 qui est injecté dans le premier latch
selon le sens du shift : 0->b0->b1->b2->b3 ou 0->b3->b2->b1->b0
Ne connaissant pas à priori les mouvements possibles entre les registres, l'idée
est la suivante :
ROL
B = A ; sauvegarde du nombre
A >> ; shift à droite trois fois pour placer le b3 en b0
A >>
A >>
C = A ; sauvegarde du b3
A = B ; rappel du nombre
A << ; shift à gauche : le b3 disparait
B = A ; sauvegarde du resultat
A = C ; rappel du b3
A + B ; ajouté au autres bits pour réaliser le ROL
ROR
B = A ; sauvegarde du nombre
A << ; shift à gauche trois fois pour placer le b0 en b3
A <<
A <<
C = A ; sauvegarde du b0
A = B ; rappel du nombre
A >> ; shift à droite : le b0 disparait
B = A ; sauvegarde du résultat
A = C ; rappel du b0
A + B ; ajouté aux autres bits pour réaliser le ROR
Si le shift injecte un 1 il faut faire un NOT sur le nombre à l'entrée de processus
et à la fin.
Si le shift à droite préserve le bit de poids fort (arthmétique) alors là...
A plus !
Juste histoire de dire qu'un post c'est aussi un contexte :
Comment il fait le gars avec sa machine... pour ne pas utiliser des ressources qu'il n'a pas et pour faire tous ces tests. $
C'est donc le problème des deux derniers posts.
Sinon, une bête addition et hop basta problemo
Vous avez un bloqueur de publicités installé.
Le Club Developpez.com n'affiche que des publicités IT, discrètes et non intrusives.
Afin que nous puissions continuer à vous fournir gratuitement du contenu de qualité, merci de nous soutenir en désactivant votre bloqueur de publicités sur Developpez.com.
Répondre avec citation
Partager