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).

#151 05-05-2018 06:30:52

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

Re : crible en python

voila une méthode en exemple : que je faisais  pour une pfam: n=1500,Pi==7;  2n%pi = 4

4+7 = 11 puis modulo 7*30 ....<= 1500 famille 11 criblée.
11 +2*7 = 25 =5m pas bon incr +14 = 39 = 3m, +incr 53 %9 == 8 ok + 210....<1500 famille 23 criblée.
53 +14 = 67, %9 == 4 ok +210.....<1500 famille 7 criblée
67 +14 = 81 = 3m pas bon,+ incr = 95 =5m pas bon  +incr =109 %9==1 ok + 210 ...< 1500 famille 19 criblée
109 +14 = 123 = 3m. +incr = 137 %9 ==2 ok +210 ...<1500 famille 17 criblée
.
.etc.etc famille 11 et 29...ok

179 + 14 = 193 %9 = 4 ok  +210...<=1500 dernière famille ==13, Criblée..

retour à Pi == 11, 3000%11 ==8; on réitere ("modulo 330")

8 +11 = 19 %9 ==1, ok +330 ....<=1500 famille 19 criblée
19+2*11 = 41%9==5 ok +330 ...<1500 famille 11criblée
41 + 22 = 3m +22 = 85 +22 = 107 %9 ==5 ok + 330....< 1500 fam 17 criblée
107 + ...etc..etc.
.
.
239 +22 =....etc 283 % 9==4 ok +330...<1500 dernière fam 13 criblée

retour à Pi suivant...etc ...fin du criblage pour n =1500

comptes des valeurs ("congrues à 3000 [Pi]") SANS LES DOUBLONS ce qui pose problème car il faut trier.... pour le bon résultat ... Il ne faut pas oublier, qu'un entier peu être congru de façon unique à l(ordre près de ses facteurs...! ce qui veut dire qu'un congruent aura plusieurs facteur P ....comme un produit...

Mais si tu positionnes les pfam dans le tableau des 8 famille puis à partir de leur position tu crible modulo Pi*30 additivement, et bien tu repassera sur des valeurs qui sont déjà en place donc écrasées ; et dans ce cas plus de Doublons ..c'est pour cela que j'utilise les [1] et [0] moins de place pas d'erreur...et aussi rapide,  car c'est du comptage modulo Pi , selon le principe d'Eratosthène...

En définitive c'est aussi simple qu'Eratosthène, mais en utilisant les congruences...
@+

Dernière modification par LEG (05-05-2018 06:48:22)

Hors ligne

#152 05-05-2018 09:10:58

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Salut,

J'entame la "longue marche"...
3 blocs modifiés, reste 1...
J'ai gagné du temps, environ 10 s pour n=240 000 000:

from time import time
from os import system

def eratostene(n):
    n = int((2*n)**0.5)
    m = (n-1) // 2
    b = [True]*m
    i = 0
    p = 3
    premiers = [2]
    while p*p < n:
        if b[i]:
            premiers.append(p)
            j = 2*i*i + 6*i + 3
            while j < m:
                b[j] = False
                j = j + 2*i + 3
        i += 1
        p += 2
    while i < m:
        if b[i]:
            premiers.append(p)
        i += 1
        p += 2
    return premiers[3:]

def Crible_mod30(n):
    # INITIALISATION
    start_i= time()
    Primes_init = eratostene(n)  
    nn,nbcell,nbcl=n*2,n//30,n//30-1  
    nombres = [[1 for _ in range(nbcell)] for _ in range(8)]
    Pfam,P8=[],[1, 7, 11, 13, 17, 19, 23, 29]
    Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}
    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):
        Pfam.append([0, 0, 0, 0, 0, 0, 0, 0])
        r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2
        for j in range(debut,fin,pas):
            if j%3!=0 and j%5!=0:
                fam =Dico[j%30]      
                if Pfam[i][fam] == 0:
                    Pfam[i][fam] = j
    s_2=time()-start_time
    print("Famille de chaque Pi: : %s secondes ---" % s_2)
   
    #ON CRIBLE LES 8 COLONNES AVEC CHAQUE FAMILLE DE pi
    start_time = time()
    for i,Pf in enumerate(Pfam):
        pi=Primes_init[i]
        for j in range(8):
            debut_index=(Pf[j] - P8[j])//30
            for index in range(debut_index, nbcell,pi):
                nombres[j][index] = 0
    s_3=time() - start_time
    print("Criblage des 8 familles: %s seconds ---" % s_3)

    # CALCUL DES NOMRES PREMIERS ENTRE n ET 2*n
    start_time = time()
    premiers = []
    for i in range(8):
        for j in range(nbcl, -1, -1):
            if nombres[i][j] == 1:
                premiers.append(nombres[i][j] == 1)
    s_4=time() - start_time            
    print("Crible mod30 : Extraction des premiers n à 2*n : %s seconds ---" % s_4)
    return len(premiers),s_1+s_2+s_3+s_4,

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

Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 5.095291376113892 seconds ---
Famille de chaque Pi: : 0.4980282783508301 secondes ---
Criblage des 8 familles: 13.137751579284668 seconds ---
Crible mod30 : Extraction des premiers n à 2*n : 12.212698459625244 seconds ---

**  12194880 nombres trouvés en 30.943769693374634 secondes **

Ancienne version :

Donnez la valeur de n = 30k : 240000000
Crible mod30 : Initialisation: 5.04628849029541 seconds ---
Crible mod30 : Famille de chaque Pi: 0.4650266170501709 seconds ---
Crible mod30 : Criblage des 8 familles: 22.361279010772705 seconds ---
Crible mod30 : Extraction des premiers n à 2*n : 12.386708498001099 seconds ---
temps_total ; 40.259302616119385

**  12194880 nombres trouvés en 40.259302616119385 secondes **

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#153 05-05-2018 09:59:23

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

5 s 1/2 de mieux encore. En tout 15 s/40 : accélération de 37,5 %... par rapport à la dernière version commune que tu possèdes...

Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 5.307303428649902 seconds ---
Famille de chaque Pi: : 0.4650266170501709 secondes ---
Criblage des 8 familles: 10.540602922439575 seconds ---
Extraction des premiers n à 2*n : 8.719498634338379 seconds ---

**  12194880 nombres trouvés en 25.032431602478027 secondes **

from time import time
from os import system

def eratostene(n):
    n = int((2*n)**0.5)
    m = (n-1) // 2
    b = [True]*m
    i = 0
    p = 3
    premiers = [2]
    while p*p < n:
        if b[i]:
            premiers.append(p)
            j = 2*i*i + 6*i + 3
            while j < m:
                b[j] = False
                j = j + 2*i + 3
        i += 1
        p += 2
    while i < m:
        if b[i]:
            premiers.append(p)
        i += 1
        p += 2
    return premiers[3:]

def Crible_mod30(n):
    # INITIALISATION
    start_i= time()
    Primes_init = eratostene(n)  
    nn,nbcell,nbcl=n*2,n//30,n//30-1  
    nombres = [[1 for _ in range(nbcell)] for _ in range(8)]
    Pfam,P8=[],[1, 7, 11, 13, 17, 19, 23, 29]
    Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}
    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):
        Pfam.append([0, 0, 0, 0, 0, 0, 0, 0])
        r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2
        for j in range(debut,fin,pas):
            if j%3!=0 and j%5!=0:
                fam =Dico[j%30]      
                if Pfam[i][fam] == 0:
                    Pfam[i][fam] = j
    s_2=time()-start_time
    print("Famille de chaque Pi: : %s secondes ---" % s_2)
   
    #ON CRIBLE LES 8 COLONNES AVEC CHAQUE FAMILLE DE pi
    start_time = time()
    for i,Pf in enumerate(Pfam):
        pi=Primes_init[i]
        for j in range(8):
            debut_index=(Pf[j] - P8[j])//30
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0
    s_3=time() - start_time
    print("Criblage des 8 familles: %s seconds ---" % s_3)

    # CALCUL DES NOMRES PREMIERS ENTRE n ET 2*n
    start_time = time()
    premiers = []
    for i in range(8):
        Nombres_i=nombres[i]
        for j in range(nbcl, -1, -1):
            if Nombres_i[j] == 1:
                premiers.append(Nombres_i[j])
    s_4=time() - start_time            
    print("Extraction des premiers n à 2*n : %s seconds ---" % s_4)
    return len(premiers),s_1+s_2+s_3+s_4,


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

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#154 05-05-2018 10:13:25

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

Re : crible en python

Bon la marche va être rapide:

voici ton résultat
Donnez la valeur de n = 30k : 240000000
CribleG6 mod30 : Initialisation: 2.8704051971435547 seconds ---
CribleG6 mod30 : Famille de chaque couple R et Pi: 0.12479996681213379 seconds ---
CribleG6 mod30 : Criblage des 8 familles: 11.74682092666626 seconds ---
CribleG6 mod30 : Extraction des premiers n à 2*n : 4.945208549499512 seconds ---
On a 12194880 nombres premiers

Parfait , ce cribleG7, permettra au moins de cribler par famille , en décalant l'ordre de Dico={ 7,0 puis etc..,29:7} et on change la valeur de range(8) en range(1) dans les 3 lignes for in range(1)  tu iras beaucoup plus loin et cela permet de faire une analyse sur la densité de premiers q, de n à 2n , par famille ..etc etc pour les Matheux...de plus avec ce crible ils n'auront aucun mal à démontrer le corollaire du TNP
[tex]\pi{(2n)}-\pi{(n)}[/tex] que l'on peut nommer  [tex]\pi{(G)}[/tex] vaut environ lorsque n tend vers l'infini , [tex]\frac{n}{Ln 2n}[/tex] mais ça n'est pas le plus important...actuellement ...de toutes les façons c'est triviale...

Revenons à ton programme cribleY_mod30
perte de temps dans l'extraction des nombres premiers , j'ai eut le même cas et j'ai modifié  la fin du programme


  [b]premiers.sort()[/b]
    return premiers

n = int(input("Donnez la valeur de n = 30k : "))
[b]nb = len(cribleG6_mod30(n))[/b]
print("On a "+str(nb)+" nombres premiers")
 

dans le crible G4 que tu avais refait ...dans tous les criblesG j'ai remis cette fin...

pourquoi tu perds du temps dans le criblage...?
lorsque ce bloc est sollicité , que fait il exactement

r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2
        for j in range(debut,fin,pas):

1) il calcule les r de 2n%pi ok...
ensuite que fait il  ??  dans les deux lignes qui suivent :

je suppose qu'il va chercher R relatif à son pi
et ensuite il va traiter les j jusqu'à ...pi*29 ....comment exactement..? je met la liste des j pour n=150 de G6 avec R=6 Pi=7, en dessous :

il perd du temps dans cette ligne ...en principe puisque la fin du programme ne change pas par rapport à G6 ;
c'est à dire qu'il range les j dans leur Famille puis il crible J +pi*30 par famille pour ensuite revenir chercher le J suivant cribler la deuxième famille en partant de j et +pi*30 ....etc afin que le criblage se fasse modulo pi * 30 additivement..

et une fois fini les 8fam ,jl retourne chercher Pi, et R suivant ...ok...? il a fait 6+7 = 13 tu remarque ras que l'on aurait pu faire
wile j<= R +pi*29 ce qui évite de traiter 223...mais aucune importance.
#13 masqué par le progra...
27
41
55
69
83
97
111
125
139
153
167
181
195
209
223
@à toi

Hors ligne

#155 05-05-2018 10:28:07

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

Re : crible en python

tu as modifié ce bloc, par rapport à G6 , qui te fait perdre du temps , car en principe la phase criblage est très rapide car
tu marques les cellule modulo pi donc plus Pi est grand, plus le programme accélère :
marquer par famille toutes les pi=7 cellules est plus long que de les marquer toutes les pi=15491.... donc attention lorsque tu modifie le criblage....tu as 8 000 000 de cellules par familles, à cribler....


#ON CRIBLE LES 8 COLONNES AVEC CHAQUE FAMILLE DE pi
    start_time = time.time()
    lenpfam = len(pfam)
    for i in range(lenpfam):
        pi=p[i]
        for j in range(8):
            index = (pfam[i][j] - p8[j])//30
            while index < nbcell:
                nombres[j][index] = 0
                index += pi
 

Hors ligne

#156 05-05-2018 11:13:04

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

Je regarde tes questions...
J'ai l'impression que tu n'as pas vu le post #154 où j'ai encore gagné du temps...

Alors, les boucles while dans les boucles for, ça me donnait des boutons : y en a plus !
Donc, ayant compris le système, j'ai d'abord cherché à optimiser entre les j, les f, les r['i], les j+=incr...
D'abord, fabriquer la liste des restes globalement ou au coup par coup, c'est inutile (la preuve, je m'en passe) : ça bouffe du temps et de la RAM.
Donc ces restes r, je les calcule à la volée...
sir pair alors, debut r+pi sinon, debut = r, ce qui est résumé, avec l'age de booleen, en r=r+pi*(1-r%2)
calcul de r%2
si r%2=0 (pair) 1-r%2 = 1, donc r=r+pi
si r%2=1          1r%2 = 0 , donc r=r+pi*0 pas d'augmentation

Quant à fin, c'est ton f=j+pi*29 qui est devenu fin 1+r+pi*29 : j'ai ajouté 1 puisque tu écrivais while j<= f... Ainsi je dépasse r+pi*29, et si par hasard, les valeurs de j devaient pouvoir arriver à r+pi*29, c'est possible... Sans ajouter 1, non...
Quant au pas, c'est ton incr...
Et la suite est identique à avant.

Ici,

 for i,Pf in enumerate(Pfam):
        pi=Primes_init[i]
        for j in range(8):
            debut_index=(Pf[j] - P8[j])//30
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0

j'ai utilisé une particularité de Python qui piège beaucoup de débutants, regarde :

>>> A=[1,2,3]
>>> B=A
>>> B
[1, 2, 3]
>>> A[1]=10
>>> A
[1, 10, 3]
>>> B
[1, 10, 3]
>>>

Je pars d'une liste A, j'écris B=A... On pourrait croire que j'ai créé une 2e liste B égale à A : et bien, la suite montre que non...
Modifier A, modifie B aussi.
B est un alias de A (allez parlons forum : un pseudo de A)
Donc, quand j'écris : Nombres_j=nombres[j], j'extrais une sous-liste Nombres_j de la liste nombres...
Modifier Nombres_j, modifie automatiquement nombres...
L'avantage c'est que je modifie directement la sous-liste déjà extraite, sans avoir besoin de l'extraire à chaque fois...
Je pourrais d'ailleurs faire la même chose avec Pfam  (il me semblait l'avoir fait)...

Voyons déjà si tu es satisfait de mon explication...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#157 05-05-2018 11:17:23

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

Re : crible en python

il fonce à donf...
RESTART: E:\Documents\conjecture de Goldbach\cribleG7y_modulo30 avec D_C - Copie.py
Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 0.40560054779052734 seconds ---
Famille de chaque Pi: : 0.031200170516967773 secondes ---
Criblage des 8 familles: 0.8424015045166016 seconds ---
Extraction des premiers n à 2*n : 0.4836008548736572 seconds ---

**  1524751 nombres trouvés en 1.762803077697754 secondes **
>>>

Hors ligne

#158 05-05-2018 11:23:36

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

Fichtre, ta machine est une vraie bête de course : 20 fois plus rapide que moi !
Ah non, tu as adapté pour Goldbach !
Quel temps total, pour le calcul de la quantité de nombres premiers entre n =240000000  et 480000000 ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#159 05-05-2018 11:42:14

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

Re : crible en python

yoshi a écrit :

Re,

Je regarde tes questions...
J'ai l'impression que tu n'as pas vu le post #154 où j'ai encore gagné du temps... SI je l'ai copié, et modifié pour ne travailler que sur une fam...

Quant au pas, c'est ton incr...

Voyons déjà si tu es satisfait de mon explication...
@+

le pas tu entends bien criblage modulo pi*30 par famille ..?

extraits pour cribleG7y_mod30 et cribleG6:

RESTART: E:\Documents\conjecture de Goldbach\cribleG7y_modulo30 avec D_C - Copie.py
Donnez la valeur de n = 30k : 15240000000
Phase d'initialisation: 74.63053107261658 seconds ---
Famille de chaque Pi: : 4.882808446884155 secondes ---
Criblage des 8 familles: 74.19473052024841 seconds ---
Extraction des premiers n à 2*n : 29.75025248527527 seconds ---

**  79936681 nombres trouvés en 183.4583225250244 secondes **
je reviens

Hors ligne

#160 05-05-2018 11:46:08

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

Dans ton prog, tu écrivais
incr = pi*2  et bien moi, j'écris pas (la traduction de l'anglais step) : pas =pi*2

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#161 05-05-2018 12:03:07

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

Re : crible en python

Quant au pas, c'est ton incr...

Voyons déjà si tu es satisfait de mon explication...
@+

le pas tu entends bien criblage modulo pi*30 par famille ..?

extraits pour cribleG7y_mod30 et cribleG6:

RESTART: E:\Documents\conjecture de Goldbach\cribleG7y_modulo30 avec D_C - Copie.py
Donnez la valeur de n = 30k : 15240000000
Phase d'initialisation: 74.63053107261658 seconds ---
Famille de chaque Pi: : 4.882808446884155 secondes ---
Criblage des (1) familles: 74.19473052024841 seconds ---
Extraction des premiers n à 2*n : 29.75025248527527 seconds ---

**  79936681 nombres trouvés en 183.4583225250244 secondes **

Avec G1-G6
Donnez la valeur de n = 30k : 240000000
CribleG1_mod30 : Initialisation: 0.37440037727355957 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 0.031200408935546875 seconds ---
CribleG1 mod30 : Criblage des (1) familles: 1.419602394104004 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 0.6240010261535645 seconds ---
On a 1524751 nombres premiers
>>>
>>>
==== RESTART: E:\Documents\conjecture de Goldbach\cribleG1_par Famille.py ====
Donnez la valeur de n = 30k : 15240000000
CribleG1_mod30 : Initialisation: 24.570043087005615 seconds ---
CribleG1 mod30 : Famille de chaque couple R et Pi: 3.541206121444702 seconds ---
CribleG1 mod30 : Criblage des (1) familles: 115.8458034992218 seconds ---
CribleG1 mod30 : Extraction des premiers n à 2*n : 37.59606575965881 seconds ---
On a 79936681 nombres premiers

pour ta demande:

= RESTART: E:\Documents\conjecture de Goldbach\cribleG6_modulo30 avec D_C.py =
Donnez la valeur de n = 30k : 240000000
CribleG6 mod30 : Initialisation: 2.9172050952911377 seconds ---
CribleG6 mod30 : Famille de chaque couple R et Pi: 0.10920023918151855 seconds ---
CribleG6 mod30 : Criblage des 8 familles: 11.637620449066162 seconds ---
CribleG6 mod30 : Extraction des premiers n à 2*n : 4.94520902633667 seconds ---
On a 12194880 nombres premiers
>>>
= RESTART: E:\Documents\conjecture de Goldbach\cribleG6_modulo30 avec D_C.py =
Donnez la valeur de n = 30k : 480000000
CribleG6 mod30 : Initialisation: 5.694010257720947 seconds ---
CribleG6 mod30 : Famille de chaque couple R et Pi: 0.4680008888244629 seconds ---
CribleG6 mod30 : Criblage des 8 familles: 24.258042812347412 seconds ---
CribleG6 mod30 : Extraction des premiers n à 2*n : 9.812417268753052 seconds ---
On a 23558892 nombres premiers

CONCLSIONS/ils vont pratiquement aussi vite en temps globale ce qui veut dire qu'ont peu aller boire un coup à ta santé et pour ton travail....
je me doutais que le post au dessus aller te faire bondir "avec une famille"...LOLLLLLL
C'est super
@+++

Dernière modification par LEG (05-05-2018 12:08:22)

Hors ligne

#162 05-05-2018 12:43:37

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Salut,

le pas tu entends bien criblage modulo pi*30 par famille ..?

alors, je ne sais pas ce que tu entends, toi, par criblage modulo pi*30 par famille
Je n'ai fait "que" rendre le code que j'avais, rationnel...
Ancienne version :

# FAMILLES POUR CHAQUE Pi
    start_time = time()
    for i,pi in enumerate(p): 
        pfam.append([0, 0, 0, 0, 0, 0, 0, 0])     
        j = r['i]
        f=j+pi*29
        lim=max(lim,f)
        incr = pi*2  <-------- Ton incr est ici ...       
        #  si la terminaison du reste est paire on ajoute directement pi et on verifie
        if j %2==0:
            j += pi         
        while j <=f:
            if j%3!=0 and j%5!=0:             
                fam =Dico[j%30]     
                if pfam['i][fam] == 0:
                    pfam['i][fam] = j
            j += incr  <------- et encore là !

Lorsque j%2 ==0 tu incrémentais j de pi (p['i])
Lorsque j%2 !=0 tu incrémentais j de 2*pi (2*p['i])
D'accord ?

Dernière version :

  # FAMILLES POUR CHAQUE Pi
    start_time = time()
    for i,pi in enumerate(Primes_init):
        Pfam.append([0, 0, 0, 0, 0, 0, 0, 0])
        r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2
        for j in range(debut,fin,pas):
            if j%3!=0 and j%5!=0:
                fam =Dico[j%30]      
                if Pfam[i][fam] == 0:
                    Pfam[i][fam] = j
    s_2=time()-start_time
    print("Famille de chaque Pi: : %s secondes ---" % s_2)

Cette fois je calcule r=nn//pi, soit r['i]=2*n//p['i] (mais je ne le stocke plus !),
et le début de la boucle vaut soir r, soit r+pi (selon que r%2 ==1 ou r%2 ==0)
Puis à chaque tour j est incrémentée du pas fixé, soit 2*pi (l'ancien incr).

Oui, le prog fait bien ce que tu attends..
pfam avec l'ancienne version pour n=1500
[[151, 67, 11, 193, 137, 109, 53, 179], [151, 217, 41, 283, 107, 19, 173, 239], [361, 127, 101, 283, 257, 49, 23, 179], [331, 127, 161, 433, 467, 229, 263, 59], [511, 397, 131, 283, 17, 169, 473, 359], [631, 217, 401, 493, 677, 79, 263, 539], [361, 187, 71, 13, 767, 709, 593, 419], [241, 427, 551, 613, 737, 799, 923, 179], [151, 817, 521, 373, 77, 1039, 743, 299], [991, 7, 581, 253, 827, 499, 1073, 89], [721, 1237, 1151, 463, 377, 979, 893, 119], [1261, 697, 791, 133, 227, 979, 1073, 509], [721, 1357, 191, 403, 827, 1039, 1463, 509]]

Pfam avec la nouvelle version :
[[151, 67, 11, 193, 137, 109, 53, 179], [151, 217, 41, 283, 107, 19, 173, 239], [361, 127, 101, 283, 257, 49, 23, 179], [331, 127, 161, 433, 467, 229, 263, 59], [511, 397, 131, 283, 17, 169, 473, 359], [631, 217, 401, 493, 677, 79, 263, 539], [361, 187, 71, 13, 767, 709, 593, 419], [241, 427, 551, 613, 737, 799, 923, 179], [151, 817, 521, 373, 77, 1039, 743, 299], [991, 7, 581, 253, 827, 499, 1073, 89], [721, 1237, 1151, 463, 377, 979, 893, 119], [1261, 697, 791, 133, 227, 979, 1073, 509], [721, 1357, 191, 403, 827, 1039, 1463, 509]]

Strictement la même !
Rassuré ? Convaincu ?

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#163 05-05-2018 14:10:21

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

Re : crible en python

Il y a longtemps que tu m'as convaincu et rassuré... j'ai compris ta modif..

Est ce que le criblage selon le principe d'Eratosthène que je t'ai expliqué plus Haut t'as convaincu...et son fonctionnement ..
il est clair qu'aucun Matheux, n'ayant étudié ce crible de Goldbach , car je l'ai découvert il y a une dizaine d'année, lorsque je m'intéressais à cette conjecture ..j'étais plus penché sur le crible Eratosthène que j'avais aussi construit mod 30 selon ce même principe en 2002...


je voudrai quand même que tu arrives à comprendre le fonctionnement du crible une fois que les j de pfam et positionné dans p8 = Dico= les 8
familles . avec pfam (0) et les 8 famille 30k +1 ou P[7;29]

ligne (0): c'est celle de 1 et des 7 premiers  soit :
Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7} qui sont remplacé par des [1]

Tu as pi=7 ; R = 4  pour :n = 1500 , . Chaque ligne augmente de 30.ok Ce qui va te donner les 8 j pour la pfam n° 0

ta pfam(0)=:
[151  , 67  , 11  , 193  , 137  , 109  , 53  , 179]

peux tu placer tes 8j dans les 8familles... et cribler modulo 7 par pas de 7 "ce qui correspond à modulo 210 c'est à dire par pas de 210 entre deux valeurs d'une même famille ou même colonne"

je place la première valeur de j 151 dans sa famille 1[30] et je crible mod 7 (par pas de 7) une seule fois...je n'oublie pas de changer le 1 en 0., (c'est ce que fait l'algorithme de Goldbach, ("Eratosthène modulo 30"), mais dans les congruences '"ou dans les multiples de P avec l'autre crible Ératosthène.").)

[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1] équivalent à [1 . 7 . 11 . 13 . 17 . 19 . 23 . 29] 8 colonnes = 8 fam [30]
[1 . 1 . 1 . 1 . 1 . 1 . 1 . 1] <..............>[31.37. 41 . 43 . 47 . 49 . 53 . 59]
[1 . 1 . 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 . 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]
[0 . 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 . 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]

à toi pour les 7 autres j dans leur famille modulo 30 c'est à dire tu vas cribler par pas de 7 en partant de la valeur de j relatif à cette pfam (0), dans chacune des 8 familles.
En fonction de l'ordre de Dico = {1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}

Dernière modification par LEG (20-06-2019 10:06:07)

Hors ligne

#164 05-05-2018 14:59:23

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

Là, je sature un peu...
Je mets en pause !

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#165 05-05-2018 15:04:54

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

Re : crible en python

ok sans problème ..Passe un bon week end
@+

Hors ligne

#166 05-05-2018 16:22:29

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,


J'ai repensé à ce que tu appelais plus haut une méthode ch... :

Pour info , il y a une méthode mais qui doit être ch...., à programmer , c'est de copier le masque des Pi cellules et de le recopier Pi ligne en dessous pour les 8 colonne jusqu'à la limite de la dernière ligne (50 pour n=1500) "c'est ce que je fais dans Excel manuellement ça évite de compter..."...

Si c'est juste une histoire de comptage (et qu'on ne veut pas lister ces nombres premiers), en Python ça prend... deux lignes :


from time import time
from os import system

def eratostene(n):
    n = int((2*n)**0.5)
    m = (n-1) // 2
    b = [True]*m
    i = 0
    p = 3
    premiers = [2]
    while p*p < n:
        if b[i]:
            premiers.append(p)
            j = 2*i*i + 6*i + 3
            while j < m:
                b[j] = False
                j = j + 2*i + 3
        i += 1
        p += 2
    while i < m:
        if b[i]:
            premiers.append(p)
        i += 1
        p += 2
    return premiers[3:]

def Crible_mod30(n):
    global Pfam
    # INITIALISATION
    start_i= time()
    Primes_init = eratostene(n)  
    nn,nbcell,nbcl=n*2,n//30,n//30-1  
    nombres = [[1 for _ in range(nbcell)] for _ in range(8)]
    Pfam,P8=[],[1, 7, 11, 13, 17, 19, 23, 29]
    Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}
    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):
        Pfam.append([0, 0, 0, 0, 0, 0, 0, 0])
        r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2
        for j in range(debut,fin,pas):
            Pf=Pfam[i]
            if j%3!=0 and j%5!=0:
                fam =Dico[j%30]      
                if Pf[fam] == 0:
                    Pf[fam] = j
    s_2=time()-start_time
    print("Famille de chaque Pi: : %s secondes ---" % s_2)
   
    #ON CRIBLE LES 8 COLONNES AVEC CHAQUE FAMILLE DE pi
    start_time = time()
    for i,Pf in enumerate(Pfam):
        pi=Primes_init[i]
        for j in range(8):
            debut_index=(Pf[j] - P8[j])//30
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0
    s_3=time() - start_time
    print("Criblage des 8 familles: %s seconds ---" % s_3)

    # CALCUL DES NOMRES PREMIERS ENTRE n ET 2*n
    start_time = time()
    total = 0
    for i in zip(*nombres):
        total+=sum(i)        
    s_4=time() - start_time            
    print("Extraction des premiers n à 2*n : %s seconds ---" % s_4)
    return total,s_1+s_2+s_3+s_4,


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

.. enfin 3 avec la décla de la variable total)0

    total = 0
    for i in zip(*nombres):
        total+=sum(i)

J'ai vraiment découvert et donc utilisé cette fonction de Python, il y a deux mois, lorsque je bossais sur ma multiplication arabe...
zip() travaille normalement sur plusieurs listes à la fois en utilisant l'élément n° 0 de la première liste, l'élément n° 0 de la deuxième...
Là, comme c'est une liste de listes, il faut dire à zip() : dém... toi tout seul avec le nombre de sous-listes - c'est le rôle du *nombres , le nombre de colonnes - i étant vu comme l'index d'une colonne - et fais la somme de chaque colonne (le sum(i) et  ajoute-la au total existant...
Du coup tu n'as pas de dépaqueter toi-même colonne après colonne, pour transférer le contenu de nombres['i][j] dans premiers...
Du coup tu n'as plus besoin de la liste premiers, donc on la vire...

Résultat des courses, j'ai encore gagné 5 s sur 25 soit 20 %...

Depuis le début de la "longue marche", j'ai divisé le temps total par 2 :
Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 5.428310394287109 seconds ---
Famille de chaque Pi: : 0.4350247383117676 secondes ---
Criblage des 8 familles: 10.586605548858643 seconds ---
Extraction des premiers n à 2*n : 3.7572147846221924 seconds ---

**  12194880 nombres trouvés en 20.207155466079712 secondes **

Mais là, on n'en est non plus à gratter l'os, mais le cartilage de l'os...
Va être très très très difficile de faire mieux cette fois (p'têt un p'tit qqchose dans eratostene, mais ça risque de ne pas être fondamental), s'pas...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#167 05-05-2018 18:00:24

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

Re : crible en python

voila ce que j'appelle un masque pour cribler celui ci-dessous
correspond à pi =13 , le programme positionne fam 2 les 8 j dans leur famille et on duplique toutes les 13 lignes [Eratosthène mod 30]
si tu veux voir ce que cela donne sur une feuille excel , je t'envoie le lien...


151  , 67  , 11  , 193  , 137  , 109  , 53  , 179     pi = 7
[151, 217, 41, 283, 107, 19, 173, 239]         pi = 11
361, 127, 101, 283, 257, 49, 23, 179]         pi = 13

..........................................................................
.                        0   
.                    0       
.                           
.        0                   
.    0                       
.                            0
.                           
.                           
.                0           
.            0               
.   
                       
.                           
0                           
.
..............................................................................

Non le maximum tu l'as fait..!  Il marche à merveille..je ne sais pas ce que tu en penses. de ce crible de Goldbach..
je trouve dommage que personne ne l'ai découvert , par conséquent étudié..
peut être que parmi tous les visiteurs cela donnera une idée
sur la répartition des nombres premiers de n à 2n...à quelqu'un.....

En plus il est très simple de modifier l'ordre des familles pour n'en cribler qu'une ou trois..et vérifier Goldbach pour les n = 30k + P8
Où les décomposants de Goldbach  ne sollicite que 3 familles pour vérifier p+q = 2n.. etc etc...

Au moins sur ton site tu peux proposer le crible..si les visiteurs ne ce sont pas déjà servis ....

Dernière modification par LEG (05-05-2018 18:11:11)

Hors ligne

#168 05-05-2018 18:16:21

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

Re : crible en python

Il marche d'enfer ...en effet ....
je viens de remplacer la version de ce matin..
à++
Bravo...

Hors ligne

#169 05-05-2018 18:18:35

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Re,

Ok, intéressant... Envoie !
Mais j'ai encore gagné 5s en passant à travers (court-circuitant ?)  ton masque...
(Tu vas bientôt être obligé d'attacher ta ceinture et d'utiliser des combinaisons anti-G ^_^)
Je ne cherche pas vraiment : j'ai ça dans un coin de mon cerveau, et c'est l'idée qui me trouve et vient me tirer par la manche...
Des fois, ça prend bcp de temps, des fois, ça s'enchaîne, comme aujourd'hui : division du temps global  par 2 !
Si tu veux respecter l'alignement vertical, alors je vais te donner un tuyau...

Nous avions un membre actif de 95 ans (hélas aujourd'hui décédé), féru de cryptographie qui pestait régulièrement contre ce problème...
Alors Fred avait bidouillé une option pour la balise code qui fasse usage d'une police à espacement fixe (je la détourne régulièrement quand j'ai besoin de tableaux) : il suffit comme si tu mets code=Python pour du code Python de remplacer = Python, par = crypto.
Un exemple aujourd'hui, ici : http://www.bibmath.net/forums/viewtopic … 465#p69465
Bon, c'est longuet à mettre en place, sauf à compter les caractères ou espaces (ce que j'ai régulièrement la flemme de faire)...

@+

[EDIT]

Au moins sur ton site tu peux proposer le crible..si les visiteurs ne ce sont pas déjà servis ....

Tu parles de ce forum ?
Ce n'est pas le mien, c'est celui de Fred...

Quel emploi fais-tu de ça pour la conjecture de Goldbach ?
Je vais retourner voir ce qu'elle dit précisément ladite conjecture.

[EDIT2] Voui.. c'est bien ce que je pensais savoir...
Mais en quoi être capable de savoir combien il y a de premiers entre n et 2n, fait-il avancer le schmilblick si on ne récupère pas lesdits premiers ??

Dernière modification par yoshi (05-05-2018 18:28:47)


Arx Tarpeia Capitoli proxima...

Hors ligne

#170 05-05-2018 19:51:51

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

Re : crible en python

Le lien du tableau Excel :

https://www.cjoint.com/c/HEfsxpV1VKK

Ainsi que le fichier Word sur le crible que j'expliquai à mon petit Fils, pour le programme...

https://www.cjoint.com/c/HEfsQTlIr7K

il va pouvoir souffler en septembre car je n'aurai plus besoin de son concour ..Grâce à Toi...! je l'ai prévenu....

je pensais que tu faisais parti des créateurs du site.. Mais ce n'est pas grave, l'intérêt c'est que cela  puisse apporter une réflexion sur ce crible  comme cela à été fait depuis 2000 ans avec Eratosthène  ...notamment pour cette conjecture relié au corollaire du TNP..N // Ln 2N
pour le nombre de nombres premiers entre N et 2N..

Concernant Goldbach ,j'avais besoins pour me convaincre de trouver un crible , de le valider, car les congruences et ce crible m'ont permis de regarder la répartition par Famille , pour 3 familles, et les 8 Familles lorsque le crible énumère tous les nombres premiers q[N;2N]
lorsque le crible pour une limite N progresse  par pas de 15k+1 et 2N, 30(k+1) on se rend compte que les congruents augmente de 30, en partant du principe que si des nombres premiers p sont congrus à 30k [Pi] il est évident qui ne le sont plus pour 30(k+1) en moyenne générale ...maintenant j'en suis convaincu , et que les Matheux peuvent toujours se casser les dents avec des outils mathématique de plus en plus complexes sans Résultat... D'ailleurs il estime qu'il y a au moins un nombre premier q [N;2N] faute d'être capable d'analyser cette fonction (N//Ln 2N)  est de la démontrer rigoureusement à l'aide de l'analyse et des propriété de ce crible , et ensuite peut être qu'il ne seront plus tenus par le postulat de Bertrand...etc ..etc

la dernière version et très rapide pour 240 000 000 , plus vite que la version G6 et G5..
mais il me semble qu'il rencontre un problème pour de granndes  valeurs je vais comparer avec la version de midi G7y, G5 , et donc G8Y

ensuite je mettrai les résultats...surement demain matin...(j'ai vu aussi pour le tableau ok) mais sur excel c'est en couleur HD granD Ecran..LoLLLL

Mais en quoi être capable de savoir combien il y a de premiers entre n et 2n, fait-il avancer le schmilblick si on ne récupère pas lesdits premiers ??[qoute]
Mais la quantité , valider par un crible sans discussion possible...! comme ils l'ont toujours fait en référence à Eratosthène Faute d'avoir Goldbach....De plus, tu sais très que le crible, peut récupérer lesdits premier à la fin en modifiant le bloc:

   premiers = []
   for i in range(8):
      for j in range(nbcell-1, -1, -1):
         if nombres[i][j] == 1:
           premier = 2*n-((j*30)+p8[i])  #en faisant une soustraction 2n - la valeur du nbcell[1] ...
            premiers.append(premier)

  Mais cela ne servirait à rien, car le but est d'estimer parmi les [1] ce qui sont premiers ou composés...quelque soit 2n >16

Bon , j'espère que tu vas passer une bonne soirée un GRand Merci Yoshi...@ +++

Dernière modification par LEG (06-05-2018 06:14:38)

Hors ligne

#171 05-05-2018 20:43:20

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

Re : crible en python

C'est Bon , c'est Bien la dernière version G8Y
1)
RESTART: E:\Documents\conjecture de Goldbach\cribleG8y_modulo30 a.py ====
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 37.1436653137207 seconds ---
Famille de chaque Pi: : 3.603606700897217 secondes ---
Criblage des 8 familles: 113.1313989162445 seconds ---
Extraction des premiers n à 2*n : 24.804043531417847 seconds ---

**  135095831 nombres trouvés en 178.68271446228027 secondes **

2)
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG7y_modulo30.py =====
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 37.5804660320282 seconds ---
Famille de chaque Pi: : 7.0044121742248535 secondes ---
Criblage des 8 familles: 113.64619970321655 seconds ---
Extraction des premiers n à 2*n : 58.890103578567505 seconds ---

**  135095831 nombres trouvés en 217.1211814880371 secondes **

3)
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG5_modulo30.py =====
Donnez la valeur de n = 30k : 3000000000
CribleG5 mod30 : Initialisation: 41.54287266731262 seconds ---
CribleG5 mod30 : Famille de chaque couple R et Pi: 9.547216653823853 seconds ---
CribleG5 mod30 : Criblage des 8 familles: 174.45510625839233 seconds ---
CribleG5 mod30 : Extraction des premiers n à 2*n : 84.98894953727722 seconds ---
On a 135095831 nombres premiers
>>>

Hier soir dans le lien du tableau excel, j'ai oublié de mettre les 3 tables de crible d'Eratosthène mod30 , qui correspondent aux 3 premières pfam cribleG_mod30.
La différence c'est que tu parts de Pi dans le tableau et tu marques en comptant avec chaque terme de pfam Eratosthène...puis tu réitères si du as du temps...
Car il est évident qu'une fois que les 8 termes ont marqué les nbcell, ensuite tu cribles mod Pi par famille comme cribleG_mod30...!

Les voici : Quelque soit Pi, la somme des 8 termes = Pi * 8

S1 , pour P = 7,   est : {12. 7. 4. 7. 4. 7. 12. 3    }               
S2 , pour P = 11, est : {18. 12. 6. 11. 6. 12. 18. 5}                   
S3 , pour P = 13, est : {21, 14, 7,  13, 7, 14, 21, 7}                   
S4 , pour P = 17, est : {27, 18 , 9, 19 , 9 ,18, 27, 9}       

il y a un table d'indexation D unique, pour indexer les 8 tables de P8 = Dico, pour chaque Pi consécutif par Famille ..!   

D =  { 48 ;32; 16 ;32;16;32;48;16 }   

Ex : : la pfam pour P = 37 est :{12. 7. 4. 7. 4. 7. 12. 3} + { 48 ;32; 16 ;32;16;32;48;16 }

et pour P= 127  par exemple: (127 -7)/30 = 4; tu rajoute à pfam 7 , 4*fois la Table D ..etc..

Note: ce sont les mêmes tables pour cribleG une fois que tu as positionné les 8 J , mais il faut ensuite les réordonner..ce qui va compliquer pour un programme et beaucoup de perte de temps...donc inutile..!

Dernière modification par LEG (06-05-2018 07:28:12)

Hors ligne

#172 06-05-2018 08:43:26

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 14 909

Re : crible en python

Salut,

C'est Bon , c'est Bien la dernière version G8Y

J'ai commis une erreur : j'airais dû numéroter mes versions et je n'aurais pas besoin de te demander si tu parles bien de ma version, celle livrée avec la fonction zip()...

Hier soir, tu avais des doutes avec l'utilisation des très grands nombres...

Alors j'explicite mieux mon idée : je suis parti du constat que
- la  liste de listes nombres['i][j] ne contenait que des 1 ou des 0
- que pour chaque 1 rencontré, tu stockais True dans la liste premiers.
- ensuite tu cherchais len(premiers)
J'ai donc alors pensé que si à la source (dans la liste nombres) je faisais la somme de tous les éléments, le 0 n'intervenant pas, alors cette somme serait égale à len(premiers).
J'aurais pu l'écrire :


    total=0
    for sous_liste in nombres:
        total+=sum(sous_liste)

Sitôt dit, sitôt fait : je viens de tester...
Et le résultat me laisse pantois :

Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 5.039288282394409 seconds ---
Famille de chaque Pi: : 0.4610261917114258 secondes ---
Criblage des 8 familles: 10.538602828979492 seconds ---
Extraction des premiers n à 2*n : 0.6150350570678711 seconds ---

**  12194880 nombres trouvés en 16.6539523601532 secondes **

-4 s !!
j'ai recommencé plusieurs fois : à quelques dixièmes près je tourne entre 16 et 17 s au lieu 20 et 21 s..

Ça mérite confirmation de ta part...

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#173 06-05-2018 09:24:56

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

Re : crible en python

[yoshi]Salut,

J'aurais pu l'écrire :


    total=0
    for sous_liste in nombres:
        total+=sum(sous_liste)

Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 5.039288282394409 seconds ---
Famille de chaque Pi: : 0.4610261917114258 secondes ---
Criblage des 8 familles: 10.538602828979492 seconds ---
Extraction des premiers n à 2*n : 0.6150350570678711 seconds ---

**  12194880 nombres trouvés en 16.6539523601532 secondes **
-4 s !!
j'ai recommencé plusieurs fois : à quelques dixièmes près je tourne entre 16 et 17 s au lieu 20 et 21 s..

Ça mérite confirmation de ta part...
@+

Tout d'abord, ATTENTION : tu vas attraper la criblomanite...LoLLLLL
hier soir je pense que cela venait d'un autre programme qui tourner ...
car ensuite je t'ai renvoyé les 3 tests ...pour les numéros c'est pas grave car des qu'un crible est modifié et suffisant je le numérote..
je vais donc tester cribleG8Y  mais il faut par conséquent que je remplace les lignes correspondantes aux nouvelles lignes....

Hors ligne

#174 06-05-2018 09:30:08

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

Re : crible en python

JE CONFIRME :

== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 3.4320061206817627 seconds ---
Famille de chaque Pi: : 0.14040017127990723 secondes ---
Criblage des 8 familles: 7.1760125160217285 seconds ---
Extraction des premiers n à 2*n : 0.5304009914398193 seconds ---

**  12194880 nombres trouvés en 11.278819799423218 secondes **
>>>

je lance 3000000000 comme cela on vérifie par rapport au teste d'hier soir avec G8Y..
@tout de suite

Voila

== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 38.57886791229248 seconds ---
Famille de chaque Pi: : 6.973212003707886 secondes ---
Criblage des 8 familles: 110.10499334335327 seconds ---
Extraction des premiers n à 2*n : 6.177610635757446 seconds ---

**  135095831 nombres trouvés en 161.83468389511108 secondes **

je vais lancer 21 000 000 000
@+

HOAUHHH je viens de modifier une ligne et donc pour 21 000 000 000 il décoiffe....En plus, on peut dire qu'il y a au moins un nombre premier entre 21 000 000 000 et  42 000 000 000
.....Faute de grives on mange du merle.....!

voici :
== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 21000000000
Phase d'initialisation: 165.1418902873993 seconds ---
Famille de chaque Pi: : 18.189632177352905 secondes ---
Criblage des 8 familles: 104.58258366584778 seconds ---
Extraction des premiers n à 2*n : 5.3196094036102295 seconds ---

**  108684761 nombres trouvés en 293.2337155342102 secondes **
>>>

Dernière modification par LEG (06-05-2018 10:02:33)

Hors ligne

#175 06-05-2018 10:28:16

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

Re : crible en python

LEG a écrit :

JE CONFIRME :

== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 3.4320061206817627 seconds ---
Famille de chaque Pi: : 0.14040017127990723 secondes ---
Criblage des 8 familles: 7.1760125160217285 seconds ---
Extraction des premiers n à 2*n : 0.5304009914398193 seconds ---

**  12194880 nombres trouvés en 11.278819799423218 secondes **
>>>

je lance 3000000000 comme cela on vérifie par rapport au teste d'hier soir avec G8Y..
@tout de suite

Voila

== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 38.57886791229248 seconds ---
Famille de chaque Pi: : 6.973212003707886 secondes ---
Criblage des 8 familles: 110.10499334335327 seconds ---
Extraction des premiers n à 2*n : 6.177610635757446 seconds ---

**  135095831 nombres trouvés en 161.83468389511108 secondes **

je vais lancer 21 000 000 000
@+

HOAUHHH je viens de modifier une ligne et donc pour 21 000 000 000 il décoiffe....En plus, on peut dire qu'il y a au moins un nombre premier entre 21 000 000 000 et  42 000 000 000
.....Faute de grives on mange du merle.....!

voici :
== RESTART: E:\executable algo P(30)\cribleG8y_modulo30 avec D_C - Copie.py ==
Donnez la valeur de n = 30k : 21 000 000 000
Phase d'initialisation: 165.1418902873993 seconds ---
Famille de chaque Pi: : 18.189632177352905 secondes ---
Criblage des 8 familles: 104.58258366584778 seconds ---
Extraction des premiers n à 2*n : 5.3196094036102295 seconds ---

**  108684761 nombres trouvés en 293.2337155342102 secondes **
>>>

Voila un autre teste pour 21 000 000 000 qui permet maintenant d'affirmer incontestablement, qu'il y a au moins 8 nombre premiers entre N et 2N
car le Crible d'Eratosthène ou le Crible G8Y , crible façon uniforme les 8 Familles de nombres par conséquent, il y aura toujours une même densité de nombres premiers entre N et 2N et CE , pour chaque Famille de nombres premiers de la forme 3k+1 ou 3k-1 tel que:
30k +{1,7,11,13,17,19,23,29} c'est pas le théorème de Noël mais celui du dimanche...

Voici le nombre de premiers entre N et 2N , congrus à 17[30] l'autre au dessus je pense que tu avais vu la blague c'était  le nombre de premiers entre N et 2N congrus à 13[30] pour N = 21 000 000 000 :

Donnez la valeur de n = 30k : 21000000000
Phase d'initialisation: 130.10422825813293 seconds ---
Famille de chaque Pi: : 14.570425748825073 secondes ---
Criblage des 8 familles: 105.00378465652466 seconds ---
Extraction des premiers n à 2*n : 5.335209131240845 seconds ---

**  108683085 nombres trouvés en 255.0136477947235 secondes **

Bon Dimanche Yoshi...Bravo pour notre CribleG8Y en commun...
@+

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)?
soixante huit plus quatre-vingt dix-huit
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