Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#451 Re : Programmation » crible en python » 17-12-2018 22:07:35
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]
Conclusion: JE 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...?
#452 Re : Programmation » crible en python » 17-12-2018 20:04:39
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 ...
#453 Re : Programmation » crible en python » 17-12-2018 19:49:50
Tu as entièrement raison à ce sujet...moi j'ai juste essayé de trouver pour calculer l'index si le produit j%30 == fam
mais je ne sais pas comment positionner les lignes...!
Je vais copier et coller tes lignes...et tester.
Car effectivement je regarder et j'ai bien vu que le produit et son debut index n'était pas marquer [0] par exemple avec fam = 7 et n=4500
j = 7*31 = 217
217//30 = 7
et bien la 8eme cellule indice 7 était marquée [1], idem pour la cellule index 22 relatif à 23*29...
@+
RE ça n'a rien changé toujours les erreurs fam 1 et 7
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py == 91 , 121 , = 0,0
Donnez N: 4500
crible:[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 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, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0]
Nombre premiers criblés famille 1: 79 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py == 187 , 217 = 0,0, 247 ok = 0
Donnez N: 4500
crible:[1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 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, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0]
Nombre premiers criblés famille 7: 84 ----- 0.01
--- Temps total: 0.01 sec ---
>>>
#454 Re : Programmation » crible en python » 17-12-2018 18:36:32
RE :
voici des exemple pour fam :1,7,11
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1]
Nombre premiers criblés famille 1: 8 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
Traceback (most recent call last):
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 81, in <module>
main()
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 76, in main
GCrible(premiers, n, 7)
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 57, in GCrible
for idx in range(index, lencrible, a):
UnboundLocalError: local variable 'index' referenced before assignment
>>>
== RESTART: E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py ==
Donnez N: 300
Traceback (most recent call last):
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 81, in <module>
main()
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 76, in main
GCrible(premiers, n, 11)
File "E:\Documents\Conjecture de Goldbach\Crible_Eratosthène_Mod30.py", line 57, in GCrible
for idx in range(index, lencrible, a):
UnboundLocalError: local variable 'index' referenced before assignment
>>>
je prend n= 600; fam = 1
Donnez N: 600
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]
Nombre premiers criblés famille 1: 12 ----- 0.0
Donnez N: 1200
crible:[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]
Nombre premiers criblés famille 1: 22 ----- 0.01
Donnez N: 1800 : 121 est devenu premier...?
crible:[1, 1, 1,0, 1, 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]
pour n =2100 et fam = 1
Donnez N: 2100 ; 91 et 121 = 0,0 sont = 1,1..?
crible:[1, 1, 1, 1, 1, 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]
Nombre premiers criblés famille 1: 38 ----- 0.01
que veut dire : lencrible = len(crible) et ensuite il s'en sert dans cette fonction :
crible[idx] = 0
on appelle à cribler ..? pourquoi ne pas avoir mis aussi lencrible[idx] = 0 ???
#455 Re : Programmation » crible en python » 17-12-2018 16:48:44
re :
Je pense peut être, qu'il saute des nombres premiers pi qui criblent et de ce fait cela augmente le nombre d'entier [1] qui ne sont pas marqué[0]
à cause de l'index qui serait mal mis...mais pourquoi dans ce cas, jusqu'à 600 le marquage des [1] en [0] est bon....???
#456 Re : Programmation » crible en python » 17-12-2018 15:49:50
moui mais pour moi c'est ..... ????
ma version, c'est 3.7.64 bit de juin 2018
mon petit fils aucune idée, mais je pense que c'est 3.5 c'est ce que j'avais en décembre 2017...
voila ma version:
Python 3.7.1rc1 (v3.7.1rc1:2064bcf6ce, Sep 26 2018, 15:15:36) [MSC v.1914 64 bit (AMD64)] on win32
pour te donner un ordre d'idée le nombre de premiers de 7 à n par la fonction :
$ \frac {(n/2)} {Ln(n/2)} + \frac {(n/2)} {Ln(n)}$ = 392 ; pour n = 3000 toujours < à $\pi(n) = 407$ fam.7
pour n = 3 000 000 000 ; fam 1
nbpremier donne :
>Le dernier nombre est:
2999999341
>trouvé à la position:
18 054 607
Gcrible donne : Nombre premiers criblés famille 1: 19 997 341 ----- 15.0
--- Temps total: 15.19 sec ---
si c'était du blé..il vaut mieux GCrible....LoLLL
#457 Re : Programmation » crible en python » 17-12-2018 15:42:07
Ca prend tournure...
Pour n = 30000
fam =7
total nombre premiers avec l'exécutable nbpremier win32:
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
au lieu de
459
en 0,03..secondes , comme pour la fam 1 ??? problème .
nombre de premiers pour n = 30 000, par fam {1,7,11,.....29}
{403-1 ; 407; 406; 406; 411; 395; 408 et 407 }
#458 Re : Programmation » crible en python » 17-12-2018 14:26:44
RE :
tu as raison pour ça:
crible[idx] = 0
pour le: print(f"Nombre premiers criblés famille {fam}: {total} ----- {int((time()-start_crible)*100)/100}")f
il m'avait dit que c'était pour calculer le temps des différentes fonctions le total....
Mais en plus chi... alors que c'était plus simple su tes programmes...!
Ensuite j'ai rien compris à ses {fam}: {total} que l'on peut virer....
En définitive pour imprimer il fait print une fois en haut....? ouù ..?
et ça lui imprimait toute les fonctions
au lieu de le faire par étape...d'ailleurs je me suis em.... pour imprimer les index, les nombres ..etc , j'ai juste réussi à débloquer print Gcrible
pour éditer les [11111111111111111111]
C'est pour cela que je pense qu'il vaut mieux modifier à partir de ta version #v6. 2# c'est à dire cribleG3Y... mais je pense que l'on a pas besoin des pfam...de toutes les façons cela ne gène en rien pour la limite et rapidité car le GCrible ne va pas plus vite....alors qu'il n'utilise pas les pfam...
#459 Re : Programmation » crible en python » 17-12-2018 12:31:10
re
voila ce que j'ai fais :
mais il y a erreur sur le résultat > 900 à cause de la sqrt n j'ai remis sqrt 2n ..???
from time import time
from os import system
from collections import OrderedDict
## V. 6.2 ##
def eratostene(n):
n = int((2*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 CribleG3Y_mod30(n):
# INITIALISATION
global nombres,nbcell
start_i= time()
Primes_init = eratostene(n)
nbcell = n//30
nombres = []
for i in range(1):
nombres.append([1]*nbcell)
P8 = {7:0} #pour 8 fam remettre les 8[1,7,...,29]
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 (Primes_init)[i:]:
j = pi*b
Fam = [0] #pour 8 fam remettre les 8[0,0,...,0]
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 , pour P8fam remettre [j%30]
if not Fam[fam]:
Fam[fam] = 7
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 ENTRE n ET 2*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 n à 2*n : %s seconds ---" % s_4)
return total,s
n = int(input("Donnez la valeur de n = 30k : "))
nbr,s = CribleG3Y_mod30(n)
print ("\n** ",nbr,"nombres trouvés en %s secondes" % s ,"**")
system("pause")
résultat :
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 300
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1]
Nombre premiers criblés famille 1: 8 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 600
crible:[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1]
Nombre premiers criblés famille 1: 12 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 900
crible:[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]
Nombre premiers criblés famille 1: 18 ----- 0.01
--- Temps total: 0.01 sec ---
>>>
=== RESTART: E:\Documents\Conjecture de Goldbach\Crible_G.T.Y_modulo30.py ===
Donnez N: 30000
Nombre premiers criblés famille 1: 465 ----- 0.0 ..FAUX
--- Temps total: 0.01 sec ---
Ensuite si je change le paramètre de la fam et que je met 7 au lieu de 1
à la ligne GCrible
GCrible(premiers, n, 1)
#460 Re : Programmation » crible en python » 15-12-2018 22:54:49
Voila , impeccable . mais il faut l'adapter au criblage, on va remplacer le mot myArray par Pi si besoin.
Et il va falloir cribler par pas de pi et de premier en partant de l'index.....
rentrer ta fonction avec (from prodduct...etc),
puis calculer l'index du produit A*B de ta fonction ....en espérant que de l'index on puisse partir cribler directement avec A, puis B
sinon: obligé de recalculer B*A index et criblage avec B ....
c'est cette idée qui fonctionnerait en principe le mieux ; si on peut paramétrer directement l'index des 2 pi = a*b ou d'un seul si a², du produit j en utilisant ton idée des Pfam comme dans Goldbach afin d'aller cribler pour chaque indice i traité... ...qu'en penses tu...
@+
Gilbert.
#461 Re : Programmation » crible en python » 15-12-2018 19:04:15
Bonsoir
@yoshi
voila une simulation que j'ai trouvée:
premiers corresponde au nombres premiers init
import os
premiers = (7,11,13,17,19,23,29,31,37,41,43,47,53,59,61)
myArray = (7,11,13,17,19,23,29,31)
for j in (premiers):
fam = 1
for i in (myArray):
produit = j*i
if produit %30 == fam:
produit //= 30
print ("i: ", j)
print ("produit%30: ", produit)
os.system("pause")
il ne reste plus qu'à utiliser l'index pour cribler , résultat des index : , i = premiers int Eratosrhène(n)
i: 7
produit%30: 3 # index
i: 11
produit%30: 4
i: 13
produit%30: 3
i: 17
produit%30: 13
i: 19
produit%30: 12
i: 23
produit%30: 13
i: 29
produit%30: 28
i: 31
produit%30: 32
i: 37
produit%30: 16
i: 41
produit%30: 15
i: 43
produit%30: 10
i: 47
produit%30: 36
i: 53
produit%30: 30
i: 59
produit%30: 57
i: 61
produit%30: 63
>>>
#462 Re : Programmation » crible en python » 15-12-2018 05:59:13
Bonjour @Yoshi :
suite post ci-dessus 307 que j'ai modifié
Peut être plus simple et en optimisant l'algorithme :
il y a une autre méthode en optimisant l’algorithme.
Il suffit de partir de la boucle des nombres premiers > 5 de la fonction
n = int(n**0.5)
pour calculer le produit.
. EX : pour n= 9000 :
que l'on appelle par la fonction
pi[i] = primes_init
En effet, on part directement du carré de Pi = 7, on calcule le produit j de :
Puis on calcule l’index pour (pi1 ,pi2) et on crible par pas de,
pi1 et de pi2 ; de l’indexe.....> n//30 ; [puis on change d'indice i donc aux Pi suivants pour ne pas les réutiliser]. Ensuite on réitère avec lindice i+=1 donc Pi suivant ...
#463 Re : Programmation » crible en python » 11-12-2018 17:51:13
re suite à une idée :
PS, j'ai remis au #post 303 ci-dessus ta version #"v6.2# que tu connais parfaitement. et à modifier , j'ai repris donc les explications par rapport à ta version ..
#464 Re : Programmation » crible en python » 11-12-2018 15:34:25
re: Je pensais qu'avec les exemples tu avais compris je modifie le #post 307
A ) on va remplacer les (restes de 2n par pi) et pour chaque premier <= sqrt de 2n..ok
enumeré par la fonction
B) on va calculer le produit de chaque élément de la liste des variables premières vp par pi et : pour chaque premier <= sqrt de n ok....
c'est simple je veux cribler la famille 13 mod30 , avec pi = 7 ; ("donc barrer les multiples de 7")
il me faut bien partir de l'index du produit = pi * vp; congru à 13 mod30 et n=900
7*7 = 49 pas bon
7*11 = 77 pas bon
7*13 = 91 pas bon
7*17 = 119 pas bon
7*19 = 133 == 13%30 ...ok calcul de l'index 133//30 = 4
je pars de 4 et je crible par pas de 7 de 4 ......> n//30 , puis je reviens dans cet indice et je crible par pas de 19 de 4 à 30..ensuite on reitère avec l'indice i+=1 relatif à Pi = a = 11
11110111111011111101111110111.n terminé pour pi = 7
je réitère avec pi = 11
11*7 = 77 pas bon
11*11= 121 pas bon
11*13 = 143 pas bon
11*17 = 187 pas bon
11*19 = 209 pas bon
11*23 = 253 == 13%30 ...ok calcul de l'index 253//30 = 8
je pars de 8 , je crible par pas de 11 de 8......> à 30.. et 8 + 23...étant .>30 donc 23 ne criblera rien...!
11110111011011111100111110111.n terminé pour pi = 11 car 23+8 >30
etc...on réitère avec l'indice i+1 relatif à a=13.....
#465 Re : Programmation » crible en python » 11-12-2018 06:52:20
Bonjour @Yoshi
effectivement tu as parfaitement compris qu'avec ma list de 8 nombres premiers ce n'est pas ce que tu m'as indiqué..
voici ma liste de variables vp = 7,11,13,17,19,23,29,31 qui permet de calculer le produit de pi * vp
tu connais parfaitement le programme version "v 6.2# ci dessus, puisque tu me l'as fait...Donc à partir de la ligne :
la suite du programme ne changera pas on remplacera reste par produit soit :
Mais attention, on changera la première ligne de Eratosthène qui va cribler jusqu' la sqrt de n et non de 2n
Ce qui donnera par obligation :
def eratostene(n):
n = int(n**0.5)
En résumé, on va faire avec produit = vp * pi ce que l'on fait avec reste que, dans ton programme on a apelé j
C'est pour cette raison qu'il nous faut la liste des Pi $\leqslant \sqrt{n}$
*******************************************************************
on a entré:
n = 3000 et choisie la fam = 1 On part du carré de Pi
On a extrait les premiers avec ératostene < sqrt n et retourner les premiers[3:]
On a initialisé les 1 , 3000 /30 = 100, soit 100 cellules de 1
Exemple voila ce que cela donnerai à partir de la fonction
:
puis: on a vp [7 ; 31]
je prends pi = 7 ; J = a * b ; qui sont les variables Pi $\leqslant \sqrt{n}$
je calcule le produit j = a*b
a *7……….donc on peut avoir 8 produits au maximum, tant que le produit %30 != 1 car on crible la fam 1.
[7*7, 7*11, 7*13 == 1%30 ]; donc ok , le break est donné par 1%30 , je n’ai pas besoin d’aller jusqu’à b = 29 pour calculer 7*29, d’accord….
Puis je calcule son index: j = 91 , 91//30 = 3 index commun à a=7 et b=13
Que Je positionne cellule 3 et je crible par pas de premiers = 7…de 3 à n//30 on remplace les [1] par [0] tous les 7 pas….etc… on réitère avec b= 13, par pas de 13...de 3 à n//30.
On change d'index i +=1 relatif à pi = 11…..premiers $\leqslant \sqrt{n}$
[11*11 == 1%30 ]; ok
calcul de l'index :
j //30 = 4
que l'on positionne cellule 4, crible par pas de 11 de 4 à n//30 ...etc on réitère avec (i +=1) Pi = 13....
13*13 , 13*17,13*19,13*23,13*29,13*31, 13*37== 1%30 ok, position index = 16, crible par pas de 13 de 16....>n//30 ...puis par pas de 37....on réitère i +=1 avec Pi= 17 ...
[17*17, 17*19, 17*23 == 1%30 ]; ok position index = 13, crible par pas de 17de 13....>n//30 ...puis par pas de 23 ......> n//30...etc
i +1; pour Pi = a = 19
[a*a == 1%30 ] ; index = a²//30 = 12 ; crible par pas de 19 de 12 à n//30..
i+1 = 23 = a
[a*a ; a*29, a*31, a*37 , a*41, 23*47== 1%30 ] ; index = a*b //30 = 36 ; crible par pas de 23 de 36 à n//30.., puis par pas de 47 de 36 à n//30
etc...etc avec i incrémenté de 1 pour les a = 29,31,37,41,43,47,53...tant que tous les Pi <= à 53 n'ont pas exécuté leur criblage..Qui va s'arrêter à Pi = a = 47 :
29*29...index ....>n//30 par pas de 29
31*31...index ....>n//30 par pas de 31
i+=1 = a = 37 , qui lui à déjà criblé avec a = 13
a*a, a*41, a*43 ==1%30 ; index = a*b //30 = 53 ; crible par pas de 43 de 53 à n//30.., car 37 à déjà criblé jusqu'à n//30
43 à criblé
i+1 = a = 47
a*a ; a*53== 1%30 ; index = a*b //30 = 83 ; crible par pas de 53 de 83 à n//30 qui ne marque donc d'un [0],que la cellule:
47*53 = [0]....! Ce qui va très vite, les 13 a = Pi ont criblés. Fin de l'algorithme on fait la somme des [1] qui nous indique le nombre de premiers de 7 à n.
********************************************************************
On supprime donc les lignes en rapport avec 2n et /ou reste=2n%pi
Ce programme serra nommé ECrible , E pour Eratosthène mod30.
l'explication est : deux cribles:
E criblera par Famille les premiers de 7 à N.. la famille 1 où 1 n'est pas premier commencera à 31.
G criblera par famille de 1 à N en partant du reste et non du produit...car on crible les congruents de Pi...et non les multiples..etc, donc les premiers de N à 2N.
Ils ont la même propriété .!
d'où on peut affirmer que le nombre de nombres premiers G(n) de N à 2N vaut au minimum N / log 2N
par conséquent $pi(2n)$ vaut environ : [(N / log N) + (N / log 2N)] lorsque N tend vers + l'infini....
#466 Re : Programmation » crible en python » 10-12-2018 19:12:57
ok @Yoshi
je comprend, mais je suis bien obliger de dire la vérité..je ne vais quand même pas m'octroyer un travail que je n'ai pas fais ..
Ceci dit, ça fait trois jours que je bataille pour modifier trois lignes du programme et je n'ai toujours pas trouver la réponse ...ni avec un ou des tutos Python, qui me font tourner en rond...à part me dire que l'on ne multiplie pas une liste par un nombre ou que c'est un tuple dont les valeur ne sont pas modifiable , C'est bien pour ça que je l'ai utilisé et comment on utilise les valeurs pour calculer le produit pour chaque premiers appelé..???? peau de balle et variété...
Merci quand même
cordialement
leg
#467 Re : Programmation » crible en python » 10-12-2018 08:15:23
Bonjour
j'ai un petit souci: le but étant d'avoir deux cribles équivalents; pour cribler de N à 2N "Goldbach" et de 7 à N "Eratosthène" :
Afin de justifier les deux fonctions relatives à $\pi(n)$ et $G(n)$ : $\frac{n}{log . n}$ et $\frac{n}{log . (2n)}$
Voici la partie que je voudrai modifier pour utiliser GCrible de Goldbach dans Ecrible Eratosthène :
Voici la partie du progr origine que je dois modifier:
1) On remplacera la première ligne de def eratostene
n = int((2*n)**0.5) par n = int(n**0,5)
*****************************
## V. 6.2 ##
def eratostene(n):
n = int((2*n)**0.5) ## ligne à modifier ##
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 CribleG3Y_mod30(n):
# INITIALISATION
global nombres,nbcell
start_i= time()
Primes_init = eratostene(n)
nn,nbcell = n*2,n//30
nombres = []
for i in range(1):
nombres.append([1]*nbcell)
P8 = {1:0} #pour 8 fam remettre les 8[1,7,...,29]
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):
j = nn%pi
debut,fin,pas = j+pi*(1-j%2),min(pi*30,n),pi*2
Fam = [0] #pour 8 fam remettre les 8[0,0,...,0]
for j in range(debut,fin,pas):
if j%30 == 1: # changer le paramètre pour une fam choisie
fam = P8[1] # changer le paramètre pour une fam fxée , pour P8fam remettre [j%30]
if not Fam[fam]:
Fam[fam] = 1
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(j)
#################################################################
Voici la partie que je veux modifier mais qui ne marche pas :
là on crible pareil, mais on n’a plus besoin de calculer le reste r de 2n par premiers…
Il faut par contre, une fonction tableMulti pour calculer le produit des 8 variables de vp = {a=31,b=7, c=11, d=13, e=17, f=19, g=23, h=29}
Par pi, et que l’on réitèrera. Pour chaque premier…
De sorte que le produit j = pi * vp , pour chaque premier , on calculera ensuite l’index…pour cribler ; au lieu du reste, dans Goldbach.
et ensuite que : j %30 == 1
exemple :
n = 3000 on a initialiser les 1 , 3000 /30 = 100, soit 100 cellules de 1
je prends premiers = 7
je calcule J = vp *7……….donc 8 produits au maximum, en vérifiant si j %30 == 1 car on crible la fam 1.
7*1 , 7*7, 7*11, 7*13 == 1%30 ; donc ok et je n’ai pas besoin d’aller jusqu’à pi = 29 pour calculer 7*29, d’accord….
Puis je vais calculer son index j = 91 , 91//30 = 3
Je positionne cellule 3 et je crible par pas de premiers = 7…de 3 à n//30 on remplace les [1] par [0] tous les 7 pas….etc… on réitère avec premiers = 11…..premiers <= sqrt de n et non de 2n, car c’est Eratosthène….modulo 30
**************************
le reste du programme, ne change donc pas.
Et ensuite je le ferai ...si possible...en C++ comme ci- dessus post d'hier .....
#468 Re : Programmation » crible en python » 08-12-2018 21:18:49
Bonjour
Alors @Yoshy ...du boulots..
voila le programme fait en C++ par une âme charitable de l'univ - grenoble-Alpes
il envoie et j'ai testé pour N = 60 mds temps 120 secondes
je te met le programme car je dois bien ça sur ton forum...
// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
void fill_crible(vector<unsigned> & crible,unsigned p){
crible.resize((p-1)/64+1);
unsigned cs=crible.size();
unsigned lastnum=64*cs;
unsigned lastsieve=int(std::sqrt(double(lastnum)));
unsigned primesieved=1;
crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
for (unsigned i=1;i<cs;++i)
crible[i]=0xffffffff;
for (;primesieved<=lastsieve;primesieved+=2){
// find next prime
unsigned pos=primesieved/2;
for (;pos<cs;pos++){
if (crible[pos/32] & (1 << (pos %32)))
break;
}
// set mutiples of (2*pos+1) to false
primesieved=2*pos+1;
unsigned n=3*primesieved;
for (;n<lastnum;n+=2*primesieved){
pos=(n-1)/2;
crible[(pos/32)] &= ~(1<<(pos %32));
}
}
}
unsigned nextprime(vector<unsigned> & crible,unsigned p){
// assumes crible has been filled
++p;
if (p%2==0)
++p;
unsigned pos=(p-1)/2,cs=crible.size()*32;
if (2*cs+1<=p)
return -1;
for (;pos<cs;++pos){
if (crible[pos/32] & (1<<(pos%32))){
pos=2*pos+1;
// if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
return pos;
}
}
return -1;
}
typedef unsigned long long ulonglong;
size_t GCrible(const vector<ulonglong> & premiers,ulonglong n,int fam){
int cl=clock();
size_t lencrible=n/30,nbpremiers=premiers.size();
vector<bool> crible(lencrible,true);
ulonglong n2=2*n;
vector<ulonglong> indices(nbpremiers);
for (size_t i=0;i<nbpremiers;++i){
ulonglong p=premiers[i];
ulonglong reste=n2 % p;
if (reste %2==0)
reste += p;
ulonglong pi2=2*p;
while (reste %30!=fam)
reste += pi2;
reste /= 30;
indices[i]=reste;
}
ulonglong nslices=lencrible/3000000,currentslice=0;
if (nslices==0) nslices=1;
for (;currentslice<nslices;++currentslice){
size_t slicelimit=currentslice+1;
slicelimit=slicelimit==nslices?lencrible:(currentslice+1)*(lencrible/nslices);
for (size_t i=0;i<nbpremiers;++i){
ulonglong p=premiers[i];
size_t index;
for (index=indices[i];index<slicelimit;index+=p)
crible[index]=0;
indices[i]=index;
}
}
size_t total=0;
for (size_t index=0;index<lencrible;++index)
total += int(crible[index]);
cout << "Nombre premiers criblés famille " << fam << " entre "<< n << " et " << n2 <<": " << total << " time " << (clock()-cl)*1e-6<< endl;
return total;
}
int main(int argc,char ** argv){
vector<unsigned> crible;
ulonglong N;
int fam=1;
if (argc>1){
N=atoll(argv[1]);
if (argc>2)
fam=atoi(argv[2]);
}
else {
cout << "Syntaxe " << argv[0] << " N fam. Donnez N puis fam: " ;
cin >> N;
cin >> fam;
}
double sqrt2N=unsigned(std::sqrt(2*double(N)));
fill_crible(crible,sqrt2N);
vector<ulonglong> premiers;
for (ulonglong p=7;p<=sqrt2N;){
premiers.push_back(p);
p=nextprime(crible,p);
if (p==unsigned(-1))
break;
}
GCrible(premiers,N,fam);
cin>>N;
}
installer codeblocks sous windows (selectionner le setup codeblocks + mingw pour installation)
Puis File>New>Empty File
puis Build>Compile et Run
Passe une bonne soirée A+
Cordialement LEG
#469 Re : Café mathématique » La mort du mathématiques » 06-12-2018 07:44:05
Bonjour
@Math.82: Ce qui est triste, c'est de prendre ton cas pour une généralité....par ce que tu as atteins tes limites.
#470 Re : Programmation » crible en python » 04-10-2018 19:51:14
RE,
Le 0 n'a rien à faire dans un crible, pourtant...
Curieux !
@+
je suppose que tu fais allusion à l'index = 0
Ce qui est vrai , car on travaille par famille et la famille en question dans ce crible est la famille 1, donc si le reste de 2n%Pi = 1; l'index de 1 par 30 serra bien = à 0 .
d'où la première cellule [1] a pour indice 0 , la cellule d'indice 1 vaut 31 ; 61 ;....etc 1 + 30k.
Si je crible la famille 7, la cellule d'indice 0 vaut 7 ; puis 37 ; 67 ;..etc 7 + 30k. Donc si le reste de 2n%Pi est 7 , l'indexe = 0.....etc
#471 Re : Programmation » crible en python » 04-10-2018 19:33:27
re : pour info, j'ai remplacer le crible _G(n), qui crible de 0 à n... de la première page par la version modifiée . qui s'inspire de la dernière version ci-dessus qui crible par famille ... GCrible(premiers, n, 1) il suffit de remplacer le 1 par {7,ou 11,13,17,19,23, ou 29}
@+
#472 Re : Café mathématique » Ecrire les théorèmes sous forme d'une impossiblité » 11-09-2018 07:27:57
Bonjour
je ne vois pas ce que cela changerai, vraiment .... En prenant ton exemple:
Le carré de l'hypoténuse est = la somme des deux carrés des cotés de l'angle droit..
Tu préfères dire: qu'il n'existe pas de triangle rectangle dont la somme des carrés, des cotés de l'angle droit, n'est pas = au carré de l'hypoténuse
On a d'un coté: existe t'il un triangle rectangle dont la surface est un carré....
Et de l'autre la réponse: la surface du triangle rectangle n' est jamais un carré ....
autrement dit un rectangle n'est pas un carré......c'est vrai qu'on c'est quoi faire....La somme des cotés de l'angle droit, n'est pas égale à la longueur de l'hypoténuse ....
Bon courage à celui qui va réécrire tous les théorème....qui ne sont pas intuitifs....
#473 Re : Programmation » crible en python » 09-09-2018 10:28:31
Bonjour
Salut @Yoshi.
j'ai une petite question (ça n'a pas grande importance..)
Dans le premier crible de base :Crible_G(n), il crible dans l'ensemble des entiers naturels 0,1,2,3.....n
le programme marque toujours la première cellule [1] qui correspond à 1...de ce fait , même si je n'ai pas de reste r = j = 1, il me compte un nombre premier en moins..par exemple 46 au lieu de 47 pour n = 300, 53 au lieu de 54 pour 330,....etc 56 au lieu de 57; n = 360...pour n = 390 c'est ok car il y a un reste R = 1
le programme est :
import os
import math
def eratostene(n):
n = int((2*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
def premiersNa2N(n):
#liste1 = eratostene(n*2)
liste = crible_G(n)
print("> Avec goldbach: On compte " + str(len(liste)) + " nombres premiers entre " + str(n) + " et " + str(2 * n))
def crible_G(n):
nombres = n*[1] # (0, puis n*[1]cela crée une erreur de -1 au final, du fait que l'on ne commence pas par 0
nombres[0] = 0
p = eratostene(n)
pi = p
r = []
for i,pi in enumerate(pi):
r.append(2*n % pi)
j = r[i]
while j <= n:
nombres[j-1] = 0
j += p[i]
premiers = []
for i in range(n-1, 0, -1):
if nombres[i] == 1:
premiers.append(nombres[i] == 1)
#print(r)
return premiers
n = int(input("Donnez la valeur de N : "))
premiersNa2N(n)
os.system("pause")
le programme devrait partir de 0,1,2,3....n car si il y a un reste R = 0 soit il part de 0 soit il part directement de Pi, puis il marque [0] par pas de Pi....
donc mon petit fils en fin de programme
avait mis l'instruction suivante , pour corriger cette erreur de 1 nombre...
premiers = []
#print("√2N = "+str(int(math.sqrt(2*n))))
for i in range(n-1, 0, -1):
if nombres[i] == 1:
premiers.append(nombres[i] == 1)
# on regarde si il y a un reste égal à 1
resteUn = 0
lenr = len(r)
for i in range(lenr):
if r[i] == 1:
resteUn = 1
# si aucun reste n'est égal à 1 2*n-1 est premier
if resteUn == 0:
premiers.append(nombres[i] == 1)
return premiers
mais je pense que c'est idiot de rappeler tous les reste r pour vérifier si il y a un reste r = 1 et si il n'y en a pas on rajoute un nombre premier au total....
alors que l'on devrait partir de 0, si R = 0 ou de Pi directement sans marquer la première cellule 1 = [1] en [0] il me semble que cela provient du fait qu'il commence à compter 0,1,2...etc...
donc lorsqu'il y a un reste R = 0 et bien il change la première cellule [1] = 1, en [0] alors qu'il ne devrait pas....lorsque le reste R = 1, pas de problème...le compte est bon ...
je suppose que la première ligne du programme, devrait commencer par la cellule 0 = [0], puis n * [1].....?????
def crible_G(n):
nombres = n*[1] # (0, puis n*[1]cela crée une erreur de -1 au final, du fait que l'on ne commence pas par 0
nombres[0] = 0
....
Si tu as une idée...sinon ce n'est pas grave...@+
#474 Re : Programmation » crible en python » 28-08-2018 07:26:13
Re
Ah ,ok. Tu as parfaitement raison..car en effet, au maximum J serra toujours < pi*30 et d'autant plus, si on ne travaille que par Famille.
par exemple on crible la famille 1 modulo 30, on va traiter les j jusqu'à j%30 == 1.
Si dans la ligne de code à : fin , je paramètre l'instruction ....,min(pi*30,n)....
et que j'édite les j ; pour N = 300 ; pour $P_i\leqslant\sqrt{600} = 23$ le dernier j serra 255 + 46 = 301 , mais il va imprimer 255 et il traitera bien 301; donc, il s'arrête bien en dessous de la limite maxi = 690 possible , pour les 8 fam par ex..
la liste des 8 j > r = nn%pi qui seraient à traiter, sont :
{2+pi : 25, 71, 117, 163, 209, 255, 301 } fin; ( 347, 393, 439, 485, 531, 577, 623, 669.) # Ensuite on rebouclerait pi*30 + j donc, sur 25 + 690..etc..
Alors que si je met pour fin : ....,min(pi*30,nn).... pour n =300 , le dernier j imprimé serra 577, donc il traitera aussi 623....pour rien puisque l'on ne veux que j %30 == 1, donc 301.
Et pour fin : ....,pi*30,.... il va jusqu'à j = 669 multiple de 3.
Tu vois que pour des valeurs n = 27 000 000 000 , ou plus, cela risque de faire quand même beaucoup de j à itérer et à traiter pour rien ; si on ne limite pas fin à :min(pi*30,n).... " avec un seul n. Cela n'enlèverai rien au résultat final...mais inutile.
#475 Re : Programmation » crible en python » 27-08-2018 16:34:16
Bonjour
Salut@Yoshi
j'ai fait un peu le tour du programme , et on ne peut pas faire plus...Ce qui me convient parfaitement.
la ligne d'instructions :
for i,pi in enumerate(Primes_init):
r=nn%pi
debut,fin,pas=r+pi*(1-r%2),min(1+r+pi*29,nn),pi*2
joue bien son rôle de limite des j qui sont traités à la volée un par un...Je pensais qu'il traitait tous les j jusqu'à fin, c'est à dire les 15 J par séquence, ou par Pi, il n'en est rien.
je l'ai vérifié sur différente valeur de 30k en éditant les J, et en comparant avec fin = pi*30 uniquement, c'est à dire
debut,fin,pas=r+pi*(1-r%2),pi*30,pi*2
juste une question pourquoi dans cette ligne de programme , à l'instruction fin , tu as mis nn ; min(pi*30,nn) et non pas n tout seul c'est ce que j'ai fait ...
voici mon bloc de programme que j'ai modifié pour ne travailler que par famille, et comme tu le vois c'est l'avant dernière version...il y a 2 à 3 secondes d'écart avec la dernière version ...ils fonctionnent impeccables.
def CribleG3Y_mod30(n) :
# INITIALISATION
global nombres,nbcell
start_i= time()
Primes_init = eratostene(n)
nn,nbcell = n*2,n//30
nombres = []
for i in range(1):
nombres.append([1]*nbcell)
P8 = {1:0} #pour 8 fam remettre les 8[1,7,...,29]
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):
j = nn%pi
debut,fin,pas = j+pi*(1-j%2),min(pi*30,n),pi*2
Fam = [0] #pour 8 fam remettre les 8[0,0,...,0]
for j in range(debut,fin,pas):
if j%30 == 1: # changer le paramètre pour une fam fxée
fam = P8[1] # changer le paramètre par fam fixée, pour P8fam remettre [j%30]
if not Fam[fam]:
Fam[fam] = 1
debut_index = j//30
Nombres_fam = nombres[fam]
for index in range(debut_index, nbcell,pi):
Nombres_fam[index] = 0
je te met les tests jusqu'à 30 000 000 000, par tranche de 3 000 000 000 , pour le criblage de la famille J%30 == 1 ...résultat du nombres de nombres premiers q = 29%30 entre n et 2n.
On peut remarquer qu'il est assez linéaire , jusqu'à 27 000 000 000 ensuite pour la dernière tranche " ce qui est assez curieux d'ailleurs " il patine dans la semoule...je suppose qu'il arrive au bout de ses possibilité en mémoire et donc il rame grave....
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 0.4212009906768799 seconds ---
Bloc S2_s3 : 12.38642168045044 seconds ---
2271979
Extraction des premiers n à 2*n : 0.7644011974334717 seconds ---
** 16889354 nombres trouvés en 13.572023868560791 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 6000000000
Phase d'initialisation: 0.7176012992858887 seconds ---
Bloc S2_s3 : 25.755645036697388 seconds ---
3179221
Extraction des premiers n à 2*n : 1.5288028717041016 seconds ---
** 32748571 nombres trouvés en 28.002049207687378 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 9000000000
Phase d'initialisation: 1.029601812362671 seconds ---
Bloc S2_s3 : 40.06087040901184 seconds ---
3777621
Extraction des premiers n à 2*n : 2.277604103088379 seconds ---
** 48272991 nombres trouvés en 43.36807632446289 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 12000000000
Phase d'initialisation: 1.1856024265289307 seconds ---
Bloc S2_s3 : 55.770097732543945 seconds ---
4441039
Extraction des premiers n à 2*n : 3.0420053005218506 seconds ---
** 63579183 nombres trouvés en 59.99770545959473 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 15000000000
Phase d'initialisation: 1.419602632522583 seconds ---
Bloc S2_s3 : 71.6509256362915 seconds ---
4877519
Extraction des premiers n à 2*n : 3.790806770324707 seconds ---
** 78726833 nombres trouvés en 76.8613350391388 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 18000000000
Phase d'initialisation: 1.7940030097961426 seconds ---
Bloc S2_s3 : 89.48175716400146 seconds ---
5562837
Extraction des premiers n à 2*n : 4.570807933807373 seconds ---
** 93754572 nombres trouvés en 95.84656810760498 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 21000000000
Phase d'initialisation: 2.106003761291504 seconds ---
Bloc S2_s3 : 105.17538475990295 seconds ---
5744411
Extraction des premiers n à 2*n : 5.335209131240845 seconds ---
** 108685478 nombres trouvés en 112.6165976524353 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 24000000000
Phase d'initialisation: 2.3556039333343506 seconds ---
Bloc S2_s3 : 120.88461256027222 seconds ---
6144439
Extraction des premiers n à 2*n : 6.099610805511475 seconds ---
** 123530551 nombres trouvés en 129.33982729911804 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 4.321207523345947 seconds ---
Bloc S2_s3 : 337.5377926826477 seconds ---
6506779
Extraction des premiers n à 2*n : 7.1760125160217285 seconds ---
** 138301355 nombres trouvés en 349.0350127220154 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 2.542804479598999 seconds ---
Bloc S2_s3 : 138.07584238052368 seconds ---
6506779
Extraction des premiers n à 2*n : 6.80161190032959 seconds ---
** 138301355 nombres trouvés en 147.42025876045227 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 2.542804479598999 seconds ---
Bloc S2_s3 : 136.59383988380432 seconds ---
Extraction des premiers n à 2*n : 6.848412275314331 seconds ---
** 138301355 nombres trouvés en 145.98505663871765 secondes ** ""je suppose qu'il y a eu un bug""
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====## V. 6.2 ##
Donnez la valeur de n = 30k : 30000000000
Phase d'initialisation: 4.134007453918457 seconds ---
Bloc S2_s3 : 6937.051384449005 seconds ---
Extraction des premiers n à 2*n : 46.768882036209106 seconds ---
** 153006648 nombres trouvés en 6987.954273939133 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4Y_modulo30.py =====## V. 6.3 ##
Donnez la valeur de n = 30k : 30000000000
Phase d'initialisation: 3.8532068729400635 seconds ---
Bloc S2_s3 : 6236.376153707504 seconds ---
Extraction des premiers n à 2*n : 47.28368306159973 seconds ---
** 153006648 nombres trouvés en 6287.513043642044 secondes **
C'est intéressant aussi l'augmentation du nombre de premiers q, par tranche de 3 000 000 000...
Bertrand avec son postulat il va se retourner dans sa tombe....Je plaisante....
@ +
Gilbert .