bon je me suis collé au probleme en utilisant les infos de SPH
SPH a écrit :On procede comme une multiplication sur le papier :
ABCDEFG
* X
=======
et en n'utilisant QUE le purebasic
SPH a écrit :Je viens d'essayer entièrement en PB mais impossible !! Et si je reussi, ca fera trop de détours pour trop de perte de temps de calcul...
si! si! c'est possible
voici le code que je viens de mettre au point , qui reprend le mécanisme d'une multiplication a la main (multiplication +addititon) , ce qui évite de manipuler des gros chiffres
mais peut obtenir de tres grand nombres !
pour se faire j'emploie les Strings
car elle sont illimitées ,on peut écrire 3 tomes de chiffres dedans.. pas de problèmes
le code si dessous utilise 2 procédures
une, qui multiplie , puis l'autre, qui est utilisée par la première , qui s'occupe de la longue addition
de cette multiplication...
tout a fait dans l'esprit de cette image :
TTTTTTTTT ; nombre a multiplier
RRRRRRRRRR ; nombre multiplicateur
=========
eeeeeeeeee addition
eeeeeeeeee addition
eeeeeeeeee addition
eeeeeeeeee addition
___________
Resultat
le code ci dessous calcul la factoriel de 200
mais surtout l'affiche !!
sinon un exemple d'utilisation de multiplication standard est proposé sous la forme
; *********** exemple d'utilisation de la multiplication **********
b.s= "92245" ; ce nombre va etre multiplié par
multiplicateur.s= "9229" ; celui ci ;o)
calldebugger
debug multiplication(multiplicateur.s,b.s) ; affiche le resultat : o)
; *****************************************************
Avantage , on est plus limité par la taille des nombres a multiplier
declare.s multiplication(multiplicateur.s,b.s)
declare.s addition_liste(long_maximale.q)
; ; *********** exemple d'utilisation de la multiplication **********²
b.s= "92233720369223372036" ; ce nombre va etre multiplié par
multiplicateur.s= "92233720369223372036" ; celui ci ;o)
debug multiplication(multiplicateur.s,b.s) ; affiche le resultat : o)
calldebugger
; ; *****************************************************
; ************** calcul de factoriel ******************
valeur_max=20
res.s= "1"
for i=1 to valeur_max
i$= str (i)
res.s=multiplication(res.s,i$)
next i
debug res.s
calldebugger
; *****************************************************
procedure.s multiplication(multiplicateur.s,b.s)
; By Dobro
if len (multiplicateur.s)>len(b.s)
buf.s=multiplicateur.s
multiplicateur.s=b.s
b.s= buf.s
endif
global newlist pile.s()
multiplicateur.s= reversestring (multiplicateur.s)
b.s= reversestring (b.s)
long_multiplicateur.q= len (multiplicateur.s)
long_b.q= len (b.s)
i_multiplicateur.q=0
while i_multiplicateur.q < long_multiplicateur.q
i_multiplicateur.q =i_multiplicateur.q +1
extrait_multiplicateur.q= val ( mid (multiplicateur.s,i_multiplicateur,1)) ; recup l'extrait du nombre multiplicateur
i_b=0
while i_b < long_b
i_b=i_b+1
extrait_b= val ( mid (b.s,i_b,1)) ; ; recup l'extrait du nombre b
; ************ multiplie *****************
resultat.s=resultat.S+ str (extrait_b*extrait_multiplicateur+retenue) :retenue=0
resultat.s= reversestring (resultat.s)
; *************************************
retenue= val ( mid (resultat.s ,2,1)) : reste= val ( mid (resultat.s ,1,1))
resultat.s= ""
ligne_provisoire$=ligne_provisoire$+ str (reste)
wend
if retenue<>0 ; ya une retenue !
ligne_provisoire$=ligne_provisoire$+ str (retenue)
addelement (pile()) ; on pose la rangée en cours
pile()=ligne_provisoire$
retenue=0:reste=0
;ligne_provisoire$=""
else ; pas de retenue
addelement (pile()) ; on pose la rangée en cours
pile()=ligne_provisoire$
retenue=0:reste=0
endif
if long_b.q<2 and long_multiplicateur.q<2 ; ressort le calcul simple tout de suite
addelement (pile())
pile()=ligne_provisoire$
resultat.s= reversestring (pile())
ligne_provisoire$= ""
ProcedureReturn resultat.s
else ; **********************************************************************
;on passe a la rangée suivante
nextelement (pile())
; ajout d'un zero
compt.q=compt.q+1
resultat.s = lset (resultat.s, compt.q, "0" )
ligne_provisoire$=resultat.s
endif
wend
if compt.q>0
lastelement (pile())
long_maximale.q= len (pile())
resetlist (pile())
total.s=addition_liste(long_maximale.q)
total.s= reversestring (total.s)
ProcedureReturn total.s
endif
endprocedure
procedure.s addition_liste(long_maximale.q)
; by dobro
ligne_provisoire$= ""
i.q=0
while i.q<long_maximale.q
i.q=i.q+1
ForEach pile()
extrait_bit= extrait_bit+ val ( mid (pile(), i,1))+retenue :retenue=0
next ; fin de l'addititon ligne
ligne_provisoire$= ligne_provisoire$+ right ( str (extrait_bit),1)
retenue= val ( left ( str (extrait_bit), len ( str (extrait_bit))-1))
total.s=ligne_provisoire$
extrait_bit=0
wend
ProcedureReturn total.s
endprocedure
