Bonjour à tous
Voici une optimisation du prg précédent dans la recherche par zone des nombres premiers.
Travailler aux limites de la machine pose quelques difficultés en ASM.
Je me suis imposé une contrainte supplémentaire c’est de faire fonctionner le prg en 32 ou 64 bits sans avoir à recompiler ou en utilisant les mêmes instructions.
La toute première difficulté est de pouvoir réaliser certaines opérations addition division etc..
En effet si vous rechercher les diviseurs possibles de tout nombre proche de pow(2,63)-1 c'est-à-dire
$7FFFFFFFFFFFFFFF =9223372036854774807 il n’est pas nécessaire de travailler avec tout diviseur supérieur à sqr($7FFFFFFFFFFFFFFF)= 3037000499,97
valeur qui dépasse théoriquement la possibilité de la capacité d’un registre 32 bits=2147483647 en valeur signée.
Mais comme certaines instructions ASM permettent de travailler en valeur non signée ce qui permet d’atteindre pow(2,32)=
4294967296 Pb résolu en faisant attention aux instructions utilisées.
La deuxième difficulté ce trouve dans la division d’un nombre très proche de pow(2,63)-1 par un diviseur très petit on peut avoir une erreur de dépassement de capacité avec la division classique. ATTENTION le PRG suivant plante pour dépassement de la capacité.
Code : Tout sélectionner
Macro _q_t_
"
EndMacro
Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro
Macro _Q (__Q)
_q_t_#__Q#=_q_t_+Str(__Q)+" "
EndMacro
nb.q=$123456789ABCDEF0
debug _q(nb)
; DIVIS.l=$FEDC
DIVIS.l=$FF
; ; ; l'opération si dessous plante dépassement de capacité sur type entier (dividende trop grand pour diviseur trop petit)
enableasm
mov eax, dword [v_nb]
mov edx, dword [v_nb+4]
mov ecx, dword [v_DIVIS]
div ecx ;;; eici ça plante dividente trop grand pour diviseur trop petit
Il faut décomposer l’opération en deux parties comme cela.
Code : Tout sélectionner
Macro _q_t_
"
EndMacro
Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro
Macro _Q (__Q)
_q_t_#__Q#=_q_t_+Str(__Q)+" "
EndMacro
nb.q=$123456789ABCDEF0
debug _q(nb)
; DIVIS.l=$FEDC
DIVIS.l=$F
debug "**************** début des 2 sortes de divisions ****************************"
define quotientp.q,DIVMAX.q,restd.l
pas=2
FOR IJ=0 TO 10
debug "****"
np.q=nb
debug _q(nb)+_q(nb/DIVIS)+""+_q(nb%DIVIS)
EnableASM
MOV ecx,dword[v_DIVIS]
XOR EDX,EDX
MOV eax,dword[v_nb+4]
DIV ecx
MOV dword[v_quotientp],eax
MOV eax,dword[v_nb]
DIV ecx
MOV dword[v_restd],edx
MOV edx,dword[v_quotientp]
MOV dword[v_nb+4],edx
MOV dword[v_nb],eax ;************************************************ Recherche de la racine carré ***************************************************************
DisableASM
debug _q(np)+"___"+_n(nb)+"__"+_n(restd)
next
debug "************* FIN ***********"
Le troisième problème est de considérer que les nombres très grands sont dans une zone ou la racine carrée reste constante. Or le prg doit travailler dans toute zone de 1 à $7FFFFFFFFFFFFFFF avec une variation de la racine carré de 1 à 3037000499,97 ce qui fait un nombre considérable de calculs de la racine carrée. Pour éviter d’avoir à calculer la racine carrée à l’incrémentation du dividende il faut prévoir la valeur du dividende qui incrémentera la racine carrée de 1
En effet on peut prévoir à partir d’un nombre X et de sa racine RAC quant la racine carrée va changer car (A+1)^2=A^2+1+2A
si A=SQR(x)=RAC alors (SQR(X)+1)^2= X+1+2*A= X+1+2*RAC
On peut encore plus optimiser sachant que le diviseur max doit appartenir à la colonne susceptible de contenir des nb premiers
(cette optimisation n’est pas encore faite c’est pour la prochaine optimisation)
La quatrième difficulté c’est le temps de préparation de la table des différences des p_fact(x)
; exemple des p_fact(x)
; p_fact(x)--modulo--------------------Nb_occurrences des différences------------------------------Taux----------------Gain
; 3__________6__________________________2________________________________0,3333_________66,66%
; 5__________30_________________________8________________________________0,2666_________73,33%
; 7__________210________________________48_______________________________0,2285_________77,14%
; 11_________2310_______________________480______________________________0,2078_________79,22%
; 13_________30030______________________5760_____________________________0,1918_________80,81%
; 17_________510510 ____________________92160____________________________0,18052________81,94%
; 19_________9699690___________________1658880___________________________0,17102________82,89%
; 23_________223092870_________________36495360__________________________0,16358________83,64%
Or plus p_fact(x) est élevé plus le temps de préparation de la table est important donc le temps de préparation devient très important pour un p_fact(23) on avait plus de 50 secondes de préparation.
Pour diminuer ce temps il faut mémoriser la table des différences sous forme binaire au moment de la conception.
Il suffira de charger cette table en quelques milli-secondes.
Pour utiliser le prg de recherche des Nb premiers dans une zone, il faut commencer par constituer le fichier binaire de la table des différences avec le prg suivant.
Ce prg n’est à utiliser qu’une seule fois. Par contre si vous désirer voir les différences de temps, créez autant de fichiers binaires que vous désirez
avec p_fact(x) x [2 3 5 7 11 13 17 19 23] au delà de 23 les tables générées sont trop importantes (voir tableau ci-dessus).
Code : Tout sélectionner
; exemple des p_fact(x)
; p_fact(x)--modulo-----------------Nb_occurrences des différences--------Taux-----------Gain
; 3__________6__________________________2_________________________________0,3333_________66,66%
; 5__________30_________________________8_________________________________0,2666_________73,33%
; 7__________210________________________48________________________________0,2285_________77,14%
; 11_________2310_______________________480_______________________________0,2078_________79,22%
; 13_________30030______________________5760______________________________0,1918_________80,81%
; 17_________510510 ____________________92160_____________________________0,18052________81,94%
; 19_________9699690____________________1658880___________________________0,17102________82,89%
; 23_________223092870__________________36495360__________________________0,16358________83,64%
Macro _q_t_
"
EndMacro
Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro
Macro _Q (__Q)
_q_t_#__Q#=_q_t_+Str(__Q)+" "
EndMacro
EnableExplicit
OpenConsole("Résultats partiel")
Dim T_MODULO.l(12)
Structure colonne
; nb.q
prem.a
; dif_prec.l
dif_prec.a
; Dif_act.l
EndStructure
Structure DIVIS
NBPFACT.a
PREMDIV.l
NBSEQ.l
MODULO.q
; Array TDIF.a(40000000) ;; *** ATTENTION A utiliser avec DATA.A et read.A mais très lent avec p_fact(23) P_fact(19) est préférable remplacer 40 par 2
Array TDIF.a(40000000)
EndStructure
define SEQD.DIVIS,mess$,nb$,nbs,rest.l,i,modulo,elem,NBprem,Tdep.q,inb,inbp,prem_p,PREM_NB_PREM_AV,NB_PREM,SOM_DIF,vecteur$,NBSEQ,lvecteur,rapportq.d,RAPPORT.D
define ADRDSEQ.q,AdresdebF.q,AdresFinF.q,Adresdeb.q,delta
; **************** Réalisation du vecteur modulo npp à partir d'une table des nombres premiers des 100 premiers nombres *********
;***** Choix du premier Nb premier pour lequel le vecteur modulo sera appliqué.
;***** pour éviter la génération d'un vesteur trop important nous limiterons ce choix aux 23 premiers nombres premiers soit :2 3 5 7 11 13 17 19 23 29 31
;***** Recherche du modulo < 2*3*5*7*11=2310 éléments du vecteur
SAISIE0:
mess$+"Filtre de réduction des diviseurs"
If Len(mess$)>120
MessageRequester("Erreur","Colonne Div max 2 3 5 7 11 13 17 19 23 29 31"+#CR$+"Relancez le prg") ;
End
EndIf
nb$=InputRequester(mess$,"Colonne Div max 2 3 5 7 11 13 17 19 23 29 31","5") ;
If Len(nb$)>Len("31")
EndIf
nbs=Val(nb$)
If nbs<1 Or nbs>31
Goto SAISIE0
EndIf
rest.l=nbs%30
If rest=2 Or rest=3 Or rest=5 Or rest=7 Or rest=11 Or rest=13 Or rest=17 Or rest=19 Or rest=23 Or rest=29
Else
Goto SAISIE0
EndIf
; NBPFACT=NBS
; FINSAISIE0:
Restore lab_pnbp
i=0
Modulo=1
Repeat
Read.l ELEM
If ELEM<>0
T_modulo(I)=elem
Modulo*elem
i+1
EndIf
Until ELEM=0 Or ELEM=>nbs
redim SEQD\TDIF(Modulo+10)
SEQD\MODULO=MODULO
SEQD\NBPFACT=nbs
NBprem=i-1
nbs=ELEM
Dim tcol.colonne(SEQD\MODULO+2)
;*** Recherche des colonnes ayant des nb premiers ***
tcol(0)\prem=2
tcol(1)\prem=2
Tdep.q=ElapsedMilliseconds()
For inb=2 To modulo+1
For inbp=0 To nbprem
If inb%t_modulo(inbp)=0
tcol(inb)\prem=2
EndIf
Next
Next
prem_p=0
PREM_NB_PREM_AV=0
NB_PREM=0
SOM_DIF=0
vecteur$="DIV_"+Str(nbs)+":"+#CRLF$
;****** Recherche des différence entre NB premiers *****
If CreateFile(0,"DIVA_"+Str(nbs)+".PB") ; création d'un nouveau fichier texte...
NBSEQ=0
For inb=2 To modulo+1
; tcol(inb)\nb=inb
If tcol(inb)\prem=0 And inb>nbs
If prem_p=0
prem_p=inb
PREM_NB_PREM_AV=inb
vecteur$+"DATA.A "+Str(inb)+","
SEQD\PREMDIV=inb
NBSEQ+1
Else
NB_PREM+1
If nb_prem%101=0
If nb_prem%201=0
PrintN(_n(NB_prem)+_n(prem_p)+_n(tcol(inb)\dif_prec)+_n(som_dif)+_n(ElapsedMilliseconds()-Tdep)+_n(lvecteur))
EndIf
If nb_prem%5=0 ; ici tous les =101*x c'est avec 5 que l'on obtient le meilleur résultat
vecteur$+Str(inb-prem_p)+#CRLF$
; SEQD\TDIF(NBSEQ-1)=inb-prem_p
SEQD\TDIF(NBSEQ)=inb-prem_p
NBSEQ+1
lvecteur=Len(vecteur$)
WriteString(0,vecteur$) ;
vecteur$="Data.A "
Else
vecteur$+Str(inb-prem_p)+#CRLF$+"Data.A "
; SEQD\TDIF(NBSEQ-1)=inb-prem_p
SEQD\TDIF(NBSEQ)=inb-prem_p
NBSEQ+1
EndIf
tcol(inb)\dif_prec=inb-prem_p
SOM_DIF+(inb-prem_p)
; tcol(prem_p)\Dif_act=inb-prem_p
prem_p=inb
Else
tcol(inb)\dif_prec=inb-prem_p
vecteur$+Str(inb-prem_p)+","
; SEQD\TDIF(NBSEQ-1)=inb-prem_p
SEQD\TDIF(NBSEQ)=inb-prem_p
NBSEQ+1
SOM_DIF+(inb-prem_p)
; tcol(prem_p)\Dif_act=inb-prem_p
prem_p=inb
EndIf
EndIf
EndIf
Next
; tcol(modulo+2)\dif_prec=nb_prem+modulo-(modulo+1)
NB_PREM+1
tcol(modulo+2)\dif_prec=PREM_NB_PREM_AV-1
SEQD\TDIF(NBSEQ)=PREM_NB_PREM_AV-1
SEQD\TDIF(0)=PREM_NB_PREM_AV-1
SEQD\NBSEQ=NBSEQ
redim SEQD\TDIF(NBSEQ+2)
; tcol(1)\Dif_act=PREM_NB_PREM_AV-1
; tcol(1)\nb=1
SOM_DIF+(PREM_NB_PREM_AV-1)
rapportq.d=100.0*(modulo-Nb_prem)/modulo
vecteur$+Str(PREM_NB_PREM_AV-1)+",0 ;"+#CRLF$+";; Modulo="+Str(modulo)+" Nb Elements dans vecteur="+Str(NB_prem)+" NBPFACT="+str(SEQD\NBPFACT)+" Nb sequences="+str(NBSEQ)+" GAin="+Str(rapportq)+"%"
WriteString(0,vecteur$) ;
CloseFile(0) ; ferme le fichier précédemment ouvert et enregistre les données
PrintN(_n(ElapsedMilliseconds()-Tdep))
RAPPORT.D=modulo/NB_PREM
MessageRequester("C'est tout bon","Somme des nb du vecteur="+_n(SOM_DIF)+#CRLF$+_n(modulo)+#CRLF$+"voir le fichier pour le détail du vecteur"+#CRLF$+"Fichier: "+GetCurrentDirectory()+"DIVA_"+Str(nbs)+".PB"+#CRLF$+"Nomnre d'éléments dans le vecteur="+Str(NB_PREM)+" Rapport="+StrD(RAPPORT))
Else
MessageRequester("Information","Impossible de créer le fichier! DIVA_"+Str(nbs)+".PB")
EndIf
; Adresdeb.l=@SEQD\NBPFACTStructure DIVIS
; NBPFACT.a
; PREMDIV.l
; NBSEQ.l
; MODULO.q
; ; Array TDIF.a(40000000) ;; *** ATTENTION A utiliser avec DATA.A et read.A mais très lent avec p_fact(23) P_fact(19) est préférable remplacer 40 par 2
; Array TDIF.a(40000000)
ADRDSEQ.q=@SEQD
AdresdebF.q=@SEQD\NBPFACT
AdresFinF.q=@SEQD\MODULO+sizeof(quad)
Adresdeb.q=@SEQD\TDIF(0)
delta=AdresFinF-AdresdebF
If CreateFile(1, "MEMA_"+Str(nbs)+".bin")
WriteData(1,ADRDSEQ ,delta )
; WriteData(1,Adresdebf , 17)
WriteData(1,Adresdeb , SEQD\NBSEQ+1)
closefile(1)
Else
messagerequester("ATTENTION", "Fichier "+ "MEMA_"+Str(nbs)+".bin non créer")
endif
Input()
CloseConsole()
DataSection
lab_pnbp:
Data.l 2,3,5,7,11,13,17,19,23,29,31,0
EndDataSection
DataSection
lab_pnbp2:
Data.L 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97
Data.L 101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199
Data.L 211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293
Data.L 307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397
Data.L 401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499
Data.L 503,509,521,523,541,547,557,563,569,571,577,587,593,599
Data.L 601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691
Data.L 701,709,719,727,733,739,743,751,757,761,769,773,787,797
Data.L 809,811,821,823,827,829,839,853,857,859,863,877,881,883,887
Data.L 907,911,919,929,937,941,947,953,967,971,977,983,991,997,0
EndDataSection
; ***************** Ci dessous les Nombres premiers pour les 1000 premiers nombres
; 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
; 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
; 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293
; 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397
; 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499
; 503 509 521 523 541 547 557 563 569 571 577 587 593 599
; 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691
; 701 709 719 727 733 739 743 751 757 761 769 773 787 797
; 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887
; 907 911 919 929 937 941 947 953 967 971 977 983 991 997
Voici enfin le programme de recherche par zone des Nb premiers.
Code : Tout sélectionner
; Le nombre 1 n'est pas par convention un nombre premier.
; exemple des p_fact(x)
; p_fact(x)--modulo-----------------Nb_occurrences des différences--------Taux-----------Gain
; 3__________6__________________________2_________________________________0,3333_________66,66%
; 5__________30_________________________8_________________________________0,2666_________73,33%
; 7__________210________________________48________________________________0,2285_________77,14%
; 11_________2310_______________________480_______________________________0,2078_________79,22%
; 13_________30030______________________5760______________________________0,1918_________80,81%
; 17_________510510 ____________________92160_____________________________0,18052________81,94%
; 19_________9699690____________________1658880___________________________0,17102________82,89%
; 23_________223092870__________________36495360__________________________0,16358________83,64%
Macro _q_t_
"
EndMacro
Macro _n (__n)
_q_t_#__n#=_q_t_+Str(__n)+" "
EndMacro
Macro _Q (__Q)
_q_t_#__Q#=_q_t_+Str(__Q)+" "
EndMacro
EnableExplicit
; DisableDebugger
; 2 3 5 7 11 13 17 19 23
; dim Nb_prem(10)
Structure DIVIS
NBPFACT.a
PREMDIV.l
NBSEQ.l
MODULO.q
Array TDIF.a(37000000) ;; *** ATTENTION A utiliser avec DATA.A et read.A mais très lent avec p_fact(23) P_fact(19) est préférable remplacer 40 par 2
; Array TDIF.a(2000000)
EndStructure
Global result$,rest,fichier$
Define nb$,nb.q,DIVIS.q,pas,mess$,quotient.q,ind.l,SEQD.DIVIS,MIN.Q=1E12,pos, logmin, logmax, rmes,MIN_DEP.Q,ZONEP.Q,presultat$,resultat$
Define MAX.Q=MIN+1E4,nbg$,nbd$,pose.l,t_ind.l,t_col.l,t_ind_dep.l,MAXMAXDIV.q,RAC2.Q,MINRAC2.Q,nbseq.l,nbseqp,deb0.q
Define ind_dep,DIFF,FLAGFIN,IND_NB,CENTM,DIVISM,INDDD, DIVIS$,MAXDIV.q,dep_time.q,cent,nbseq_1.q,deb00.q,ADRDSEQ.q,AdresdebF.q,AdresFinF.q,Adresdeb.q,delta
Procedure.s choixdiv()
Protected COUR_DIR$,Filtre$,fichier$,Tfichier,fichierp$,leftfich$,RIGHTfich$
COUR_DIR$ = GetCurrentDirectory()
Filtre$ = "MEMA (MEMA_*.BIN)|MEMA_*.BIN;|Tous les fichiers (*.*)|*.*"
fichier$=OpenFileRequester("Choisissez un fichier MEMA ou annulez", COUR_DIR$+"\MEMA_17.BIN", Filtre$, 0)
fichierp$=UCase(Trim(GetFilePart(fichier$)))
Tfichier=FileSize(Fichier$)
leftfich$=Left(fichierp$,5)
RIGHTfich$=Right(fichierp$,4)
If Tfichier<1 Or Left(fichierp$,5)<>"MEMA_" Or Right(fichierp$,4) <>".BIN"
MessageRequester( "ATTENTION", "fichier vide ou le nom n'est pas conforme "+ _n(Tfichier)+" "+fichierp$)
End
EndIf
ProcedureReturn fichier$
EndProcedure
FICHIER$=choixdiv()
deb00.q=ElapsedMilliseconds()
;************************************************************************************************************************************
ADRDSEQ=@SEQD
AdresdebF=@SEQD\NBPFACT
AdresFinF=@SEQD\MODULO+SizeOf(quad)
Adresdeb=@SEQD\TDIF(0)
delta=AdresFinF-AdresdebF
If OpenFile(2,FICHIER$);,#PB_File_SharedRead|#PB_File_NoBuffering)
ReadData(2,ADRDSEQ ,delta)
ReDim SEQD\TDIF(SEQD\NBSEQ+1)
ReadData(2, Adresdeb,SEQD\NBSEQ+1)
CloseFile(2)
EndIf
deb0.q=ElapsedMilliseconds()
mess$=""
SAISIE2:
mess$+"MIN Blanc +Zone à explorer avec MAX=MIN+1Ex <= 1E2 +1E3 "
If Len(mess$)>250
MessageRequester("Erreur","Donnez Min BLANC et Zone à explorer sous forme 1E3 +1E3 1E4 +1E4 1E9 +1E4 "+#CR$+"Relancez le prg") ;
End
EndIf
nb$=UCase(LTrim(InputRequester(mess$,"MIN Blanc +Zone à explorer avec MAX=MIN+1Ex <= 1E2 +1E3 ","1E9 +1E4")));
pos=FindString(nb$," ")
nbg$=Trim(Left(nb$,pos))
nbd$=Trim(Right(NB$,Len(nb$)-pos))
POSE=FindString(nbg$,"E")
If pose>0
MIN=ValD(nbg$)
Else
MIN=Val(nbg$)
EndIf
POSE=FindString(nbd$,"E")
If pose>0
ZONEP=ValD(nbd$)
Else
ZONEP=Val(nbd$)
EndIf
MIN_DEP=MIN
MAX=MIN+ZONEP
If MAX<=MIN Or MIN<0 Or MIN=>$7FFFFFFFFFFFFFFF ;;; = 9223372036854775807 valeur max positive en .q
Goto SAISIE2
EndIf
logmin=Log10(MIN)
logmax=Log10(max-min)
If logmin+logmax>22
rmes=MessageRequester(" ATTENTION Temps très long","Oui=>continuez Non=>donnez autre zone",#PB_MessageRequester_YesNo)
If Rmes = 6 ; le bouton Oui a été choisi (Resultat = 6)
Else ; le bouton Non a été choisi (Resultat = 7)
Goto SAISIE2
EndIf
EndIf
MIN_DEP=MIN
resultat$=""
presultat$=" 2 3 5 7 11 13 17 19 23 29 31"
IF MIN < SEQD\NBPFACT
pose=findstring(presultat$,str(SEQD\NBPFACT))+1
resultat$=left(presultat$,pose)
MIN=SEQD\NBPFACT
endif
; ******** sysnchronistion des Nombres à tester avec le vecteur des différences ***********
Define restd.q=MIN%SEQD\MODULO
t_ind=0
t_col=1
For ind=0 To SEQD\MODULO
If restd<=t_col
t_ind_dep=t_ind
Break
Else
t_col+seqd\TDIF(t_ind)
t_ind+1
EndIf
Next
DIFF=t_col-restd
MIN+DIFF
;************** Fin de sysnchronisation *************************************************
OpenConsole()
divis.q=SEQD\PREMDIV
flagfin=0
; maxdiv.q=Pow(min,0.5)
maxdiv.q=Sqr(min)
MAXMAXDIV.q=Sqr(MAX)
;;;*******************************************************************************************************************************************************************
;;; On peut anticiper la prochaine racine différente de celle actuelle (A+1)^2 =A^2+1+2A si A=SQR(X)=RAC donc (RAC^2)=X alors => (RAC+1)^2= (RAC^2)+1+2*RAC=X+1+(2*RAC)
;;;*******************************************************************************************************************************************************************
RAC2.Q=(2*maxdiv)+1
MINRAC2.Q=MIN+RAC2
If MINRAC2<0
MINRAC2=9223372036854775807
EndIf
PrintN(_n(MAXMAXDIV-MAXDIV)+_n(RAC2)+_N(MINRAC2))
printn(resultat$)
IND_NB=t_ind_dep
centm=min/100
divis$=Str(min)+" "
divism=0
nbseq_1.q=SEQD\NBSEQ-1
nbseq=SEQD\NBSEQ
nbseqp=nbseq+1
dep_time.q=ElapsedMilliseconds()
pas=SEQD\TDIF(1)
;;;***********************************************************************************************************************
;;;****************************************** Début des 2 boucles pour rechercher les NB premiers dans une zone MIN MAX
Repeat
INDDD=1
pas=SEQD\TDIF(INDDD)
While divis<=maxdiv; or FLAGFIN>0
; printn(_n(divis)+_n(pas)+_n(idivis))
; ;Le nom de @@: signifie étiquette anonyme,vous pouvez avoir défini un grand nombre d'entre eux dans la source.
; ;Symbole @b(ou l'équivalent @r)le plus proche des références du label précédent anonyme
; ;,symbole @f références plus proche de l'étiquette suivante anonyme.
; ;Ces symboles spéciaux sont insensibles à la casse.
;;******************************* TESTS EN ASM ********************************************************************
;*************************************** Division d'un nombre de 64 bits par un nombre de 32 bits ******************************************
EnableASM
MOV ecx,dword[v_DIVIS]
XOR EDX,EDX
MOV eax,dword[v_MIN+4]
DIV ecx
; MOV dword[v_quotientp],eax ;;;; Le reste de la division nous suffit
MOV eax,dword[v_MIN]
DIV ecx
CMP edx,0
JNZ @f
INC dword [v_FLAGFIN]
Break
!@@:
MOV edx,dword[v_pas]
ADD dword[v_DIVIS],edx ; pas de PB l'addition est réalisée en valeur absolue
; donc $FFFFFFFF =>4294967295 donc pas de risque de dépassement sqr(pow(2,63)-1))=>3037000499,9760496922867524030306 <4294967295
;********************************************************************************************************************************************************
;********************************************************************************************************************************************************
; ;****************** peu efficace Pour accélerer encore l' algo et surtout incompatible avec PB64bits*******************************
; INC dword [v_INDDD]
; mov ebx,dword[v_INDDD]
; cmp ebx,dword[v_nbseqp]
; ; ; jne @f
; jne _FinFin
; mov dword[v_INDDD],1
; ; ; !@@:
; !_FinFin:
; LEA ebp,[v_SEQD]
; MOV ebx,dword [v_INDDD]
; MOV ebp,dword [ebp+17]
; MOVZX eax,byte [ebp+ebx]
; mov dword[v_pas],eax
DisableASM
;********************************************************************************************************************************************************
;********************************************************************************************************************************************************
; ;*********************************** Pour accélerer encore l' algo *******************************
INDDD+1
If INDDD=nbseqp ;;; inutil de passer en ASM voir ci dessus c'est plus long de près du double en temps sur la zone 9223372036854774807 1000
INDDD=1 ;;;;;9223372036854770999
EndIf
pas=SEQD\TDIF(INDDD)
EnableASM
;************************************ Pour accélerer encore l' algo vous pouvez décommentez les 5 lignes PB précedentes ******************************
;*******************************************************************************************************************************************************
Wend
;;;; *********************************************** FIN DE LA PREMI7RE BOUCLE *************************************************************
If flagfin=0
; debug _n(MIN)
cent=min/100
If centm<>cent
PrintN(result$)
centm=cent
result$=Str(min)+" "
Else
result$+Str(min)+" "
EndIf
Else
flagfin=0
EndIf
MIN+ seqd\TDIF(ind_nb)
;;;*******************************************************************************************************************************************************************
;;; On peut anticiper la prochaine racine différente de celle actuelle (A+1)^2 =A^2+1+2A si A=SQR(X)=RAC donc (RAC^2)=X alors => (RAC+1)^2= (RAC^2)+1+2*RAC=X+1+(2*RAC)
;;;*******************************************************************************************************************************************************************
If MIN =>MINRAC2
maxdiv.q=Sqr(MIN)
MINRAC2.Q=MIN+(2*maxdiv)+1
; PrintN("Changement de MAXDIV="+_q(maxdiv)+_q(minrac2)+_q(MIN)) ;;;; Pour vérifier le changement de racine carree
EndIf
;************************************************ Recherche de la racine carré ASM peut de gain ***************************************************************
; enableasm
; !FILD qword[v_MIN]
; !FSQRT
; ; !FISTTP qword [v_MAXDIV] ; avec arrondi si vous décommentez cette instruction commentez la précédente
; ; et laissez le ! car l'instruction FISTTP n'est pas reconnue par PureBasic avec !FISTTP c'est tout bon !!!!
; !FISTP qword[v_MAXDIV] ; sans arrondi
; disableasm
divis=SEQD\PREMDIV
ind_nb+1
; if ind_nb>SEQD\NBSEQ-1
If ind_nb>NBSEQ_1
ind_nb=0 ;;; remise à zéro si le cycle des différences est atteint pour incrémentation des nombres susceptibles d'être premiers
EndIf
Until min>max Or min<0 ;;Si vous n'allez pas aux confins de la machine =$7FFFFFFFFFFFFFFF ;;; = 9223372036854775807 valeur max positive en ..q.
;; Vous pouvez retirer (or min<0) ou dépassement de $7FFFFFFFFFFFFFFF
PrintN(result$)
PrintN( "Nombre Minimal = "+Str(MIN_DEP)+" Nombre Maximal = "+Str(MAX))
PrintN("Nombre d'éléments du vecteur =:"+Str(SEQD\NBSEQ)+" temps de préparation ="+Str(deb0-deb00))
PrintN("Temps millisecondes ="+Str(ElapsedMilliseconds()-dep_time))
Input()
CloseConsole()
; debug " "
; ***************** Ci dessous les Nombres premiers pour les 1000 premiers nombres
; 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
; 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199
; 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293
; 307 311 313 317 331 337 347 349 353 359 367 373 379 383 389 397
; 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499
; 503 509 521 523 541 547 557 563 569 571 577 587 593 599
; 601 607 613 617 619 631 641 643 647 653 659 661 673 677 683 691
; 701 709 719 727 733 739 743 751 757 761 769 773 787 797
; 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887
; 907 911 919 929 937 941 947 953 967 971 977 983 991 997
A+
