Algorithme Multiplication par Jalousie

[invitee620a714]

Bonjour à tous!

En 1ère année de cycle préparatoire aux grandes écoles, je dois réaliser un algorithme permettant de multiplier 2 nombres par jalousie (technique de multiplication par jalousie : https://fr.wikipedia.org/wiki/Techni..._par_jalousies), puis le retranscrire sous le langage C. Cependant, j'ai déjà beaucoup de mal a écrire mon algorithme, rien ne marche, et encore moins en C...
Si vous pouviez m'aider svp, ne serait ce que pour écrire l'algorithme, j'en serais ravis!
Merci d'avance!
-----

[invitee620a714]

Up svp, j'ai vraiment besoin d'aide..

[jiherve]

Bonjour,
de ce que j'en comprends cela correspond aux algo classiques de multiplication sur petites machines.
voila une multiplication 32x32 bits codage flottant (propriétaire) sur un Atmega en assembleur Atmel

;====================================================================================================================
; 32 bits floating point signed multiplication input in @0,@1 output in @2
;====================================================================================================================
  ; .DEF rRegcLL  = R0 ;   Mul Result byte 0
  ; .DEF rRegcLH  = R1 ;   Mul Result byte 1
  ; .DEF rRegcHL  = R2 ;   Acc result byte 0   
  ; .DEF rRegcHH  = R3 ;   Acc result byte 1   
  ; .DEF rRegxLL  = R4 ;   input a byte 0  
  ; .DEF rRegxLH  = R5 ;   input a byte 1  
  ; .DEF rRegxHL  = R6 ;   input a byte 2  
  ; .DEF rRegxHH  = R7 ;   input a byte 3 
  ; .DEF rRegyLL  = R8  ;  input b byte 0
  ; .DEF rRegyLH  = R9  ;  input b byte 1       
  ; .DEF rRegyHL  = R10 ;  input b byte 2
  ; .DEF rRegyHH  = R11 ;  input b byte 3       
  ; .DEF rRegzLL  = R12 ;  Acc result byte 2 
  ; .DEF rRegzLH  = R13 ;  Acc result byte 3        
  ; .DEF rRegzHL  = R14 ;  Acc result byte 4 
  ; .DEF rRegzHH  = R15 ;  Acc result byte 5   



  
  .MACRO xmult_mem;
    lds  rRegxHH,@0+0;
    lds  rRegxHL,@0+1;
    lds  rRegxLH,@0+2;
    lds  rRegxLL,@0+3;
    lds  rRegyHH,@1+0;
    lds  rRegyHL,@1+1;
    lds  rRegyLH,@1+2;
    lds  rRegyLL,@1+3;
    call mult24;
    sts @2+3,rRegzLH;
    sts @2+2,rRegzHL;
    sts @2+1,rRegzHH;
    sts @2+0,rRegxHH;
  .ENDMACRO
  
;mul 24x24_48:
;xHL,xLH,xLL  * yHL,yLH,yLL 
;zHH|zHL|zLH|zLL|cHH|cHL
;xHL|yHL
;    xHL|yLH
;    xLH|yHL
;        xLH|yLH
;        xHL|yLL
;        xLL|yHL
;            xLL|yLH
;            xLH|yLL
;                xLL|yLL




;
mult24:
    add rRegxHH,rRegyHH;compute exponent
    clr rRegyHH;
    clr rmp4;
    tst rRegxHL;
  brpl mult24_1; x pos nothing to do here
    com rRegxLL;
    com rRegxLH;
    com rRegxHL;
    sec; 
    adc rRegxLL,rRegyHH;
    adc rRegxLH,rRegyHH;
    adc rRegxHL,rRegyHH;
    inc rmp4; sign
  mult24_1:
    tst rRegyHL;
  brpl mult24_2; y pos nothing to do here
    com rRegyLL;
    com rRegyLH;
    com rRegyHL;
    sec; 
    adc rRegyLL,rRegyHH;
    adc rRegyLH,rRegyHH;
    adc rRegyHL,rRegyHH;
    inc rmp4; adjust sign odd = neg even = pos

  mult24_2:

    mul rRegxHL,rRegyHL;(ahl * bhl) 
    movw rRegzHL,rRegcLL;

    mul rRegxLH,rRegyLH;(alh * blh) 
    movw rRegzLL,rRegcLL;

    mul rRegxLL,rRegyLL;(all * bll) 
    movw rRegcHL,rRegcLL;

    mul rRegxHL,rRegyLH;(ahl * blh) 
    add rRegzLH,rRegcLL;
    adc rRegzHL,rRegcLH;
    adc rRegzHH,rRegyHH;

    mul rRegyHL,rRegxLH;(bhl * alh) 
    add rRegzLH,rRegcLL;
    adc rRegzHL,rRegcLH;
    adc rRegzHH,rRegyHH;

    mul rRegxHL,rRegyLL;(ahl * bll) 
    add rRegzLL,rRegcLL;
    adc rRegzLH,rRegcLH;
    adc rRegzHL,rRegyHH;
    adc rRegzHH,rRegyHH;

    mul rRegyHL,rRegxLL;(bhl * all) 
    add rRegzLL,rRegcLL;
    adc rRegzLH,rRegcLH;
    adc rRegzHL,rRegyHH;
    adc rRegzHH,rRegyHH;

    mul rRegxLH,rRegyLL;(alh * bll)
    add rRegcHH,rRegcLL;
    adc rRegzLL,rRegcLH;
    adc rRegzLH,rRegyHH;
    adc rRegzHL,rRegyHH;
    adc rRegzHH,rRegyHH;

    mul rRegyHL,rRegxLL;(bhl * all) 
    add rRegcHH,rRegcLL;
    adc rRegzLL,rRegcLH;
    adc rRegzLH,rRegyHH;
    adc rRegzHL,rRegyHH;
    adc rRegzHH,rRegyHH;
    ;remove redundant bits
    lsl rRegcHL;
    rol rRegcHH;
    rol rRegzLL;
    rol rRegzLH;
    rol rRegzHL;
    rol rRegzHH;
    sbrc rRegzHH,6
  rjmp adjust_exp;
    lsl rRegcHL;
    rol rRegcHH;
    rol rRegzLL;
    rol rRegzLH;
    rol rRegzHL;
    rol rRegzHH;
  adjust_sign:
    sbrs rmp4,0; check sign of result
  ret;
    com rRegzLH;
    com rRegzHL;
    com rRegzHH;
    sec;
    adc rRegzLH,rRegyHH;
    adc rRegzHL,rRegyHH;
    adc rRegzHH,rRegyHH;
  ret;
  adjust_exp:
    inc rRegxHH;
  rjmp adjust_sign;

[Paraboloide_Hyperbolique]

Bonjour,

Je ne pense pas qu'un code assembleur (qui plus est pour un format numérique propriétaire) ne soit très utile pour la demande formulée ici et qui concerne le langage C.

totoooo: avant de vous répondre, il faudrait quelques informations complémentaires:

-) quels nombres devez-vous traiter ? Des entiers, des réels, autres ?
-) Sous quel forme les recevez-vous ? Chiffres dans une chaîne de caractères, entiers (int), flottants (float, double), autres ?

Avez-vous déjà tenté quelque chose de votre coté ? Si oui, quoi ?

[A voir en vidéo sur Futura]

[invitee620a714]

Bonjour, tout d'abord merci pour vos réponses!

Jiherve : Je ne comprends en effet rien du tout au code assembleur...

Paraboloide_Hyperbolique :
Les nombres a multiplier sont 2 entiers. Les instructions quant a la forme reçue ne sont pas donnés, mais je pense que entier (int) est sous entendu.
J'ai tenté plusieurs choses au brouillons, cependant j'ai quelques idées mais je n'arrive a rien mettre en place (d'ailleurs ça m’énerve pas mal parce que habituellement j'y arrive pas trop mal par rapport aux autres élèves)

Merci de prendre de votre temps pour m'aider! )

[pm42]

Tu peux essayer de coder exactement ce qui est décrit : tu crées un tableau à 2 dimension, chaque entrée modélisant une cellule à 2 entrées, avec une struct par exemple. Ou avec 2 tableaux, un pour le haut de la cellule, l'autre pour le bas, plus simple mais moins propre.

Ensuite, tu remplis les cellules haut et bas. Tu peux utiliser la multiplication du C et extraire les 2 chiffres par / 10 et % 10. Pour vraiment simuler, l'idéal serait d'utiliser un tableau avec les tables de multiplication de 0 à 9 mais ça commence à faire lourd.

Puis, une fois ton tableau rempli, la fin de l'algorithme se code facilement.

[invitee620a714]

Bonjour pm42, mercid e ta réponse!

J'ai peur de ne pas bien comprendre ta première phrase... (Tu peux essayer de coder exactement ce qui est décrit : tu crées un tableau à 2 dimension, chaque entrée modélisant une cellule à 2 entrées, avec une struct par exemple. Ou avec 2 tableaux, un pour le haut de la cellule, l'autre pour le bas, plus simple mais moins propre.)
Ensuite les %10 ca 'y ai pensé mais j'ai du mal

[Paraboloide_Hyperbolique]

Ce que veux dire pm42, c'est:

1. Créer une structure contenant 2 entiers.
2. Créer un tableau à deux dimensions avec cette structure.

Pour ce qui est de l'extraction de chiffres à partir de nombres, je conseille de coder une fonction dédiée qui reçoit un entier et renvoie un tableau d'entier contenant les chiffres corresondants.

[invitee620a714]

Qu'est ce qu'une "structure contenant 2 entiers"? juste un tableau avec 2 cases?

[pm42]

Qu'est ce qu'une "structure contenant 2 entiers"? juste un tableau avec 2 cases?

Pour faire un exercice de programmation en C, tu as besoin au moins de :
- connaitre le langage
- à défaut, être capable d'utiliser un moteur de recherche et de taper "langage C structure" par exemple

Poser question sur question sans faire d'effort sur un forum n'est pas un mécanisme d'apprentissage.

[invitee620a714]

Erf si tu savais :

Je fais de mon mieux :/

[polo974]

tout d'abord:
http://forums.futura-sciences.com/pr...ces-forum.html

as-tu compris la méthode décrite par wikipedia ?
as-tu fais à la main une multiplication avec d'autres nombres (voir en bas autre exemple plus complexe) ?
le résultat est-il juste ?

si non, pose les questions sur la méthode même.

si oui aux 3 question précédentes, tu dois pouvoir décrire en français la procédure
(montre-nous ce que tu as).
et pose toi (et éventuellement nous) des questions.

puis avec des for et des if... (ou des "pour chaque ... en commençant par ..." et des "si ... alors ... sinon ..." )
(montre-nous ce que tu as).
et pose toi (et éventuellement nous) des questions.

puis en C (il s'agit de faire un calcul en décimal, digit par digit avec les reports de retenues, le résultat sera donc une suite de digits à afficher).
(montre-nous ce que tu as).
et pose toi (et éventuellement nous) des questions.

bref, on veux bien t'aider sur une question particulière, mais pour faire ton exo à ta place, c'est payant et c'est très cher ! ! !