Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#326 17-12-2018 19:04:39

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

en définitive, ce sont certain départ de début d'index, qui ne sont pas marqué [0] car ensuite ça crible....pourquoi ???

peut être que c'était plus simple avec les pfam mais là je nage encore ...

Hors ligne

#327 17-12-2018 19:53:30

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Que ça n'ait rien changé au problème, c'est normal, je n'ai fait que
- soulever un lièvre
- diminué de façon conséquente le nombre de produits (et autant de tests d'égalité) avant crible : si le nombre d'éléments de premiers est 13 (cas de n=3000), je supprime 78 multiplications, et donc 78 tests sur 169 soit 46 % de calculs inutiles et autant de tests puisque redondants.
  Si nn est le nombre d'éléments de la liste premiers, je supprime [tex]\dfrac{nn(nn-1)}{2}[/tex] calculs sur nn²...
  Mais pour n = 300 000 000, premiers contient 1987 nombres : je supprime donc 1 973 091 calculs sur 3 948 169 et autant de tests...
  Le % tend vers 50 % quand nn tend vers l'infini....

Je vais creuser cette histoire d'index qui sont calculés, validés mais que seul le dernier sert au crible...
Je ne comprends pas...
C'est TA traduction Python du script C++ ?


Arx Tarpeia Capitoli proxima...

Hors ligne

#328 17-12-2018 21:07:35

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

j'ai bien compris ta modif pour supprimer des multiplications redondantes puisque par ex pour n = 24 000 000 000 il met 124 secondes aussi rapide que cribleG3Y.. Et encore il n'est pas optimisé..

car pour chaque début d'index on devrait faire partir les deux nombres premiers à la suite  a,b de sorte qu'il n'y aura plus à les utiliser cela fait cribler à partir de l'index du carrée de a au minimum ,  quand le produit n'est pas un carré de a et bien il y a: a et b = (j%30) == fam
et l'index j //30  est donné pour a et b...!

pour ta question ce n'est pas tout à fait la transcription de nbpremier en  c++ car on utilise pas l'appel des pi < sqrt n
on positionne le GM {7,11,13,17,19,23,29,31}...et on avance à petit pas avec des arrêts...

car si c'était le cas, il irait à donf...! c'est pour cela qu'il faut le faire en python puis on le transcrit en C++ si possible comme cela à été fait par Mr Parisse Bernard de l'univ de Grenoble  qui à vraiment été symp...de s'investir pour voir ce que l'on pouvait faire en c++ pour le crible Gcrible GtY...il l'a retranscrit en utilisant la mémoire iscas par copié collé...(mais j'ai rien compris....)

chez moi il est limité à 145 000 000 000 en 12 secondes......chez lui sous linux en 64bit il met 60 seconde pour 450 000 000 000
alors que nbpremier win32 chez moi je met 2h40....pour 450 Go, et 240 secondes pour 145 Go...

si on arrive à l'optimisé celui ci, il ira encore plus vite que crible G3Y donc 20 fois plus vite retranscrit en c++

c'est en faisant le Gcrible que je me suis rendu compte que mon nbpremier win 32 était loin d'être optimisé car il fait des aller retour sans arrêt ; du fait que l'on crible avec le groupe multiplicatif GM {7,11,13,17,19,23,29,31} et c'est ce groupe qui extrait les Pi puis les fait partir ...sous condition......Problème le groupe GM avance par petit pas....c'est redondant...

Voila pourquoi le but est de faire partir A et B à la suite ou A tout seul si j = A*A. , de sorte que chaque premier qui a cribler et bien il sort du crible comme je te l'ai expliqué plus Haut...

prenons n=3000 fam =1
donc liste des Pi = { 7,11,13,17,19,23,29,31,37,41,43,47 et 53}
regarde :
7*7 , 7*11 (7*13)% 30 = 1 ok index, ils partent cribler et sorte de liste Pi.suivant 11
(11*11)% 30 = 1 ok index, il part cribler par pas de a et b puis sorte de liste Pi. suivant 17 puisque 13 est sorti...!
17*17 , 17 *19 , (17*23)% 30 = 1 ok index, il partent cribler et sorte de liste Pi. suivant 19 ok [7.11.13.17.23 sont sortie]
(19*19)% 30 = 1 ok index, il part cribler et sorte de liste Pi. suivant 29 :
(29*29)% 30 = 1 ok index, il part cribler et sorte de liste Pi. suivant 31 .." là on part des carré , au lieu de revenir en arriere"
(31*31)% 30 = 1 ok index, il part cribler et sorte de liste Pi.suivant 37 (" re belotte ça va être avec 41 ce qui est simple à voir")
37*37 , (37*41% 30) = 1 ok index, ils partent cribler et sorte de liste Pi. suivant 47 qui va être avec 43 car fam 13...!
47*47 , (47 *53)% 30 = 1 ok index, il partent cribler et sorte de liste Pi. ...FIN on fait la somme des [1]

ConclusionJE ME SUIS trompé car j'ai sauté des premiers Pi VOIR le #POST 307 page 13.
comme tu l'as fait remarquer à juste titre...
Mais surtout on commence toujours à cribler soit à partir du carré de a au minimum , ou plus loin , sans avoir à revenir...!

Ce que ne fait pas mon exécutable nBpremier win 32 car le jeune étudiant à l'époque ...il a fait au mieux mais très performant...

On va attraper la criblite....LoLLLL.

Passe une bonne fin de soirée Yoshi ...j'attends si tu veux, tes coordonnées par mail..Noël est proche....
@ +
gilbert

PS : As tu essayé le Gcrible retranscrit en c++...de Parisse B...?

Dernière modification par LEG (21-12-2018 07:15:05)

Hors ligne

#329 18-12-2018 07:29:55

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Suite du post ci-dessus:
Je suppose que la fonction range ne changerait rien à la place de enumérate, dans le but d'appeler les pi d'eratosne(n) afin d'utiliser les indices ['i] pour calculer les produit :
j = a * b
de sorte que lorsqu'un j a été calculé et qu'il est égal à j%30 == fam, puis on a calculé son index : soit pour a ou pour a et b suivant j est le carré de a.

Donc : a et b sont deux (premiers(n)) eratostene appelé, ils vont donc aller cribler....> n/30.

alors pourquoi ne pas mettre à 0 ces deux indices ['i] pour ne pas les rappeler...?
De sorte, que l'indice:  i +1 du [premier] suivant, si i +=1 est marqué 0 , on saute et on utilise l'indice suivant:
  i += 1, +=1, pour tout indice > 0.....non ?

En exemple:

for i,a in enumerate(premiers):

=
  {7, 11 13 17 19 23 29 31 37 41 43 47 53}  indice i +=1:
  {0, 1 , 2 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12}

ce qui donnerait pour calculer  j:
i*i , i * i+1, i *j+2 qui %30 = fam
index de j //30 = 3 index de a et b,

a crible , puis b crible, on met leur deux indices à 0 ce qui donne
{0, 1 , 0 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12} on réitère avec l'indice suivant qui est 1.
i*i qui %30 = fam
index de j //30 = 4 index de a , qui crible...>n/30 , on met son indices à 0 ce qui donne :

  {0, 0 , 0 , 3, 4 ,5 , 6 , 7, 8 , 9, 10,11, 12}; on réitère avec l'indice i +=1 suivant qui est 0 ; donc i += 1  indice 3
i*i  , i* i +1 , i * i+2 qui %30 = fam
index de j //30 = 13 .. index de aet b, , qui criblent...>n/30 , on met leurs indices à 0 ce qui donne :

{0, 0 , 0 , 0, 4 ,0 , 6 , 7, 8 , 9, 10,11, 12} ..etc on réitère...avec i = 4 qui serra un carré congru à 1 (mod30)

Pourquoi on peut supprimer les pi qui ont criblé , ou mettre leurs indices à 0 ...?

Tout simplement , pour fam = 1 fixée:

  pi = 7 , va parcourir les pi de Fam =13 , inversement 13 va parcourir les pi de Fam = 7:

Lorsqu'ils criblent ils marquent leur "conjoints" C...d'où on peut partir du carré de pi ou plus loin...pour ne pas revenir en arrière...Et donc , ne pas refaire des multiplications et index inutile...pour 3000: 18 au lieu de 72 ou 169...
Ex : je prend pi = 43 je fais i,a *b = 43*7 et index ...Alors que 7 en criblant a marqué d'un 0 sa cellule. ainsi que 37...d'où l'indice de 43 a été mis à 0 part 37, et l'indice de 53  mis à 0 par 17...lis ne peuvent donc pas être utilisé ensuite car ils ont déjà criblés...!
("Ce qui n'est pas faisable avec le Gcrible de Goldbach...car on part de l'indice du reste Ri.")

7 *13 ; 7*43; 7*73 ; 7* C+30 .....7 *C+30k
13 *37 , 13*67, 13 *97 ; 13 * C +30 .....13*C+30k....

11 *11 , va parcourir sa Fam = 11 +30k

17*23 vont parcourir fam 23+30k et 17+30k

19*19 ,va parcourir sa Fam = 19 +30k

29*29 ,va parcourir sa Fam = 29 +30k  et en dernier :

31*31 ,va parcourir sa Fam = 31 +30k qui est la fam 1+30k

c'est un résumé du GM (groupe multiplicatif)de l'algorithme nbpremier en c++ Mais qui par cette méthode serra optimiser au maximum...pour fam = 1 ou 19 ,il y a 6 couples de base car il y a les carrés de pi, et pour les autres 4 couples.

pour fam =7 , on aura : 7 *31 ..c+30k et inversement , 11* 17 ...c+30k ; 13 *19 ..c+30, et 23 *29 ..c+30k

etc..

Ce qui en principe pour chaque indice i traité et par Pfam i, avec pi i, on doit limiter le nombre d'opération à 8 au maximum en fonction de chaque Pfam appelée par la fonction range; afin de calculer l'index de a*b ou de a*a...!pour ensuite cribler par pas de a de l'index à n//30.

Dernière modification par LEG (21-12-2018 07:20:41)

Hors ligne

#330 19-12-2018 10:17:38

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Salit,

Je te l'ai déjà dit : si un point me paraît obscur, je suis comme le chien qui ronge son os...
Donc je t'avais dit qu'un "détail" me chiffonnait grandement :

def GCrible(premiers, n, fam):
    start_crible = time()
 
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)

    # On calcule les restes: ri = 2*n/pi
    nbpremiers = len(premiers)
 
    for i,a in enumerate (premiers):
        for b in (premiers)[i:]:
            j = a * b
            if j%30 == fam:
                index = j // 30
        # On crible directement à partir de l'index
        for index in range(index, lencrible, a):
                crible[index] = 0

    total = sum(crible)

Je t'avais expliqué que, vu l'indentation de la boucle for idx qui la place en sortie de boucle for b,  si pour une fam donnée, j'ai au moins deux index calculés, seul le dernier servira pour le crible...
Ce qui m'a amené à d'autres questions...
Supposons l'existence de 2 index calculés :
- sont-ils égaux ? si oui, alors à quoi sert d'en calculer 2 ?
- s'ils sont différents, pourquoi dans ce cas ne traiter que le dernier ? Et à quoi a servi de calculer le premier ?
- ils sont peut-être différents mais les cribles qu'on obtiendraient seraient-ils les mêmes ? Et dans ce cas, pourquoi s'embarrasser du premier index ? Et question subsidiaire, pourquoi ces cribles seraient-ils les mêmes ?

Alors j'ai fait un test édifiant pour n=3000 et fam = 7:

a=11
B=[17,47]
crible=[1]*100
crible2=[1]*100
lencrible=100
for b in B:
    j = a * b
    index=a*b//30
    if b==17:
        for idx in range(index, lencrible, a):
            crible[idx] = 0
    else:
        for idx in range(index, lencrible, a):
            crible2[idx] = 0        
print(crible==crible2)
print(crible)
print()
print (crible2)
print ("les cribles diffèrent à l'indice",end=" ")
for i,valeur in enumerate(crible):
    if valeur!=crible2[i]:
        print(i, end=" ")
 

Sortie :

False
[1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1]
les cribles diffèrent à l'indice 6

Qu'est-ce que ça t'inspire ? Lequel des deux cribles est le bon ?
---------------------------------------------
Au cas où, point technique :

premiers=[7, 11, 13, 17, 19, 23 ,29, 31, 37, 41, 43, 47 ,53]
for i,a in enumerate (premiers):
    print("i =",i)
    for b in (premiers)[i:]:
        print ((a,b),end=" ")
    print()

me sort :

i = 0
(7, 7) (7, 11) (7, 13) (7, 17) (7, 19) (7, 23) (7, 29) (7, 31) (7, 37) (7, 41) (7, 43) (7, 47) (7, 53)
i = 1
(11, 11) (11, 13) (11, 17) (11, 19) (11, 23) (11, 29) (11, 31) (11, 37) (11, 41) (11, 43) (11, 47) (11, 53)
i = 2
(13, 13) (13, 17) (13, 19) (13, 23) (13, 29) (13, 31) (13, 37) (13, 41) (13, 43) (13, 47) (13, 53)
i = 3
(17, 17) (17, 19) (17, 23) (17, 29) (17, 31) (17, 37) (17, 41) (17, 43) (17, 47) (17, 53)
i = 4
(19, 19) (19, 23) (19, 29) (19, 31) (19, 37) (19, 41) (19, 43) (19, 47) (19, 53)
i = 5
(23, 23) (23, 29) (23, 31) (23, 37) (23, 41) (23, 43) (23, 47) (23, 53)
i = 6
(29, 29) (29, 31) (29, 37) (29, 41) (29, 43) (29, 47) (29, 53)
i = 7
(31, 31) (31, 37) (31, 41) (31, 43) (31, 47) (31, 53)
i = 8
(37, 37) (37, 41) (37, 43) (37, 47) (37, 53)
i = 9
(41, 41) (41, 43) (41, 47) (41, 53)
i = 10
(43, 43) (43, 47) (43, 53)
i = 11
(47, 47) (47, 53)
i = 12
(53, 53)

C'est pourquoi je n'ai pas de calculs redondants, mais je pense que tu avais compris...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#331 19-12-2018 12:52:55

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

re Tu as bien fait ...!
A)
tu n'as pas de calcul redondant , c'est exact, mais le nombre d'opérations est très important par rapport à Goldbach qui inférieur :, c'est pourquoi ensuite il faut optimiser comme je l'ai indiqué sur le dernier post.

B) crible 1 ok pour 11²
le 2 ; crible avec 11 il est bon puisque en partant de l'indice 6 , tu marque un 0  tous les 11 nombres mais l'indice 6 c'est aussi pour 17  ...et les 0 par pas de 17 ....???

j'ai mis ton programme version ##6.2## au post 315 page 13 en remplacement du Gcrible car il me gonfle et je lui ai apporté tes modif ..pour l'instant afin de vérifier si pour la fam 1 il fonctionne  ...ET ...il marche ..Mais en gardant dans la def eratostene sqrt 2n...? ce qui n'est pas normal...
.je te met le résultat pour n = 3000  sqrt < 54 ok

== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 3000
Phase d'initialisation: 0.0 seconds ---
Bloc S2_s3 : 0.0 seconds ---
[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1]
Extraction des premiers n à 2*n : 0.0 seconds ---

**  51 nombres trouvés en 0.0 secondes ** à ce résultat , il faut enlever 1 , donc 50
>>>

j'ai testé jusqu'à 30 00 000 000 résultat ok .
par contre le temps mis,  10 fois moins vite que Goldbach G3Y ce qui s'explique par le nombres d'opé...

regarde le post 315 pour charger le programme et y apporter ton savoir...ce qui va te permettre de voir les lignes que j'ai remplacées...

pour les opération de multiplication on est ok ..mais suppose maintenant qu'il faut que tu les arrêtes lorsque le produit par exemple :
fam 7 ; n 3000 est = à 7%30  donc il faut les faire partir pour cribler...
donc  :
(11, 11) (11, 13) (11, 17) (11, 19) (11, 23) (11, 29) (11, 31) (11, 37) (11, 41) (11, 43) (11, 47) (11, 53)
i = 2
la partie rouge ne doit pas être effectué...ok?

D) je met le criblage pour la fam 7 et n = 3000

== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 3000
Phase d'initialisation: 0.0 seconds ---
Bloc S2_s3 : 0.0 seconds ---
[1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0]
Extraction des premiers n à 2*n : 0.0 seconds ---

**  55 nombres trouvés en 0.0 secondes **

pour n = 30 000 ; fam = 7
nbpremiers win32 Eratosthènemod30
Allocation du Tableau en cours...
>Allocation Terminée!
>Calcul du tableau en cours...
>Calcul du tableau terminé!
>Le dernier nombre est:
29947
>trouvé à la position:
407

ta version #v.6.2# mais pour  pour Eratosthène:

== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 30000
Phase d'initialisation: 0.0 seconds ---
Bloc S2_s3 : 0.0 seconds ---
Extraction des premiers n à 2*n : 0.0 seconds ---

**  407 nombres trouvés en 0.0 secondes **
>>>

Maintenant reste à y apporter ta TOUCHE ....

dans cette partie du programme :


for i,pi in enumerate(Primes_init):
        for b in (Primes_init)[i:]:
            j = pi*b
            if j%30 == 7:          # changer le paramètre pour une fam fxée
                fam = P8[7]  # changer le paramètre pour une fam fxée
                debut_index = j//30
                Nombres_fam = nombres[fam]
                for index in range(debut_index, nbcell,pi):
                   Nombres_fam[index] = 0
 

afin déjà , qu'il aille aussi vite que Goldbach ta version #V.6.3# ou 2 peu importe..
**********************************************************************
aperçu entre les deux cribles version Gold et version Erat

===== RESTART: E:\Documents\Conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 30000000

Extraction des premiers n à 2*n : 0.04679989814758301 seconds ---

**  213125 nombres trouvés en 0.15600013732910156 secondes **
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 30000000
Phase d'initialisation: 0.015599966049194336 seconds ---
Bloc S2_s3 : 5.85001015663147 seconds ---
Extraction des premiers 7 à n : 0.0 seconds ---

**  232262 nombres trouvés en 5.865610122680664 secondes **
>>>


@+




>>>

Dernière modification par LEG (21-12-2018 07:23:06)

Hors ligne

#332 19-12-2018 13:30:02

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Re,

je ne comprends pas ce que tu veux me montrer crible 2 avec [17,47]...

J'ai cru avoir été clair...
j'ai pris l'exemple de fam=7. 17*11%30 =7  et 47*11%30 =7
1. Le 1er crible est celui obtenu si j'oblige la boucle for b à s'arrêter puis à cribler après avoir trouvé le 1er b tel que  11*b%30 =7 donc un index de 11*17//30, donc 6...

2. Le crible2 est celui qu'on obtient en laissant la boucle for b à aller jusqu'au bout (b=53) et donc qui traite l'index 47*11//30=17
    Je constate alors que le crible n°1 et  le crible n°2 diffèrent par le 0 ou le 1 à l'indice 6.

C'est là que je t'ai demandé lequel des deux cribles était le bon ? Tu as répondu le n°2 ?
Donc à quoi ont servi les calculs :
  11*17=187, 187%30 = 7 puis 187//30  = 6 puis qu'on se fiche pas mal de ces calculs (ignorés par le crible qui suit la boucle for b...
Dans ce cas s'il ne faut utiliser pour une fam donnée n'utiliser que le dernier index calculé, je parcours la boucle for a en partant de la fin (je devrais probablement retoucher la boucle for b) et forcer la sortie de boucle dès le 1er index trouvé...
Je vais voir à expérimenter ça...

Précision programme.
Cette nouvelle façon de faire les choses est seulement plus lente ou elle donne aussi des résultats faux.
C'est bien ce que tu avais dit pourtant pour fam=1, pas de pb pour fam=7 une fois le message d'erreur disparu, tu as dit que le résultat obtenu était erroné... Peux-tu faire le point là-dessus ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#333 19-12-2018 13:41:18

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

On ne s'est pas compris,...tu as étais clair...
j'étais en train de répondre et je n'ai pas enlevé ma question.

pour ceci ok

1. Le 1er crible est celui obtenu si j'oblige la boucle for b à s'arrêter puis à cribler après avoir trouvé le 1er b tel que  11*b%30 =7 donc un index de 11*17//30, donc 6...

Pour celui ci ça ne sert à rien et tu l'as bien compris..!

2. Le crible2 est celui qu'on obtient en laissant la boucle for b à aller jusqu'au bout (b=53) et donc qui traite l'index 47*11//30=17
    Je constate alors que le crible n°1 et  le crible n°2 diffèrent par le 0 ou le 1 à l'indice 6.

puisque dans ce cas cela fausserait le crible, il partirait d'un index 17 au lieu de 6 et par conséquent on aurait un nombre 1 comptabilisé en plus...!


les résultats faux que j'avais indiqués c'est le Gcrible ...terminé avec lui;  j'ai repris ta version que j'ai reposté au # post 315, page 13...il n'y a plus d'erreur..

et pour n 300 000 000 E_cribleG3Y :
Extraction des premiers 7 à n : 0.09360003471374512 seconds ---

**  2031596 nombres trouvés en 207.9795651435852 secondes **  au lieu de ...

Extraction des premiers n à 2*n : 0.07800030708312988 seconds ---

**  1884105 nombres trouvés en 1.3260021209716797 secondes **
>>>

Dernière modification par LEG (19-12-2018 14:04:38)

Hors ligne

#334 19-12-2018 14:50:53

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Est ce que tu peux donc bloquer l'opération à l'index ok ..mais pour a*b %30 == 7..ou autre fam  ??

cela ne ferait que 39 au lieu de 78 multiplications  ...pour n = 3000. c'est toujours 3 fois plus que Goldbach pour le calcul des reste
Mais si on peut les faire partir à l'index commun aux deux pi...Alors c'est génial...! il ne resterait que 16 multipli...
ton tableau i = 0
(7, 7) (7, 11) (7, 13) (7, 17) (7, 19) (7, 23) (7, 29) (7, 31)
i = 1
(11, 11) (11, 13) (11, 17)
i = 2
(13, 13) (13, 17) (13, 19)
i = 3
(17, 17) (17, 19) (17, 23) (17, 29) (17, 31) (17, 37) (17, 41)
i = 4
(19, 19) (19, 23) (19, 29) (19, 31) (19, 37) (19, 41) (19, 43
i = 5
(23, 23) (23, 29)
i = 6
(29, 29) (29, 31) (29, 37) (29, 41) (29, 43) (29, 47) (29, 53)
i = 7
(31, 31) (31, 37)
i = 8

la c'est fini si/si tous les pi ont criblés !!! ; car à partir de cette limite > 31  on ne peut plus faire partir les pi {37..à.. 53} si il ne sont aussi partis à l'index commun aux deux  pi quand c'est le cas en général..

(37, 37) (37, 41) (37, 43) (37, 47) (37, 53) fin pour 37 car son conjoint est 61 > 53 ; mais de plus il a déjà criblé
i = 9
(41, 41) (41, 43) (41, 47) 
i = 10
    que l'on ne traite pas , car  b = 43 a déjà criblé
i = 11
(47, 47) (47, 53) dernière boucle pour l'index  = 86 , par pas de 47 et de 53 donc ils sortent directement seul la cellule [47*53] serra transformer en [0]

Donc 44 opération au total pour les 13 premiers = a.

Dernière modification par LEG (21-12-2018 07:30:54)

Hors ligne

#335 19-12-2018 18:20:13

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Re,

J'ai réussi l'inversion et l'élimination du calcul inutile en forçant la sortie

Couples (a,b) avec l'inversion pour n=3000 :

( 7, 53) ( 7, 47)  ( 7, 43), ( 7, 41) ( 7, 37) ( 7, 31) ( 7, 29) ( 7, 23) ( 7, 19) ( 7, 17) (7, 13)  (7, 11) ( 7,  7)
(11, 53) (11, 47) (11, 43) (11, 41) (11, 37) (11, 31) (11, 29) (11, 23) (11, 19) (11, 17) (11, 13) (11, 11)
(13, 53) (13, 47) (13, 43) (13, 41) (13, 37) (13, 31) (13, 29) (13, 23) (13, 19) (13, 17) (13, 13)
(17, 53) (17, 47) (17, 43) (17, 41) (17, 37) (17, 31) (17, 29) (17, 23) (17, 19) (17, 17)
(19, 53) (19, 47) (19, 43) (19, 41) (19, 37) (19, 31) (19, 29) (19, 23) (19, 19)
(23, 53) (23, 47) (23, 43) (23, 41) (23, 37) (23, 31) (23, 29) (23, 23)
(29, 53) (29, 47) (29, 43) (29, 41) (29, 37) (29, 31) (29, 29)
(31, 53) (31, 47) (31, 43) (31, 41) (31, 37) (31, 31)
(37, 53) (37, 47) (37, 43) (37, 41) (37, 37)
(41, 53) (41, 47) (41, 43) (41, 41)
(43, 53) (43, 47) (43, 43)
(47, 53) (47, 47)
(53, 53)

Sachant qu'ils ne sont pas tous calculés, puisque maintenant le 1er a*b %30=fam était, avant le 2nd, et dès qu'il a été trouvé, je calcule l'index et en dessous, aligné, j'ajoute : break qui force la sortie de la boucle b.
Il sort donc dès les calculs avec 11*47 effectués.
On traite et on passe à : a=13.
Pas de bol, il faut attendre 13*19 pour que le % donne 7.

Mais avant, je calculais de 13*7 à 13*53, là je ne teste ni 13*17, ni 13*13, ni 13*11, ni 13*7, je suis sorti de la boucle
pour n = 3000, le nombre d'index pour chaque fam varie de 1 à 2, peut-être que pour n=3*10**8 il y en a plus, je m'en fiche, le premier trouvé est le bon.
Avec inversion :

    # On calcule les restes: ri = 2*n/pi
    nbpremiers,lp = len(premiers),len(premiers)-1
    for i,a in enumerate(premiers):
        ii=i-1
        for k in range(lp,ii,-1):
            j = a * premiers[k]
            if j%30 == fam:
                index = j // 30
                break
        # On crible directement avec l'index
        for idx in range(index, lencrible, a):
            crible[idx] = 0

Je vais aller chercher la bonne version parce qu'avec n=300 000 000, j'obtiens comme sortie

Nombre premiers criblés famille 7 : 2278284  ----- 1.57
--- Temps total : 1.636 s ---

Avec n=3 000 000 000
c'est bien plus long :

Nombre premiers criblés famille 7 : 19997308  ----- 17.95
--- Temps total : 18.306 s

---

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#336 19-12-2018 19:52:21

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

oui effectivement avec la bonne version tu dois avoir pour n 300 000 000 fam 7;
>Calcul du tableau terminé!
>Le dernier nombre est:
299999977
>trouvé à la position:
2031596

donc avec nbpremier c'est moins d'une seconde, aà titre d'info, tel qu'il est pour 3 000 000 000 il met le même temps que nbpremier win..8100 seconde pour n = 450 000 000 000....mais c'est normal il fait trop d'opération

8000 seconde c'est le temps que met cribleG4Y ,ta dernière version #.V.6.3# ; pour n = 30 000 000 000.
la version python ...>C++ ; met 7 secondes pour 129 000 000 000.


-

Hors ligne

#337 19-12-2018 21:39:54

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

fais ATTENTION dans la version que j'ai copié au post 315, page 13 , tu verras la def eratostene est paramétré pour

def eratostene(n):
    n = int((2*n)**0.5)

si on met n=int(n**0,5) ce qui doit être le cas et bien le résultat est faux...???

Probablement à cause de l'indexation...
Vers la fin les pi ne peuvent plus être indexés , ce que je t'ai signalé, lors de ton exemple avec le tableau des multiplications pour cribleN°1 et crible N°2

@Yoshi

Supposons l'existence de 2 index calculés :- sont-ils égaux ? si oui, alors à quoi sert d'en calculer 2 ?

1) bien sûr qu'ils sont égaux ; 2) on perd du temps dans le criblage.

- s'ils sont différents, pourquoi dans ce cas ne traiter que le dernier ? Et à quoi a servi de calculer le premier ?

  1) les index ne sont pas différent par couple (a*b)  mauvaise interprétation ;
2) erreur on doit calculer l'index commun au couple (a * b) afin qu'on les range puis break  on continu dans l'indice !

on change d'indice i ; pour calculer les produits%7 de l'indice i +=1. ... l'index du couple ..., break ! on range l'index du couple ou d'un seul..on continue, on change d'indice ( i+1) on réitère ..lorsque l'on a l'index des 13 premiers on par cribler..

- ils sont peut-être différents mais les cribles qu'on obtiendraient seraient-ils les mêmes ?

1) non ! ils ne sont pas différents , le Point de départ du criblage est le même pour (a, b) même index de départ...!

Et question subsidiaire, pourquoi ces cribles seraient-ils les mêmes ?

les deux criblage ne peuvent être les mêmes pour un même point de départ..! le nombre de pas est différent !!

ton exemple crible N° 1 pour 11 * 17:

False
[1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1]

l'index 6, EST  pour 11 et 17 ! suite à cette erreur il manque le criblage de 17 que je fais en bleu 0... il n'y a donc pas de crible N°2.....

Ce qui obligatoirement, a pour résultat de limiter encore les multiplications de l'indice en question...de ton exemple :

( 7, 53) ( 7, 47)  ( 7, 43), ( 7, 41) ( 7, 37) ( 7, 31) ...donc calcule de l'index commun de 7 et 31  ..break  on change d'indice..

une fois le nombre d'index obtenu pour chaque premier par indice i ils criblent , break  on passe à l'indice suivant ...une fois que tous le pi on criblés , fin et résultat...ce qui limitera les opérations des derniers indices qui seront inutiles...

de ton exemple:

(37, 53) (37, 47) (37, 43) (37, 41) (37, 37)
(41, 53) (41, 47) (41, 43) (41, 41)
(43, 53) (43, 47) (43, 43)
(47, 53) (47, 47)
(53, 53)

Pour info : dans l'algorithme nbpremier le groupe multipl GM fait constamment des break...pour faire partir les pi premiers qui ont été extraits par le GM...

Dernière modification par LEG (20-12-2018 06:01:38)

Hors ligne

#338 20-12-2018 07:13:00

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

RE suite de ton #post 335 ci-dessus et de mes explications :

voila pour l'instant: ce qui serait très intéressant suite à ton tableau sans inversement 30 opération Fam = 1% 30:
i = 0
(7, 7) (7, 11) (7, 13) on a l'index 3 pour 7 et 13 ; break 7 et 13 partent cribler..retour à l'indice suivant sans continuer sur cet indice i=0
i = 1
(11, 11) on a l'index 4 pour 11 ; break 11 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 2
(13, 13) (13, 17) (13, 19) (13, 23) (13, 29) (13, 31) (13, 37)) on a l'index 16 pour 13 et 37 ; break;  37 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 3
(17, 17) (17, 19) (17, 23) on a l'index 13 pour 17 et 23 ; break 17 et 23  partent cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 4
(19, 19) on a l'index 12 pour 19 ; break 19 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 5
(23, 23) (23, 29) (23, 31) (23, 37) (23, 41) (23, 43) (23, 47) on a l'index 36 pour 23 et 47 ; break 47 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 6
(29, 29) on a l'index 28 pour  ; break 29 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 7
(31, 31) on a l'index 32 pour 31 ; break 31 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 8
(37, 37) (37, 41) (37, 43) on a l'index 53 pour 37 et 43 ; break seul 43 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 9
(41, 41) on a l'index 56 pour 41 ; break 41 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice
i = 10
(43, 43) (43, 47) (43, 53) pas d'index..ok car 43 devrait faire partir 37+30= 67 < 53...d'accord. indice suivant i +=1
i = 11
(47, 47) (47, 53)on a l'index 83 pour (47,53) ; break , 53 part cribler..retour à l'indice suivant  i= +1 sans continuer sur cet indice 
i = 12
(53, 53)  et pas d'index...
FIN résultat...!

1) moins d'opération, les pi partent de plus en plus loin ; donc accélération du criblage car moins de [1] à remplacer par [0]..
2) ce sont les plus petits pi qui font partir leurs conjoints supérieur , d'où moins d'opérations au lieu de continuer des opération dans l'indice en cour....c'est simple à vérifier...on supprime 82% d'opérations...

.....c'est presque la méthode , mais en plus optimisé que: nbpremier C++, traduit en python...car en C++, c'est le GM qui fait des break et des aller retour, pour faire partir leur conjoints premiers augmenté de 30k à chaque boucle du GM...

Dernière modification par LEG (20-12-2018 07:32:41)

Hors ligne

#339 20-12-2018 08:16:17

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Bonjour,

LEG a écrit :

@Yoshi

    Supposons l'existence de 2 index calculés :- sont-ils égaux ? si oui, alors à quoi sert d'en calculer 2 ?

1) bien sûr qu'ils sont égaux ;

Bien sûr que non...
Soit pour n=3000
Pour fam=7
a=11, b=17
j=a*b = 187
j%30 = 7 ? oui
   donc index= j//30=187//30=6

a= 11, b=47
j=a*b= 517
j%30= 7 ? oui
    donc index = j//30=517//30 = 17

Voilà donc, dans la boucle for b deux couples avec le même a =11 ou deux b (17 et 47) donnent un a*b%30 ramenant à la même famille :7
Mais leurs index sont différents : 6 et 17...
Alors ?

On ne doit pas parler de la même chose...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#340 20-12-2018 11:02:53

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Bien sûr , qu'ils sont égaux c'est pour cela que je te met les exemples ...mais tu n'as pas fais attention au déroulement de l'algorithme...

Soit pour n=3000 et  l'indice de i = 2
Pour fam=7
a=11, b=17
j=a*b = 187
j%30 = 7 ? oui
   donc index= j//30=187//30=6

EXACTEMENT...Mais POUR 11 et aussi 17 l'index est commun..à a et b..!

regarde mon tableau je déroule l'algo :

je fais partir 11, puis retour et c'est 17 qui par de l'index 6 par pas de 17 tu es bien d'accord ...
Où arrive t'il  ..? cellule ((17*41) -7) /30 = cellule 23....et ce n'est pas un index ok ..etc il crible..  ..mais on s'en fou , et retour i+1 = 2

Peut être que ce que tu n'as pas vu, ne connaissant pas parfaitement l'algo ce sont toujours les petit Pi qui font partir leur Conjoint b.
D'où rassure toi, c'est 41 qui va faire partir 47 à l'index 64...! et non pas 11.
de ce fait tu peux arrêter les multiplications pour a = 11 de l'indice 1...!et passer à l'indice 2


Pour moi: à l'indice i = 1, relatif à pi = 7;  aura : a = 7, b = 31, a*b = 217  index 7: pour 7 et 31  break : ils partent cribler tous les deux de cet index puis retour à l'indice suivant i = 1...! que l'on vient de voir..

l'indice i = 2 , relatif à pi = 13....13*13,13*17,13*19 j= a*b = 247 ,j%30==7 , index de 13 et 19 break , ils partent cribler , et retour 13 a fini les multiplication de son indice 2 . Donc: retour à l'indice i+1 = 3  ...

relatif à 17 qui a déjà criblé par contre il faudrait qu'il fasse partir b donc :
17*17,17*19,17*23, 17*29,17*31,17*37 , 17 *41 tu connais, on vient de le voir ça devient effectivement l'index = 23 et bien comme 17 à déjà criblé on fait partir son conjoint 41 de l'index 23.break , retour à l'indice i+1 = 4

relatif à 19...etc

je t'avais mis le tableau de déroulement de fam = 7...tu as dû zapper avec tous ça... et ne pas faire attention que par indice i et i+=1 il n'y a toujours qu'un couple a et b qui partent cribler  ou un seul dans le cas d'un a² et b n'est que le conjoint... d'où le produit a *b = 7%30 , donne le break et la fin des multiplication quelque soit l'indic i relatif à Pi n < Pin+1....

Dernière modification par LEG (20-12-2018 11:27:03)

Hors ligne

#341 20-12-2018 11:29:33

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Re,

Bien sûr que non, si j'appelle un chat un chat...
Dans ce morceau que tu as abandonné depuis :

    # On calcule les restes: ri = 2*n/pi
    nbpremiers,lp = len(premiers),len(premiers)-1
    for i,a in enumerate(premiers):
        ii=i-1
        for k in range(lp,ii,-1):
            j = a * premiers[k]
            if j%30 == fam:
                index = j // 30  # Je calcule bien un index, non ?
                break
        # On crible directement avec l'index
        for idx in range(index, lencrible, a):  # index qui est réutilisé ici, non ?
            crible[idx] = 0

La réponse étant oui à mes deux questions, et les deux index obtenus avec a =11  et b =17  et a=11 et b = 47  dans la même boucle for b, étant respectivement 6 et 17 (certes ils sont séparés de 11) je ne vois pas comment on peut dire que 6 = 17...
Je ne disais rien d'autre...

Avec la famille 7, c'est d'ailleurs le seul a à qui profite le break :

a = 7
(31, 7)

a = 11
(47, 17) (17, 6)

a = 13
(19, 8)

a = 17
(41, 23)

a = 19
(43, 27)

a = 23
(29, 22)

a = 29
(53, 51)

a = 31
(37, 38)

a = 37
-----------

a = 41
(47, 64)

Ci-dessus ce sont des couples (b, index) pour fam =7 et n=3000

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#342 20-12-2018 13:20:25

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

RE (je n'inverse pas...:)

1 ) le morceau comme je te l'ai dit il ne fonctionne pas du tout dans ta version #v.6.2#  de plus il faudra les Pfam en principe .

2) on parle du même index , Mais que l'on utilise différemment.

j'utilise un index commun à :  a et B explication au dessus #post 335 ce qui fait au maximum 42 opération , pour n = 3000; fam = 7

ton idée, c'était les Pfam dans Goldbach... et bien c'est la même...!

pour l'indice i = 0 , relatif à : a= 7 et bien Pfam indice 0..

je l'appel, je met dedans [(7, 7) (7, 11) (7, 13) (7, 17) (7, 19) (7, 23) (7, 29) (7, 31) = 7%30]

calcul de l'index de pfan i = 0  pour a et b
7*31 // 30 =7
a part cribler par pas de 7 de 7 à n/30 ; puis b par cribler de 7 à n/30 par pas de 31 .
puis on réitère avec i+1 = 1 pour Pfam =1 et a = 11
i = 1
je l'appel, je met dedans [(11, 11) (11, 13) (11, 17) = 7%30]
calcul de l'index 11*17 / 30 =  qui est bien l'index 6 mais pour 11 et 17
a part cribler par pas de 11 de 6 à n/30 ; puis b par cribler de 6 à n/30 par pas de 17 .
puis on réitère avec i+1 = 2 pour Pfam =2 et a = 13

i = 2 , Fam =2 a =13
[(13, 13) (13, 17) (13, 19)]
index  pour a et b = 13*19//30 = 8
a part cribler par pas de 13 de 8 à n/30 ; puis b par cribler de 8 à n/30 par pas de 19 . etc etc..
etc etc

toi: tu continu dans ta boucle i = 1 pour a= 11 pour extraire 47 , index 17..moi non, j'ai fini la boucle  à 11*17; car c'est 41 qui va calculer l'index de 47

on arrive à i = 9 fam = 9 pour a = 41
[(41, 41) (41, 43) (41, 47)]
index  pour a et b = 41*47//30 = 64
a part cribler par pas de 41 de 64 à n/30 ; puis b par cribler de 64 à n/30 par pas de 47 .

**********fin des boucles et du crible soit 44 opérations..****

car tous les a c'est à dire tous les premiers ont criblés, ils ont fait partir leurs conjoint B ...!

d'où i = 10,  et 12 sont inutile....!

combien d'opération sans utiliser les Pfam...? 47 de plus ..

Si tu penses (" ce qui m'étonnerait car tes versions avec les Pfam sont très rapides") : que même en faisant plus d'opérations sans utiliser les Pfam c'est plus optimisé.......Alors pas de problème .....reste plus qu' a le paramétrer pour qu'il fonctionne avec le bon résultat.

De plus dans ton système ce qui risque de se produire ...tu vas te retrouver avec l'indice i=0 puis 1 = 1....avec  moult opérations ...

au lieu de 8 par Pfam et indice, comme dans Goldbach , amuse toi à vérifier...c'est simple le GM que j'utilise dans nbremier il ne contient que 8 terme soit 4 multiplications ou 6 par fam...
Dans Godbach  comme tu as pu le voir au maximum 8...!

Dernière modification par LEG (21-12-2018 07:35:23)

Hors ligne

#343 20-12-2018 16:25:08

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Salut,

Bon, résumons : si tout fonctionne à ta satisfaction, qu'attends-tu donc de moi ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#344 21-12-2018 15:38:35

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Re Bonjour :

1 ) après réflexion sur la fonction :
   


 nbpremiers,lp = len(premiers),len(premiers)-1
    for i,a in enumerate(premiers):
        ii=i-1
        for k in range(lp,ii,-1):
            j = a * premiers[k]
            if j%30 == fam:
                index = j // 30  # Je calcule bien un index, non ?
                break
        # On crible directement avec l'index
        for idx in range(index, lencrible, a):  # index qui est réutilisé ici, non ?
            crible[idx] = 0
 

2 )
Sur mon Post au dessus en expliquant d'utiliser les [Pfam] mais sans inverser la liste de premiers pour calculer les produits =J ; en optimisant le nombre d'opérations...

Tu as fait une remarque qui à fait tilt...

Ci-dessus ce sont des couples (b, index) pour fam =7 et n=3000

il y aurait encore plus simple : DESOLE MAIS L'ALGO SERRA FAUX après controle...cétait trop simple je n'ai pas vue l'erreur§

on appelle la liste a = prime les premiers eratostene qui vont multiplier les éléments premiers de la liste b eratostene aussi

pour chaque indice i : on rapplle la liste B , mis à jour déduite des éléments b = premiers qui sont aller cribler
i=0
a = 7  : 7*7,7*11,7*13,7*17,7*19,7*23,7*29,7*31//30
(31, 7) premier ou b = 31, index =7 b va cribler de 7 à n//30 par pas de 31

i=1 on rappelle liste b - {31}
a = 11 :11*7, 11*11,11*13,11*17 //30
(17,6) ... b = 17, index =6 b va cribler de 7 à n//30 par pas de 17 . on réitère :

i=2 rappel liste b - {31,17}
a = 13 ; 13*7, 13*11,13*13,,13*19//30
(19, 8)  b =19 , index = 8 b va cribler de 8 à n//30 par pas de 19 . on réitère :

i = 3 rappel liste b - {31,17,19}
a = 17 : 17*7,17*11//30
(11,6) b =11 , index = 6, b va cribler de 6 à n//30 par pas de 11 . on réitère :

i=4 rappel liste b - {31,17,19,11}
a = 19 :19*7,, 19*13//30
(13,8)  b =13 , index = 8, b va cribler de 8 à n//30 par pas de 13 . on réitère :

i=5 rappel liste b - {31,17,19,11,13}
a = 23 : 23*7,,,,,23*23, 23*29//30
(29, 22) b =29 , index = 22, b va cribler de 22 à n//30 par pas de 29 . on réitère :

i=6 rappel liste b - {31,17,19,11,13,29}
a = 29 : 29*7,,,,, 29*23//30
(23, 22) b =23 , index = 22, b va cribler de 22 à n//30 par pas de 23 . on réitère :

i=7 rappel liste b - {31,17,19,11,13,29,23}
a = 31 : 31*7//30
(7, 7 ) b = 7 , index = 7, b va cribler de 7 à n//30 par pas de 7 . on réitère :

i = 8 rappel liste b - {31,17,19,11,13,29,23,7}
a = 37 : 37*37, 37*41,37*43, 37*47,37*53...stop on réitère

''pas d'index, car il serait avec 61 >53 aucun problème b = 31  a déjà marqué la cellule [0] = 31*37 index = 7+31  comme si il avait criblé !

i = 9 rappel liste b - {31,17,19,11,13,29,23,7,37}
a = 41 : 41*41, 41*47//30
(47, 64) b = 47 , index = 64, b va cribler de 47 à n//30 par pas de 47 . on réitère :
--------------------------------------------------------------------------------------
i=10  rappel liste b - {31,17,19,11,13,29,23,7,37,47}
a = 43 : 43*43,43*47,43*53, pas dindex ,cellule marqué [0] par pas de 19 donc ok

i=11 rappel liste b - {31,17,19,11,13,29,23,7,37,47,43,47}
a= 47 : 47*47,47*53....idem cellule déjà marqué par 41 ok

i= 12 rappel liste b - il ne reste dedans que 53
a = 53 :53*53 ok fin du crible somme des [1]

On a fait 39 multiplications et calculé 9 index.. pour  8 criblages  sur 13 ...un peu moins que ci dessus avec les Pfam mais 12 manipulations dans la liste b....aucune dans la liste A .... et à chaque fois que l'on rappelle la liste b elle se réduit de nb premiers à 1 seul il n'en reste qu'un ...c'est le Hyghlander....

Est ce plus simple... par rapport à l'explication ci dessus il me semble que cela serait plus long que d'appeler tes Pfam... Ce qui évite d'enlever à chaque fois un nombre premiers b dans la liste ce qui prend du temps...???? pour un gain d'opérations....mitigé

voila le déroulement de l'algorithme..Eratosthène mod30...selon ce principe...
@+

Dernière modification par LEG (22-12-2018 11:22:33)

Hors ligne

#345 21-12-2018 19:18:08

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Salut,

je vais regarder ça...

a = 7  : 7*7, 7*11, 7*13, 7*17, 7*19, 7*23, 7*29, 7*31//30

Tu sembles n'avoir pas intégré que c'est comme cela que ça fonctionne :
      a = 7  : 7*53, 7*47, 7*43, 7*41, 7*37, 7*31//30
et crible...
6 opérations et non 8...
Et je vais examiner pour voir, si en fonctionnant à l'envers, mais avec ton principe de retirer un nombre de la liste ça peut marcher et pour quel intérêt...
Maintenant, je me demandais pourquoi un seul nombre.
Mais ce ne serait pas une bonne idée par ex, pour a =11 et fam=7
11*47=517 ; 517%30 = 7 donc index = 517//30 = 17
Et
11*17 = 187 ; 187%30 =7 donc index = 181//30 = 6.
Toi, en ne fonctionnant pas en l'envers, tu t'arrêtes à 11*17 et tu sors 17 de la liste des b. Pourquoi t'arrêter là vu qu'après 11*47 se raccroche à la même fam ?
C'est vrai que je n'avais pas vu les choses sous cet angle : moi je pars de 53 et m'arrête à 47. Pourrais-je alors retirer 47 de la liste des b ?

Cela avec ce système de retrait, je suis obligé de travailler avec deux listes au départ, identiques, après, non.
D'où l'obligation, pour ne pas se retrouver avec un capharnaüm, de gérer 2 listes... Sinon, Python va se mélanger les crayons avec les indices...

Autre chose.
J'ai repris ma dernière version globale avec Pfam et un peu de binaire et je l'ai regardée avec un œil que je souhaitais neuf...
Du coup, j'ai repris la piste du binaire...
Et j'ai trouvé un outil nommé getsizeof()
from sys import getsizeof

print (getsizeof(255)) --> 28 (octets)
Mais
print( getsizeof([255])) --> 72 (octets)
Et
print(getsizeof([1,1,1,1,1,1,1,1]))  --> 128
Parce que si je l'écris comme ça  : 11111111 ce n'est rien d'autre que 225 en binaire...
Et pourtant que ce soit [[1,1,1,1,1,1,1,1]]*30 ou [255]*30, ils occupent la même taille : 304 octets... Piste à oublier, ou au minimum à revoir...

Mais j'en ai une autre sous le coude.
J'aurais plus vite ma réponse en te questionnant...
Lorsque j'ai Pfam :
[
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
[1,1,1,1,1,1,1,1],
.................
[1,1,1,1,1,1,1,1],
]
Une fois que des 0 après criblage ont pris la place de certains 1
Ces Fam de 8 éléments disposées en ligne comme ci-dessus, j'obtiens des colonnes...
La première correspond-t-elle, lorsque des zéros y figurent, à la Famille P8[0] c'est à dire 1...
Parce que dans cas cela voudrait dire pour n= que je peux demander à mon prog de sortir ça (et que ce ne soit pas une sottise) :

Pour n = 3000000
Phase d'initialisation: 0.013000726699829102 seconds ---
Bloc S2_s3 : 0.09000515937805176 seconds ---
Extraction des premiers n à 2*n : 0.008000612258911133 seconds ---

**  196033 nombres trouvés en 0.11100649833679199 secondes **
     Répartition
Famille 1 : 24551
Famille 7 : 24523
Famille 11 : 24497
Famille 13 : 24448
Famille 17 : 24527
Famille 19 : 24505
Famille 23 : 24509
Famille 29 : 24473

Si oui, alors j'ai une idée dont
- je ne sais pas, si je suis capable de la mettre en œuvre,
- si elle me ferait gagner du temps et de la mémoire...

Dans un 2e temps, je vais me demander si l'idée que j'avais suggérée de ne traiter que
- 50% des couples (a,b) en brute force
- encore moins en traitant à l'envers et en forçant la sortie
- en voyant ta variante à élimination...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#346 22-12-2018 08:07:32

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Bonjour Yoshi
1) si ... j'ai bien intégré comment cela fonctionne mais il y a trop d'opérations inutiles..
2)

Lorsque j'ai Pfam :[11111111]

cela ne peut pas être  les 8 fam par colonne que tu criblerais :

sauf si par colonne tu cribles :nbcell = n//30 *[1].Ce qui serra faux : si tu parcours les 8 colonnes en partant d'un index..ok?
car un index c'est pour aller cribler dans une et une seule fam donc une colonne....ou une ligne de nbcell.
à titre d'exemple pour fam 0 = 1 voila le résultat:

>Allocation du Tableau en cours...
>Allocation Terminée!
>Calcul du tableau en cours...
>Calcul du tableau terminé!
>Le dernier nombre est:
2999911
>trouvé à la position:
27042

Au lieu de

Famille 1 : 24551

3) les pfam, c'est pour y calculer les produits, comme tu le faisais avec les reste Ri += 2pi ....> tant que j%30 != fam...d'accord.?
[pfam] pour l'indice i=0 , A = 7 [7*7, 7*11, 7*13, 7*17 , 7*19, 7*23 , 7*29 et 7*31] ça ne peut pas aller plus loin que 8 produits..! Alors que la liste Bpi contient 13 pi ou plus en fonction de n...car si je continue et bien 7*37 == 19%30 comme 7*7..ok

4)******************************************************
reprise et modification du #post 344 ci-dessus: il y a une erreur
Donc retour vers le passé, avec ta liste A mais sans avoir besoin de l'inverser....Car cela ne commettra pas mon erreur... Ni celle que tu rencontres et qui donne une résultat FAUX.....
Car comme moi, tu ne vas pas redescendre assez bas,  pour marquer une cellule d'un [0] et garder le [1]....par exemple, dans le cas de n = 6000 ce que je viens de vérifier...! puis, qui s'aggrave pour des limites n plus grandes.....

***********************************************************************

5) le fonctionnement à l'envers  fais gagner des opérations ....mais fausse le résultat.!

peut on dans ta version, n'utiliser que le groupe de Multiplications GM = [pfam].....?
GM ={7,11,13,17,19,23,29,31,}  au lieu de la liste B inversée....tu verras que tu ferras moins d'opérations et avec un résultat juste..!

[la liste B = liste du groupe de multiplications GM et bien sûr Liste A erastostene < sqrt de n  .] la pfam contiendrai le GM...!
la liste A normale,  parcourt le GM, calcul l'index et  pi = A et non B part cribler...! puis indice suivant i+1 = A1

A1=7, parcourt pfam ({7,11,13,17,19,23,29,31,}) ...> 7%30. calcule de l'index, A1 part cribler par pas de A1 de l'index à N/30 = Famille 7 par exemple. pour n= 3000. On réitère avec A2 et pfam

A2=11, parcourt pfam ({7,11,13,17,19,23,29,31,}) ...> 7%30. calcule de l'index, A2 part cribler par pas de A1 de l'index à N/30

A3=13, parcourt pfam ({7,11,13,17,19,23,29,31,}) ...> 7%30. calcule de l'index, A3 part cribler par pas de A1 de l'index à N/30
etc...etc on réitère..

D'où pas besoin de manipuler la liste A , comme tu le pensais pour éviter les ennuis de python...


Mais pour info :

 ça c'est une Fam [11111111111111111111111111111111111111111111111111111111111111]
ça c'est une pfam[1.1.1.1.1.1.1.1] 8 opérations de multiplications au maximum ou groupe GM.Eratosthène. #pour Goldbach pfam, [1.1.1.1.1.1.1.1.1.1.1.1.1.1.1] 15 au maximum, mais seulement 8 appartiennent à une Fam; car il y a les multiples de 3 et de 5  lorsque l'on incrémente  par addition += 2p1 ...> %30 = Fam

Dernière modification par LEG (23-12-2018 06:02:22)

Hors ligne

#347 22-12-2018 13:59:42

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Après rectification du post 344 :


A = 7 11  13  17  19  23  29  31  37  41  43  47  53]   59  61  67  71  73
      n= 6000   Fam =7    nbcell = 6000/30 = 200 à cribler                    
                                   
pfam GM ({7, 11, 13, 17, 19, 23, 2931})                              
                                   
A ] ..GM = [7 11  13  17  19  23  29   31]
=
Pi ].........................................................
               
7    49   77   91 119 133 161 203 217 idx=7                
11     77  121   143   187    idx=6                        
13     91  143   169   221   247  idx=8                      
17    119  187  idx=6                            
19    133  209   247  idx=8                ( 36 opérations )        
23    161  253   299   391   437   529   667  idx=22                   
29    203  319   377   493   551   667  idx=22                     
31    217 idx=7  
....................................................................                         
37  259  407  ,,  ,,  ,,  ,,  ,,  1147  idx=38                 
41  287 ,,  ,,  697 idx=23                         
43  301  473   559  731 817 idx=27                       
47  329 517 idx=7                 (+ 19 opérations pour n = 3000) 
  ......................................................................     
53  371 583 689 901 1007  1219  1537  idx=51       
59  413 649 767 1003  1121  1357  idx=45 
..............................................................       
61  427 idx = 14                   
67  469 ,,  ,,  ,,  ,,  ,,  ,,  2077  idx=69     
71  497 ,,  ,,  1207  idx=40             
73  511 803 ,,  ,,  1387  idx=46    fin pour n = 6000 ;  en 86 opérations       
                       

 

Donc un total de 55 opérations. et de 86 pour n = 6000
chaque indice i relatif à A, va parcourir et mutiplier les éléments du de la pfam = GM
voila ..
ton idée ..?
Il me semble que cela doit être rapide comme temps d'exécution...
Plus vite que GOLDBACH...,? Où , c'est fonction , du nombre d'incrémentations par addition dans chacune des pfam et de leur nombre de divisions pour vérifier l'égalité du %30 avant de cribler..

Par contre le criblage est plus rapide pour chacun des pi dans Eratosthène..Exemple: pi =7 et Fam = 3000
Dans E :7 part de l'index 7 avec 8 opérations
Dans G : 7 par de l'index 4 avec 10 opérations....

Ta fonction ci-dessous est juste, mais c'est à cause de l'inversement de ta liste B qu'il y a erreur de résultat...!


nbpremiers,lp = len(premiers),len(premiers)-1
    for i,a in enumerate(premiers):
        ii=i-1
        for k in range(lp,ii,-1):
            j = a * premiers[k]
            if j%30 == fam:
                index = j // 30  # Je calcule l'index,
                break
        # On crible directement à partir de l'index
        for idx in range(index, lencrible, a):  # index qui est réutilisé ici...
            crible[idx] = 0
 

si tu utilises la liste B = GM = ({7, 11, 13, 17, 19, 23, 29, 31}) tu verras que le résultat est juste, sans inverser...
pour n=30 000 fam =7 tu dois avoir 407 premiers.

Regarde ton #post 335: avec tes explications....! et ton exemple, indice i=0 et i=1:

( 7, 53) ( 7, 47)  ( 7, 43), ( 7, 41) ( 7, 37)( 7, 31) [color=#0C11F2]( 7, 29)[/color]  ( 7, 23) ( 7, 19) ( 7, 17) (7, 13)  (7, 11) ( 7,  7)
(11, 53) (11, 47) [color=#A605F9](11, 43)[/color] (11, 41) (11, 37) (11, 31) (11, 29) (11, 23) (11, 19) (11, 17) (11, 13) (11, 11

Pourquoi penses tu que la 7eme cellule de l'indice 6 est toujours marqué [1] au lieu de [0]...? ci-dessous:

Donnez N: 3000
crible:[1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,....

quel est la valeur de cette cellule...???
qui aurait dû marquer cette cellule avec son conjoint = ??? et pourquoi ce n'est pas marqué..??? 
c'est la même erreur que dans mon post supprimé .....!!!

Donnez N: 6000
crible:[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1....  Tiens cela s'aggrave avec n = 6000....maintenant il y a l'indice 6 et 7 qui sont marqué d'un [1] au lieu de [0]..

cela a le mérite, que ta fonction marche marche très bien , mais c'est ta liste B inversée, qui met la zone : solution tu prends la liste A dans le sens normale, la liste B deviens liste GM qui serra toujours la même quelque soit n et Fam..!

et c'est la liste A, indicée qui parcourt le GM ""liste B"" :


( 7, 7) ( 7, 11)  ( 7, 13), ( 7, 17) ( 7, 19) ( 7, 23) (7,29), (7,31) .
(11,7) (11,11) (11,13) (11,17) .
# Sachant qu'ils ne sont pas tous calculés, puisque maintenant le 1er a*b %30=fam était, avant le 2nd, et dès qu'il a été trouvé, je calcule l'index et en dessous, aligné, j'ajoute : break qui force la sortie de la boucle b.
Il sort donc dès les calculs avec 11*47 effectués.

et 11*17 ...? qui marque l'indice 6 = 187....?

Dernière modification par LEG (23-12-2018 07:06:45)

Hors ligne

#348 23-12-2018 07:58:20

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

Bonjour Yoshi:

voici les résultat : Fam = 1, 7 pour n = 3 000 000
Après avoir remis la def eratostene à n = int(n**0.5) et modifié ta première fonction avec le GM.

GM = 7,11,13,17,19,23,29,31.

== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 3 000 000
Phase d'initialisation: 0.0 seconds ---
Bloc S2_s3 : 0.031200170516967773 seconds ---
Extraction des premiers de 7 à n : 0.0 seconds ---

**  27042 nombres trouvés en 0.031200170516967773 secondes **
>>>

== RESTART: E:\Documents\Conjecture de Goldbach\CRIBLE_Eratosthène_Mod30.py ==
Donnez la valeur de n = 30k : 3000000
Phase d'initialisation: 0.015599966049194336 seconds ---
Bloc S2_s3 : 0.031199932098388672 seconds ---
Extraction des premiers de 7 à n : 0.0 seconds ---

**  27137 nombres trouvés en 0.04679989814758301 secondes **
>>>

Programme :version #v.6.2# modifiée pour Eratosthène ...qu tu peux surement optimiser avec ta deuxième fonction dans cette version..


from time import time
from os import system
from collections import OrderedDict

## V. 6.2 ##

def eratostene(n):
    n = int(n**0.5)
    m = (n-1) // 2
    limite=1+n
    b = [True]*m
    premiers = [2]
    for i,p in enumerate(range(3,limite,2)):
        if b[i]:
            premiers.append(p)
            j = 2*i*i + 6*i + 3
            debut,pas=j,2*i+3
            for j in range(debut,m,pas):
                b[j] = False
    debut=i
    for i in range(debut,m):
        if b[i]:
            premiers.append(p)
        p += 2
    #print(premiers)
    return premiers[3:]

def E_CribleG3Y_mod30(n):
    # INITIALISATION
    global nombres,nbcell
    start_i= time()
    Primes_init = eratostene(n)
    nbcell = n//30
    nombres = []
    GM = 7,11,13,17,19,23,29,31
    for i in range(1):
        nombres.append([1]*nbcell)
    P8 = {1:0}          # changer le paramètre pour une fam fxée                  
    s_1=time()-start_i
    print("Phase d'initialisation: %s seconds ---" % s_1)
   
    # FAMILLES POUR CHAQUE Pi
    start_time = time()
    for i,pi in enumerate(Primes_init):
        for b in (GM):
            j = pi*b
            if j%30 == 1:          # changer le paramètre pour une fam fxée
                fam = P8[1]        # changer le paramètre pour une fam fxée
                debut_index = j//30
                Nombres_fam = nombres[fam]
                for index in range(debut_index, nbcell,pi):
                    Nombres_fam[index] = 0
    s_23=time()-start_time
    print("Bloc S2_s3 : %s seconds ---" % s_23)
    #print(Nombres_fam)

    # CALCUL DES NOMRES PREMIERS de 7 à n
    start_time = time()
    total = 0
    for sous_liste in nombres:
        total += sum(sous_liste)      
    s_4=time() - start_time
    s=s_1+s_23+s_4
    print("Extraction des premiers de 7 à n : %s seconds ---" % s_4)
    return total,s

n = int(input("Donnez la valeur de n = 30k : "))
nbr,s = E_CribleG3Y_mod30(n)
print ("\n** ",nbr,"nombres trouvés en %s secondes" % s ,"**")
system("pause")
 

A+ gilbert

Hors ligne

#349 23-12-2018 10:37:18

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 13 614

Re : crible en python

Re,

et 11*17 ...? qui marque l'indice 6 = 187....?

C''est la question que je t'avais posée au post #330 :

def GCrible(premiers, n, fam):
    start_crible = time()
 
    # On génère un tableau de N/30 cases rempli de 1
    crible = n//30*[1]
    lencrible = len(crible)

    # On calcule les restes: ri = 2*n/pi
    nbpremiers = len(premiers)
 
    for i,a in enumerate (premiers):
        for b in (premiers)[i:]:
            j = a * b
            if j%30 == fam:
                index = j // 30
        # On crible directement à partir de l'index
        for idx in range(index, lencrible, a):
                crible[index] = 0

    total = sum(crible)

Je t'avais expliqué que, vu l'indentation de la boucle for idx qui la place en sortie de boucle for b,  si pour une fam donnée, j'ai au moins deux index calculés, seul le dernier servira pour le crible...
Ce qui m'a amené à d'autres questions...
Supposons l'existence de 2 index calculés :
- sont-ils égaux ? si oui, alors à quoi sert d'en calculer 2 ?
- s'ils sont différents, pourquoi dans ce cas ne traiter que le dernier ? Et à quoi a servi de calculer le premier ?
- ils sont peut-être différents mais les cribles qu'on obtiendraient seraient-ils les mêmes ? Et dans ce cas, pourquoi s'embarrasser du premier index ? Et question subsidiaire, pourquoi ces cribles seraient-ils les mêmes ?

Alors, cette fois regarde mieux l'indentation et tu verras que ton morceau (c'est bien le tien) aussi s'asseyait royalement sur cet index 6...
Je vais élaguer pour te permettre de mieux visualiser:

    n=3000
    for a in premier:
        for b in premiers:
       |     calcul de j=a*b
       |     si j%30==7:
       |         calcul de l'index
        for idx in in range(index, lencrible, a):
               criblage

Comprends-tu que là, tu ne criblais qu'une fois tous les b passés en revue pourun a donné ?
Et que donc,  quand il y avait deux j tels que j%30==fam, tu calculais deux index certes, mais que la valeur du second venait écraser la valeur du premier et que, par conséquent, seul le 2e index était utilisé pour cribler ?

Pour cribler les deux, voilà ce qu'aurait dû être la bonne indentation :

    for i,a in enumerate (premiers):
        for b in (premiers)[i:]:
            j = a * b
            if j%30 == fam:
                index = j // 30
                for idx in range(index, lencrible, a):
                    crible[index] = 0

    total = sum(crible)
 

Tu vois la différence ?
Je t'ai posé la question, et au vu de ta réponse, j'en ai déduit que ce devait être normal et j'ai passé un après-midi à tenter de prendre les couples à l'envers, et à optimiser le code...
Et c'est pourquoi après le b =47 et le calcul de l'index, je forçais la sortie de boucle (avec break) pour ne pas aller jusqu'à 11*17...

Faut pas courir partout : qui trop embrasse mal étreint !...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#350 23-12-2018 10:42:18

LEG
Membre
Inscription : 19-09-2012
Messages : 455

Re : crible en python

D'accord, je n'avais pas compris le sens de ta question...OK

D'où maintenant, il suffit d'utiliser B = le GM avec ses 8 premiers...Pour effectivement éviter cette erreur , en passant en revue toute la troupe de B...

Question :
si c'est le GM i = 0 , B = 7, qui parcourt la liste A, mais à chaque index, break,  A part cribler par pas de A , puis GM inidce i = 0 pour B =7, continue dans la liste A ,j%30,  A crible par pas de A,..etc
Ensuite on change d'indice i = 1 pour B= 11....> A = [7....à 53]

Ets ce que cela serait plus rapide....?

Dernière modification par LEG (23-12-2018 11:09:33)

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
neuf plus soixante quatre
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums