Forum de mathématiques - Bibm@th.net

[yoshi]Bonjour, 

Aurais-je mal écrit le code hier ? surement..la position des tableau qui est mal interprété il est où ton masque que tu veux coller...?...est il bien orienté...?

Sortie :..............................[sortie cribleG8Y , des 30k+[P8] de 7 à 240
................................................>masque ..........>............> tout est à l'envers...

.[(1), (1), (1), (1), (1),(0),(0),(1)] ........>[451, 457, 461, 463, 467, 469, 473, [479]]
.[0, 1, 0, 1, 1, 0, 1, 1].....> .............................[421, 427,431, 433, 437, 439, 443.[449],.
[0,1, 1, 1, 1, 0, 0, 0].....>  ..........................  [391, 397, 401, 403, 407, 409, 413,[419]                                                         
[1, 0, 0, 0, 1, 1, 0, 1]......> ............................[361, 367, 371, 373, 377, 379, 383,[389]
[1, 1, 0, 1, 0, 1, 1, 0], ....> ............................ [331, 337, 341, 343, 347, 349, 353, [359],.
..[1, 1, 1, 0, 0, 1, 1, 1],....> ............................  [301, 307, 311, 313, 317, 319, 323, [(329)]
..[1, 0, 1, 1, 1, 1, 1, 0]......>.............................  [271, 277, 281, 283, 287, 289, 293, [(299)]
.[0, 1, 0, 0, 1, 0, 1, 1]].....> .............................. [241, 247, 251, 253, 257, 259,263,   [269]

effectivement si on met dans la bonne orientation ligne 1 et colonne 8 bien alignée et dans l'autre sens il se peut fortement que ton programme soit juste.....! je travail dans excel avec des couleurs pour me réorienté...car Galère....

compare ton masque avec celui des  decribleG8Y dans le bon ordre d'orientation..et compare comme suit:
première ligne du masque de gauche à droite avec dernière colonne de Haut en Bas ce qui donne réaligné:
    1. ....31....61... ..91......121....151...181....211
.[(1), .  (1), ..(1),... (1),... (1), ....(0), ..(0),...(1)]  .
[479]] .[449],[419] [389]..[359]..[329] .[299..[269]

C'EST SUPER CHI...

multiple de 3, multiple de 5
comment peux tu avoir dans un tableau de 30k +[P8], une colonne de 3m en deuxième position,???

regarde la réorientation de ta sortie avec l'exemple ci dessus afin de vérifier...

mais ton masque ...
@+

c'est vrai..?, car :
la deuxième colonne sont des 3m ; et il manque la colonne = famille 17modulo 30, Dico= {17:5} , colonne 2 à supprimer ...

[241, 243, 247, 251, 253, 259, 263, 269],
[271, 273, 277, 281, 283, 289, 293, 299],
[301, 303, 307, 311, 313, 319, 323, 329],
[331, 333, 337, 341, 343, 349, 353, 359],
[361, 363, 367, 371, 373, 379, 383, 389],
[391, 393, 397, 401, 403, 409, 413, 419],
[421, 423, 427, 431, 433, 439, 443, 449],
[451, 453, 457, 461, 463, 469, 473, 479]

Si tu fais un masque, la première ligne doit être indicé, afin de bien te poser sur les tableau à partir de la même ligne , c'est donc le premier [0] de la première (ligne ou colonne : sens du criblage) , qui donne (l'indice le rang) de la première ligne.des 8 familles
Par Exemple : si la première cellule [0] à été indexé (3) = 109, colonne dans Dico = {19:5} tu poses ton masque sur la ligne ("sens du criblage ligne ou colonne) d'indice 3

tu les appelles sous liste.. ce ne sont pas des masque ok

[151, 67, 11, 193, 137, 109, 53, 179],.ce sont les cell[0] et leur N° de ligne :[0:5,0:2,0:0,0:6,0:4,0:3,0:1,0:5]
[271, 7, 161, 73, 227, 139, 293, 29],.....
[181, 337, 311, 103, 77, 259, 233, 389],
[361, 157, 191, 463, 497, 259, 293, 89],
[271, 157, 461, 43, 347, 499, 233, 119]

......................................................................................................................
tableau de 8 lignes:[p8]
            [1,7,11,13, 17,19, 23,29]
colonne n°  0, 1 ,2, 3, 4, 5, 6, 7  .....etc......> vers (nbcell = n/30)
........(1). .[1, 1, 1, 1, 1, 0, 0, 1],
........(7). .[0, 1, 0, 1, 1, 0, 1, 1],
........(11) .[0, 1, 1, 1, 1, 0, 0, 0],
....... (13). [1, 0, 0, 0, 1, 1, 0, 1],
....... (17)..[1, 1, 0, 1, 0, 1, 1, 0],
........(19). [1, 1, 1, 0, 0, 1, 1, 1],
........(23). [1, 0, 1, 1, 1, 1, 1, 0],
.......(29). .[0, 1, 0, 0, 1, 0, 1, 1],

Une remarque : tu ne peux pas utiliser un tableau avec les entiers de n à 2n.....! car il faut inverser les familles complémentaires, du fait des congruences ; si un entier A est congru B [Pi]; Pi divise la différence B - A, si A=1, B=30 alors B - A = 29....etc..

passe une bonne soirée @+

ça se cache plus précisément avec ton explication, qui est très limpide et qui explique le prog ligne par ligne ...!
c'est pour cela que je te disais dans mon langage pourquoi ne pas avoir utilisé le quotient de Dico%30
                fam =Dico[j%30]     
.....................................................
donc : dans ce processus ci de-ssous:

suite:

non:

Ok 

On a alors Pf=[0, 0, (11), 0, 0, 0, (53), 0]  au lieu de et automatiquement Pfam=[[0, 0, (0), 0, 0, 0, (1),0]] ...

Ce qui fait Bien éviter le processus : dans le criblage :

suite :

[ etc.."Le dernier j à être testé (quand i == 0) sera j=193..."] Tout à fait...

........................D'OÛ:...............

Il ne reste plus qu'à cribler les 8 familles par pas de pi =7 en partant des index = rang en mettant les [0] à la place des [1] ainsi que tous les 7 pas...jusqu'au rang 8 car il n' y a que 8 rang : 480/30 =8

Puis passer au pi(1) = 11

... EXACTEMENT......

Au lieu de faire deux fois les travail..En recommençant dans la phase S3, le calcule des index avec pfam(0)  et criblage...????
quel est ton avis...??

déjà , même en modifiant ce processus  illogique..ça gagne du temps, même en faisant d'une traie pfan(0)==  [(5),(2),(0), (6), (4), (3), (1), (5)] puis aller cribler, c'est simplifier énormément..
alors que l'on pourrait même, cribler au fur et à mesure que pfam(0) se rempli de ses index....mais est que l'on aurait simplifié et gagner du temp.....pas sur.

car une fois pfam(0) construite : [(5):0,(2) :1 ,(0):2, (6):3, (4):4, (3):5, (1):6, (5):7] pf[j] fait des aller retour  , il prend ses index, change le [1] en [0] ....crible...> par pas de 7, ...> limite nbcell= 480/30= 8... etc les 8 familles..Fin .
les 8 famille sont criblée avec pi=7 . Retour au processus suivant avec pi=11...!

car déjà on y voit plus clair et même très clair , tu peux d'ailleurs, vraiment t'en faire une idée de ce qu'il aurait dû faire....

1. Encore une fois, ce n'est pas ma méthode : moi, je n'ai fait qu'optimiser

, ok pour moi ç'est tout comme puisque cela à modifier les blocs initialisation ,famille pi , criblage,

2) tu imprimes les temps des 4 phases :S1 : initialisation; S2: famille pi ; S3 : criblage et  S4.extraction.
initialisation :
prendre les Pi d'Eratosthène ,
création du tableau :
nn,nbcell,nbcl=n*2,n//30,n//30-1
    nombres=[]
    for i in range(8):
        nombres.append([1]*nbcell)

les famillesP8 =[..] et Dico ={...}
.....................................................
je ne comprends rien à ce genre de notation : si ??? %9 == (2,5,8) que mets-tu à la place de "???"  les 16 j , de R à f= j+2*pi
et pourquoi ?.
pour éviter de faire deux fois le travail en calculant fam dans S2: et ensuite les index dans S3: ce que tu m'as expliqués hier et qui sont la phase crible   cette ligne dans S.2 positionne les "J" fam:
[fam = Dico[j%30]     
        if Pf[fam] == 0:   , tel que ton EX ..............>: pfam(0) ;  Pf=    [151,  67, 11,   193,   137,  109,   53,   179]
dans S.3 on calcul les index.:.......>debut_index=(Pf[j] - P8['j])//30...>  [(5), (2),(0),  (6),      (4),  (3),    (1), (5)] 
.........................................................................................................................................................
le j%9 , permet de tout faire en une étape si  ... d'abord on vérifie les Décimales d_c = j%10J donc si j != D_c==5 on passe au suivant
on a indiqué :    ... " l'ordre de Dico est déjà établi en phase S1"....

A_): si le reste de j %9 == [0,3 6] alors j est multiple de 3 on passe à j suivant

B_):si j %9 ==[1,4,7]  alors j appartient à fam , P8= [1, 7, 13 , 19] et donc si  j = D_c== [1, or 7, or 3, or9], l'index de Pf[j] serra:

debut_index=(Pf[j] - P8['j])//30
            Nombres_j=nombres[j]
.............................................................explication........................................................................................
[" il donne l'index: le quotient , c'est à dire la position ou rang de Pf[j] dans sa famille Dico=[1:0,7:1,13:3,19:5] puis il va marquer [1] en[0]   par pas de pi = 7..donc par pas de 7, toutes ses cellules  seront marqué [0] jusqu'à ...> nbcell qui est le nombres de cellule définie par n//30...  on revient à la suite des j, pour le j suivant.... on réitère   : donc on a la position de [j] et sa famille, il part cribler..pour ensuite passer à j suivant..jusqu'au dernier j qui serra de toutes les façon, <= f== j + pi*29 ..."]
....................................................................................................................................................

sinon:

C_): si j %9 ==[2,5,8]  alors j appartient à fam ,P8= [11 , 17 , 23 , 9} d'où si  j = D_c== [1, or 7, or 3, or9], l'index de Pf[j] serra:
debut_index=(Pf[j] - P8[j])//30 
            Nombres_j=nombres[j]   
qui donne le quotient, donc l'index,  P8j on connais sa place dans Dico={11:2, 17:4, 23:6 ,29:7......}  pf[j] par pas de pi = 7..va marquer toutes ses cellules, qui seront marquées [0] jusqu'à ...> nbcell qui est le nombres de cellule définie par n//30...("principe d'eratosthène")
................................................................................
c'est ce que tu m'as expliqué hier dans ton dernier post  et ma réponse,  on peut  faire S2 et S3  en une étape , [j] après [j] avec le reste %9;  Exemple j=151 : j%9== 7, donc se terminant par 1 c'est la famille 1[30] et Pf[J] - P8[j]//30 == 5 ; l'index ,le rang, la position.. P8[j] = 1  la famille {1:0} dans Dico...on place [j] dans la celllule 5 qui par pas de 7 va marquer d'un[0] ses cellules .....> nbcell == n//30.
..................................................................................
:S2
fam =Dico[j%30]     
                if Pf[fam] == 0:
                    Pf[fam] = j
............................................................
S3:
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
..................................................................................
dans la phase S2 : le programme crée les J à partir du reste R ...>jusqu'à  f=j+2*pi

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:

il classe les j impairs par famille qui ne sont pas 3m , 5m
par :   fam =Dico[j%30]     
                if Pf[fam] == 0:
                    Pf[fam] = j

.............................................
les index il m'a dit que c'était plus facile et rapide ...je lui est dit tu en est sûr...il m'a regardé de haut en rigolant....

4.

p8= [1....7...11...13..17...19...23...29]

..   [(5),(2),(0), (6), (4), (3), (1), (5)] 

par pas de 7. pour chaque colonne (famille) ....>lmite  nbcell==n//30

Tu veux dire quoi avec pas de 7---> nbcell ? que nbcell= 7 ? :
attention ceci  sont les index de ta pfam(0) avec Pi(0) = 7, dans les 8 colonnes de P8j , donc tu comptes par pas de 7 en partant de chaque index , marquer [0] ses cell......> limite nbcell = 8 dans l'exemple que tu as cité , dans tes explications...
.........................................

pour moi index je n'en savais rien ...pour moi pf[j] ==151 , est placé au rang 5, famille 1[30] et 151 est  dans la liste des j le cinquième sans les 3m et 5m..., Pf[j] =193 est le dernier de pfam(0) pour Pi(0) une fois que le dernier Pf[j] a criblé, on passe au couple Pi(1) R(1)
et on réitère ...Pourquoi établir une pfam(1), alors que l'on traite au fur et à mesure les pf[j]...? suite aux explication que tu m'as fournie....

dans le processus des phases S1, (S2.S3)== S3, puis S4 devient S3....à mon sens ...@+

Bien sûr, vous travaillez dans le programme avec des indexes et vous comptez bien par pas de Pi dans la phase 2....pour chaque début d'index, mais dans la phase 1; famille de pi :
tu as traité les [j] construit les pfam et elles sont déjà "indexé" par famille et surement par Dico={.....}

Or dans cette phase 1 , si pfam[0] est déjà ordonné par famille  [j] devrait déjà être indexé...est donnée :pfam[0] indéxé..

{1:0,  7:1, 11:2, 13:3 , 17:4, 19:5 ,23:6 ,29:7}

[151,  67, 11,   193,   137,  109,   53,   179],                        --->Pf =   Pfam[0]  ;  pi=Primes_init[0] = 7
[(5), (2), (0), (6),  (4),   (3),    (1),   (5)]    les indexes --->Pf =   Pfam[0]  ;  pi=Primes_init[0] = 7
.

voila ce que je pensai : dans l'ordre:
n=240
nbcell=240//30=8 (de 0 à 7)
Primes_init=[7, 11, 13, 17, 19]  récupérés grâce à l'appel à la def eratostene.
............R=[4,  7, 12 , 4 ,  5]
puis :
phase (1) famille de pi tu as traité les 3m et 5m au fur est à mesure

j= [11, 53, 67, 109 , 137 ,179 , 193, 151] les [j] à partir de là, phase 1, (tu peux obtenir l'indice et l'index) moi je faisais:

J[0]== 11,  d_c == 1 , 11%9 == 2 ok 11 = Dico%30 == 0 , et 11:2 index 0 puis par pas de 7==[0]...> nbcell.retour
J[1] == 53 , D_c== 3 , 53%9 == 8  ok 53 = Dico%30 == 1, et 23:6 index 1 puis par pas de 7==[0]...>nbcell et retour
J[2] == 67 , D_C==7, 67%9 == 4  ok 67 = Dico%30== 2  et  7:1  index 2, puis par pas de 7==[0]>nbcell et retour
J[3] == 109 ,D_c== 9, 109%9 == 1  ok109 Dico%30 == 3 et 19:5 index 3, par pas de 7 ==[0] ...>nbcell retour
J[4]==137 , D_c==7, 137%9 ==2 ok, 137Dico%30== 4  et 17:4   index 4, par pas de 7==[0]...>nbcell retour
J[5] == 179, D_c == 9 179%9 == 8 ok 179 Dico%30 ==5 et 29;7 index 5 , par pas de 7==[0] ...Nbcell retour
J[6]==193,  D_c== 3  193%9 ==4 ok 193 Dico%30  ==6 et 13:3 index 6, par pas de 7==[0] ..>nbcelle retour
J[7] == 151 D_c== 1  151%9 ==7 ok 151 Dico%30  ==5 et  1:0 index 5, par pas de 7==[0] ..>nbcelle  fin pour pi==7 retour

au Pi suivant ==11 et pfam[1] réitération...  comme ci dessus...

[271, 7, 161, 73, 227, 139, 293, 29],                  --->Pf =   Pfam[1]  ; pi=Primes_init[1]  =11
..............................................................
colonnes = p8
[1 ,7 11,13,17,19,23,29]

  phase 3 criblage :

pfam[0] et pi[0]=7, par pas de 7, )à partir de l'index ....> nbcell

[(5),(2),(0), (6), (4), (3), (1), (5)]

[1, 1, 0, 1, 1, 1,1, 1],   -ligne ,nombre(0)
[1, 1, 1, 1, 1, 1, 0, 1],  -----,------   (1)
[1, 0, 1, 1, 1, 1, 1, 1],  -----,------- (2)
[1, 1, 1, 1, 1, 0, 1, 1],  -----,--------(3)
[1, 1, 1, 1, 0, 1, 1, 1],  -----,--------(4)
[0, 1, 1, 1, 1, 1, 1, 0],  -----,--------(5)
[1, 1, 1, 0, 1, 1, 1, 1],  - ---, --------(6)
[1, 1, 0, 1, 1, 1, 1, 1]   -----,--------(7)

nbcell = n/30 = 8 lignes , initialisation des 8 colonne de cellules qui se fait au début..du programme
...............................

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

Pfam : ok tu as été jusqu'à la limite indiquée par donc j wile <= f == pi*29
étant donnée que les pfam [n] sont initialisées dans la phase 1, puis les [j] sont indexés par leurs famille , Dico={1:0,7:1,11:2,.....29:7}//30

sans les 3m et 5m alors, elles restes dans l'ordre :

[(5),(2),(0), (6), (4), (3), (1), (5)]  par pas de 7........> nbcell
[151, 67, 11, 193, 137, 109, 53, 179],   --->Pf =   Pfam[0]  ;  pi=Primes_init[0] = 7 :

["donc tu as fait un calcul pour ordonner les [j] de pfam[0], par rapport à leur famille...en éliminant les 3m et 5m; A priori  cette phase est rapide....vu le test avec G9Y
Puis tu recalcules les indexes, ([j] - Dico [8])//30 pour ensuite cribler par pas de Pi...ok..."] c'est ce que je ne comprenait pas (indice, index..moi je disais position.. ["mais c'est vrai, une fois que le langage serra compris est défini dans ma tête ça ira..ça ira..."]

Donc il se peut que ma méthode, soit plus compliquer et moins rapide..que ta méthode mais dans la phase 1 :on peut indexer avec les D_c , et %9 sachant qu'à la base: si %9 == (2,5,8) ....> alors p8 =={11,17;23 29} et D_c == {1, 7, 3,9} dico%30 == {11:2,17:4;23:6,29:7} d'où le quotient donne l'index dans sa famille d'où, il ne reste plus qu'à marquer d'un[0] sa cell et par pas de Pi, marquer ses cell.[0]..> nbcell et il sort.

la limite peut toujours rester <= F==pi*29, car des l'instant où le dernier J[7] de sa pfam[n] à fini et indiqué l'index pour Pi et que ce dernier à fini de marquer [0] par pas de pi dans sa famille ...>nbcell. La limite était pour cette pfam j <= F== (R +29*30) = 214 ne serra pas atteinte par le dernier[j] ...

Peut être que c'est pour cette raison qu'il a indexé comme cela ....?,
Mais il t'a fallu sacrément décrasser et réordonner...Je ne sais pas si cette forme ci dessus pour indexer %9 et indiquer les familles, te donnera des idée , du gain de temps, {"du fait que les indexes ne sont plus à "calculer"après avoir ordonné les pfam[n]..
la il sont invariables., quelque soit n . Car les D_c et %9 sont invariable seule le quotient de %9 qui va donner l'index de [j] va changer, en fonction de la limites 2n%pi qui donne les couples pi et  les reste R... Dans les deux cas c'est pareil...

En tous les cas, il marche à merveille ,tu as pu t'en rendre compte avec les résultats que tu m'as demandés...

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

[181, 337, 311, 103, 77, 259, 233, 389],            --->Pf =   Pfam[2]  ; pi=Primes_init[0] = 13
[361, 157, 191, 463, 497, 259, 293, 89],             --->Pf =   Pfam[3]  ; pi=Primes_init[0] = 17
[271, 157, 461, 43, 347, 499, 233, 119]              --->Pf =   Pfam[4]  ; pi=Primes_init[0] =19

ok je comprend , tu as les 5 pfam indice de 0 à 4, et leur pf ......>ok.....................>0k

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

voila pour cette soirée , j'espère que j'ai été compréhensif...et que ton avis serra très bien venu...avec un GRAND Merci
@+ Yoshi..Gilbert.

je t'ai donné la liste des résultat post de 11h19 au dessus ...jusqu'a 27 900 000 000 on été bloqué à 23 9400 000 000 et je ne connais pas encore la limite maxi....

avec ma dernière version G9Y  que j'ai modifié ce matin et qui comporte bien:

qui est excellente !!!

on a presque divisé le temps par deux 1/2 ; par rapport à G8Y , toujours pour une famille criblée..!
regarde les résultats du post de ce matin à 9h34..

pour ta question effectivement je ne comprend pas exactement ce que fait cette ligne de programme...!
pas plus qu'il m'a fallut attendre Hier soir en faisant les testes par famille, que ce que l'on croyait cribler était en faite les familles complémentaires de Goldabch c'est en vérifiant avec [nbpremier win32] ("Eratosthène modulo 30, qui lui crible de 7 à N") que le résultat que j'imprimai :[  print (nombre) ] était en fait, pas le résultat de la famille que j'étais en train de cribler de n à 2n, mais celui de sa famille complémentaire ...ce qui ne change rien sur le résultat final des 8 familles , mais famille par famille c'est différent..

1) résultat pour 240 000 000 : 1 seconde...
========== RESTART: E:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 240000000
Phase d'initialisation: 0.07800030708312988 seconds ---
Famille de chaque Pi: : 0.062400102615356445 secondes ---
Criblage des 8 familles: 0.8736014366149902 seconds ---
Extraction des premiers n à 2*n : 0.06240034103393555 seconds ---

**  1524685 nombres trouvés en 1.076402187347412 secondes **

2 ) un exemple des 8 familles cribler pour n = 150 , je t'imprime les nombres , c'est à dire les cellules où le crible, commence dans un sens ou dans l'autre ce que l'on pourrait croire ,or il n'en ai rien grâce à Dico ={....} qui m'a fait comprendre le sens du criblage dans le programme...

CribleG6 mod30 : Initialisation: 0.0 seconds ---
CribleG6 mod30 : Famille de chaque couple R et Pi: 0.0 seconds ---
CribleG6 mod30 : Criblage des 8 familles: 0.0 seconds ---
CribleG6 mod30 : Extraction des premiers n à 2*n : 0.0 seconds ---
[[0, 1, 1, 0, 1], [1, 1, 1, 0, 1], [0, 0, 1, 1, 0], [0, 1, 1, 1, 1], [1, 0, 1, 1, 1], [1, 1, 0, 1, 0], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]]
On a 27 nombres premiers

cette première colonne criblée par la famille 1[30]

[0, 1, 1, 0, 1] corespond au nombre premiers de la famille 29 [30]

179  +121
0     +91 marqué ==[0]
239  +61
269  +31
0     +1 marqué [0]

..............................................

Tu peux me détailler exactement ce que fait cette ligne, avec un ou deux exemples :

car ce que je pense comprendre,  c'est la relation qu'il y a entre les 8 j d'une pfam , par exemple les 8, de pfam(0) et don Pi==7; {"puisque pour chaque changement de valeur de la limite n +30, on réitère en repartant de Pi==7..."}

et les P8j une fois les testes %30 fait, afin de les positionner dans leur famille...ensuite P_j ou P_i crible...

pour moi c'est la méthode du programme qui va réduire les divisions qui peuvent rentrer en jeu c'est tout....je suppose.....

Exemple: j'ai mon premier j en partant de R...ok  donc j(0), qui peut être R,des l'instant où il est impair...!

Moi je faisais %9 trois solutions possibles sur un seul teste ok...j'ai vu aussi qu'il ne se termine pas par 5 car sinon != (incr == 2*pi)

j'obtiens  :
a) : {1,4,ou7} ;
par conséquent il appartient une des 4 familles {1,7,13 et 19} ok en fonction de sa D_c je connais exactement sa famille ...je part le positionner et je crible avant de passer au pf[j] suivant...

b): j'obtiens {0,3, ou 6} multiple de trois != icnr..

C) : j'obtiens {2,5, ou 8} par conséquent il appartient une des 4 familles {11,17,23 et 29} ok en fonction de sa D_c je connais exactement sa famille ...je part le positionner et je crible avant de passer au pf[j] suivant...

donc le cas A) est C),  sont identiques...! ça ne fait pas l'hombre d'un doute...

la seule relation que je vois entre Pf[j] et P8[j] c'est le reste modulo 9 qui sont différents, du fait que 4 familles sont de la forme 3k +1
et les 4 autre ; 3k -1...

Quant au positionnement  avant le départ du criblage et bien il dépend du quotient ...uniquement  car par exemple si tu as un Pj ==30k +7
qui fait 4 chiffres où 5...le plus simple c'est c'est (P8[j] - 7)//30 = quotient, entier par obligation :
donc la position dans P8 , est par le N° du quotient..!

Si le quotient ==127 et bien cellule 127  si tu préfaire le 127 ème nombre qui est == (127*30) + 7 , puisque la première cellule a pour N° 0

je ne pense pas ...car c'est pf[j] qui détermine P8[j] , pas l'inverse...du fait que c'est  pf[j]  qui détermine à quelle famille P8, il appartient ..!

est bin dis donc , ça change tout .....!!!!

regardes,
========== RESTART: E:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 24090000000
Phase d'initialisation: 2.610149383544922 seconds ---
Famille de chaque Pi: : 3.0521745681762695 secondes ---
Criblage des 8 familles: 125.56661677360535 seconds ---
Extraction des premiers n à 2*n : 6.0996105670928955 seconds ---

**  123968501 nombres trouvés en 137.32855129241943 secondes **

par rapport à tout à l'heure...:

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

**  123968501 nombres trouvés en 497.8489727973938 secondes **

wonderbar....lollll

ça influence énormément cette modification.....! Chapeau chapeau...

Moi qui voulait t'envoyer, nbpremier-win32...mais il ne sert plus à rien même si il crible ....>450 000 000 000 par famille..cela oblige le double de manipe pour soustraire...

je vais pousser pour voir où il n'en peut plus....

Bonjour
@Yoshi pour info:

j'ai demandé de cribler la famille 17[30] pour extraire les nombres premiers q [n ; 2n] de la famille 13[30]
== 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: 177.06031107902527 seconds ---
Famille de chaque Pi: : 14.383225202560425 secondes ---
Criblage des 8 familles: 104.36418318748474 seconds ---
Extraction des premiers n à 2*n : 5.31960916519165 seconds ---

**  108 685 119 nombres trouvés en 301.1273286342621 secondes ** Et BIen BRAVO car :

résultat de nbpremier-Win32 : fam13[30] temps total pour les deux extraction : 326'' secondes
1) jusqu'à 42 000 000 000
puis
2)jusqu'à 21 000 000 000

>Allocation du Tableau en cours...
>Allocation Terminée!
>Calcul du tableau en cours...
>Calcul du tableau terminé!
>Le dernier nombre est:
41999999953
>trouvé à la position:
224226861
>Allocation du Tableau en cours...
>Allocation Terminée!
>Calcul du tableau en cours...
>Calcul du tableau terminé!
>Le dernier nombre est:
20999999743
>trouvé à la position:
115541742

total de la différence = 108 685 119

G8Y est plus rapide car il n'a pas besoin de faire deux extractions...!
@++

je voulais te faire une blague avec le premier résultat...Mais à priori tu n'as pas vu..? la répartition du nombre de nombres premiers par famille ne peut Jamais être la même , chaque nombre premier étant unique, les départs ne peuvent JAMAIS être les mêmes pour une limite n fixée, il y aura donc un décalage que ce soit dans Eratothène ou dans G ....! la répartition des nombre premiers est oscillatoire en règle générale, mais aussi par Famille avec une même densité en moyenne générale, puisque les P_i criblent de façon identique les 8 familles...

Tu as un premier Résultat que j'ai indiqué , en criblant séparément deux familles a) la fam 30k+7 et  ensuite la fam 30k+13 :

Tu remarques que le temps à un écart de 30 secondes, mais avec une autre limite plus grande si c'était faisable , tu verrais les temps s'inverser..
passe de 1 200 000 000 par limite une dizaine de fois et tu le remarqueras en criblant qu'une famille  ex la 7 puis après la 13... n'oublies pas de changer Dico={7:0....etc } puis Dico={13:0......etc} et.. in range (8) en (1).
Sachant que cribler la famille 30k+7 , te donne le résultat de n à 2n pour la famille 30k+23 ... Goldbach..!

j'ai dû faire une erreur de manipe en relisant ce post vers la page 4 et en modifiant certaines "de mes phrases..."

Après, il restera plus qu'à me repencher sur le criblage des 8 familles :

sur le criblage proprement dit , tu ne pourras pas changer grand chose en principe ...

car une fois que tu as tester pfam(0),les 8j  sont de la forme 30k + P8, [" peut être qu'on aurait dû les nommer Pj"] et que tu les as affecté à leur famille (("j==p8%30") = Pj ) ils vont marquer les 8 positions de départ pour P_i, et puis P_i cribles chacune des 8 fam, modulo P_i.

C'est à dire que si _P[sub]i ==7[/sub] , et bien 7 va marquer du [0] toutes les 7 cell [1] comme le fait Eratosthène_mod30 lpar famille, et là, tu ne peux pas partir du carré de P_i...!

Ensuite serra le tour de 11 qui marquera d'un [0] toutes ses 11 cellules comme Eratosthène, même si une cellule est déjà marquée [0]  par 7, qui est passé avant c'est normale..

Dans Eratosthène , tu parts de 7 et tu marque tous ses multiples toutes les 7 cellules,  puis lorsque 11 part il marque tous ses multiples y compris 77 qui est déjà marqué par 7...

La différence qu'il y a dans E et dans G, c'est la position de départ...Qui pour le cribleG8Y est = ou < à P_i quel qu'il soit...! Ce qui par obligation entraine moins de nombres premiers q de n à 2n...! pour n >= à 30 donc pour P_i = 7 au minimum..qui donne les premiers de la famille 23[30]...

Alors que dans E , tu parts au minimum de P_i, ou de son carré...! forcément pour une même limite n tu marqueras moins de nombres...d'où = plus de premiers de 7 à n ; il n'y a rien à démontrer ! cqfd ...! d'où quelque soit n >= 30 il ne peut y avoir plus de nombres premiers q de n à 2n que de nombres premiers p de 7 à n

A+

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 **
>>>

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 P_i par famille comme cribleG_mod30...!

Les voici : Quelque soit P_i, la somme des 8 termes = P_i * 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 P_i 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..!