Multiplication/divisions sur 64bits pour registre 32bits

0/5 (7 avis)

Snippet vu 19 404 fois - Téléchargée 30 fois

Commenter

Contenu du snippet

Voici deux petites fonctions permettant d'effectuer rapidement des multiplications et des divisions sur des registres 32 bits ....

J'ai développé ce code pour un Microcontroleur type H8 (Hitachi)

A noter que si vous utiliser un processeur avec des registre 64Bits, vous pourrez faire des multis sur 64Bits.... à l'inverse, si vous n'avez qu'un µC 8Bits, rien ne vous empeche d'etendre a chose sur 16 bits (juste la variable d'occurence à changer)

A noter :

_L_reg32_1 & _H_reg32_1
_L_reg32_2 & _H_reg32_2

sont des variables 32 bits L(Low) H(High)
// la c'est pour les nouveaux, pour les pros c'etait evident ...

Source / Exemple : 


;****************************************************;
;* Multiplication avec expansion en 64 bits         *;
;*                                                  *;
;* Entrées : er2 :: nombre 1 (32 bits)              *;
;*           er3 :: nombre 2 (32 bits)              *;
;*                                                  *;
;* Sorties : 	er2 :: 32 bits bas                  	*;
;*		er6 :: 32 bits haut                 					*;
;****************************************************;
mulxu.64:
	sub.l	er4,er4
	mov.l	er4,er5
	mov.l	er4,er6

	mov.b	#32,r4l		; charge le nombre de bits de multiplication.	
	andc	#254,ccr
bou64_1:
	rotxr.l	er2			;
	bcc	suite64_1		;
	add.l	er3,er5		;	er5 : H_reg
suite64_1:				;	er6 : L_reg
	rotxr.l	er5			;
	rotxr.l	er6			;
	dec.b	r4l				;
	bne	bou64_1			;
fin64_1:
	mov.l	er6,@_L_reg32_1	;
	mov.l	er5,@_H_reg32_1	;

	mov.l	er6,er2 ;
	mov.l	er5,er6	;
	rts

	.align 1
;****************************************************;
;*         Division 64 Bits / 32 Bits           (2) *;
;*                                                  *;
;* Entrées : @_H_reg32_1 :: nombre 1 (32 bits)      *;
;*           @_L_reg32_1 :: nombre 2 (32 bits)      *;
;*           @_L_reg32_2 :: diviseur (32 bits)      *;
;*                                                  *;
;* Sorties : 	er1 :: 32 bits haut                 *;
;****************************************************;
divxu.64:
	sub.l	er5,er5
	mov.l	@_L_reg32_2,er4	;
	mov.l	@_H_reg32_1,er3 ;
	mov.l	@_L_reg32_1,er2 ;

	cmp.l	#0,er4		; Verifie si le diviseur est à 0.
	beq	div64_6			;
	mov.b	#33,r6l		; charge le nombre de bits de multiplication.	
	andc	#254,ccr
div64_1:	
	bcs	div64_3			;
	cmp.l	er4,er3		;
	bhi	div64_3			;
	beq	div64_3			;
div64_2:
	shll.l	er5			;
	jmp	div64_4			;
div64_3:
	orc	#1,ccr			; Met la carry à 1
	rotxl.l	er5			;
	sub.l	er4,er3		;
div64_4:
	shll.l	er2			;
	rotxl.l	er3			;
	dec.b	r6l				;
	bne	div64_1			;
div64_6:
	mov.l	er5,@_L_reg32_1 ;
	mov.l	er5,@_L_reg32_2 ;
	mov.l	er5,er2					;
	rts

Conclusion :


Pour la multiplication, je l'ai repris d'un livre de Maths App.
Pour la division, Je me suis creusé les meninges (en fait j'ai pas trouvé d'infos)

J'ai aussi fait une extraction de racine carré sur un registre 32 bits, mais très lent... Si l'un de vous à des algo sur le sujet je suis preneur (Pas de virgule flottante/Approximation_succesive, ca m'oblige à recasser tout mon code)... Et oui je suis feignant

A voir également

Ajouter un commentaire Commentaires
jod1019 Messages postés 6 Date d'inscription mercredi 6 février 2008 Statut Membre Dernière intervention 3 mai 2012
10 juil. 2008 à 00:08
Merci cela me permettra de faire mon projet
frobinet Messages postés 64 Date d'inscription jeudi 19 décembre 2002 Statut Membre Dernière intervention 15 décembre 2006
18 nov. 2003 à 09:59
Bonjour,

Je suis aussi interressé par des routines pour calculer sans le coprocesseur. Mon adresse mail est robinet.gemic@wanadoo.fr
merci d'avance !
jc_amacher Messages postés 1 Date d'inscription jeudi 23 octobre 2003 Statut Membre Dernière intervention 16 novembre 2003
16 nov. 2003 à 15:37
Bonjour,

J'ai implémenté l'algorithme dit "Héron d'Alexadrie" sur AT mega 128 (8 bits, 16 MHz) qui me permet d'extraire une racine avec une précision de 10E7 en 300us.

Pas de virgule flottante, uniquement des long.

Le code s'inscrit dans une routine un peu longue qui m'a permis d'obtenir une meilleure précision qu'en flottant pour des calculs trigo. Il mixte C et assembleur. Il est dispo et toutes les remarques seront les bienvenues.

Je suis aussi à la recherche d'un algo rapide (8bits) pour diviser par 100.000.000, le mien se traîne un peu
BarthOlivier Messages postés 132 Date d'inscription mercredi 6 mars 2002 Statut Membre Dernière intervention 27 novembre 2012 1
15 nov. 2003 à 12:44
voici : BarthOlivier@free.fr et merci pour tout
cs_Vermifuge Messages postés 75 Date d'inscription samedi 23 mars 2002 Statut Membre Dernière intervention 18 septembre 2006
15 nov. 2003 à 12:14
lol, oki. si tu veux j'ai toutes les routines pour calculer sans le coprocesseur. Passe moi ton mail et je t'envoi ça. :)

@+
Vermi
S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (BarthOlivier)