Discussion :

[Nadine11]

Salut â Tous

Je débute en PEP8, je voudrais faire des divisions de chiffres sur 19 , sur 3, 7, 451, 31

je sais que je dois utiliser la commande ASRX, mais je ne sais pas comment faire pour toutes ces divisions

2002/19
20/3
3/7
390/451
146/31

Merci

[Obsidian]

Bonjour,

On aurait besoin de savoir quel genre d'architecture est le PEP8. Cela dit, voici déjà la table des instructions :

http://code.google.com/p/pep8-1/wiki/InstructionSet

Pour faire des divisions, tu as deux approches possibles :

• La plus simple et la plus naïve, qui consiste à faire des soustractions successives jusqu'à ce que le reste soit inférieur au diviseur. Le calcul peut être très long si ton nombre est grand, mais ça s'implémente extrêmement facilement ;
• La division euclidienne dont on a l'habitude à l'école, mais transposée au binaire.

« ASR » signifie « Arithmetical Shift to the Right », soit un décalage des bits d'un registre d'au moins une position vers la droite, en conservant le signe (« arithmetical »).

Lorsque tu effectues une division euclidienne, tu alignes le diviseur à gauche du dividende, et tu soustrais les chiffres jusqu'à ce que tu ne puisse plus le faire. À ce stade, tu inscris le nombre de soustractions — donc neuf au maximum —, tu descends le chiffre suivant, tu ré-appliques le même procédé une colonne plus loin et tu continues ainsi jusqu'à ce que tu aies atteint la dernière colonne. C'est le fait d'ajouter un chiffre à droite du résultat à chaque étape qui « pousse » en réalité les autres vers la gauche et leur fait prendre automatiquement un ordre de grandeur.

Comme tu ajoutes un chiffre à chaque fois, en décimal (base 10) tu fais au maximum neuf soustractions. En binaire (base 2), tu feras donc au maximum une soustraction par étape.

Le truc consiste donc à décaler le diviseur vers la gauche et à compter les rotations, jusqu'à ce que le bit de poids fort devienne non nul. Tu as donc n rotations. Ensuite, tu commences avec un registre mis à zéro au départ pour calculer le résultat et tu :

• Décale ce registre d'une position vers la gauche ;
• Vérifie si tu peux soustraire le diviseur au dividende ;
• Si oui, tu le fais et tu ajoute 1 au résultat ;
• Tu décales le diviseur vers la droite ;
• Si n est nul, tu sors ;
• Sinon tu décrémentes n et tu reprends au début.

[Nadine11]

Merci bq pour ta réponse,

Pourrais tu me donner juste un exemple avec 2002/19, pour bien comprendre , je suis toute débutante

Merci

[Obsidian]

Pourrais tu me donner juste un exemple avec 2002/19, pour bien comprendre , je suis toute débutante

Certainement, mais je ne pourrai pas te donner un exemple de programme tout fait car l'algorithme est le même pour tous les nombres.

Le PEP8 utilise des registres de 16 bits, soit 0 à 65536 en binaire naturel non signé. Au dela, il faudra procéder par étapes.

2002 en décimal = 07d2 en hexadécimal = 11111010010 en binaire ;
19 en décimal = 0013 en hexadécimal = 10011 en binaire ;

soit, sur seize bits :

0000011111010010 = 2002
0000000000010011 =   19

Tu alignes le diviseur sur la gauche, donc jusqu'à ce que le premier chiffre non nul occupe la position de poids le plus fort. Or, un bit non nul vaut forcément 1. Tu comptes le nombre de décalages qu'il faut faire pour y parvenir. Ici, c'est onze.

0000011111010010
1001100000000000

Le diviseur ainsi décalé devient donc un nombre à part entière. Pour savoir quand le premier bit à 1 a atteint la dernière position, tu peux le comparer à 32767 avec « CP » et vérifier qu'il est plus grand. Tu peux aussi attendre qu'il sorte naturellement dans le bit C puis le réinjecter juste après avec ROR.

Ensuite, tu fais une boucle dans laquelle tu vérifies si le diviseur est inférieur ou égal au dividende. Si c'est le cas, tu le soustrais et tu ajoutes un 1 au résultat, sinon tu laisses intact le diviseur et tu ajoutes un zéro. Pour « insérer » un nouveau 0 ou 1 à droite de ton résultat, il suffit de le décaler avec ASL. Ceci aura automatiquement pour effet de décaler les bits du résultat vers la gauche et donc d'insérer un zéro à droite. Pour que ce soit un 1, il suffit d'appliquer un « OR 1 » juste après (apparemment, le PEP8 ne propose pas INC ou DEC).

Ta boucle doit faire un tour de plus que tu as fait de décalages à la première étape, ce afin de ramener progressivement le diviseur à sa position initiale (celles des unités). Ca donne :

0000011111010010 : étape 1
1001100000000000 : diviseur plus grand : 0

0000011111010010 : étape 2
0100110000000000 : diviseur plus grand : 0

0000011111010010 : étape 3
0010011000000000 : diviseur plus grand : 0

0000011111010010 : étape 4
0001001100000000 : diviseur plus grand : 0

0000011111010010 : étape 5
0000100110000000 : diviseur plus grand : 0

0000011111010010 : étape 6
0000010011000000 : diviseur plus petit : 1 et soustraction

0000001100010010 : étape 7
0000001001100000 : diviseur plus petit : 1 et soustraction

0000000010110010 : étape 8
0000000100110000 : diviseur plus grand : 0

0000000010110010 : étape 9
0000000010011000 : diviseur plus petit : 1 et soustraction

0000000000011010 : étape 10
0000000001001100 : diviseur plus grand : 0

0000000000011010 : étape 11
0000000000100110 : diviseur plus grand : 0

0000000000011010 : étape 12
0000000000010011 : diviseur plus petit : 1 et soustraction

0000000000000111 : dividende en fin de traitement : 7

Si on lit les chiffres cumulés de haut en bas, on obtient 000001101001, soit 105 en décimal, et le dividende vaut 111, soit 7 en décimal. Si tu poses l'opération sur papier comme tu en as l'habitude, tu t'apercevras que c'est exactement le quotient et le reste de la division de 2002 par 19.

[Nadine11]

Merci beaucoup, C'est vraiment très bien expliqué, Merci encore !!!