Multiplication/divisions sur 64bits pour registre 32bits

Soyez le premier à donner votre avis sur cette source.

Snippet vu 18 933 fois - Téléchargée 28 fois

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

Messages postés
6
Date d'inscription
mercredi 6 février 2008
Statut
Membre
Dernière intervention
3 mai 2012

Merci cela me permettra de faire mon projet
Messages postés
64
Date d'inscription
jeudi 19 décembre 2002
Statut
Membre
Dernière intervention
15 décembre 2006

Bonjour,

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

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
Messages postés
132
Date d'inscription
mercredi 6 mars 2002
Statut
Membre
Dernière intervention
27 novembre 2012
1
voici : BarthOlivier@free.fr et merci pour tout
Messages postés
75
Date d'inscription
samedi 23 mars 2002
Statut
Membre
Dernière intervention
18 septembre 2006

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
Afficher les 7 commentaires

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.