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

Répondre

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 ?2 + 80
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.

Retour

Résumé de la discussion (messages les plus récents en premier)

LEG
14-05-2018 08:23:31

yoshi]Bonsoir, Re

Je pense avoir dissipé - en partie - les nuées :
- tu as remarqué que dans s2, on calculait Pfam et que pour n très grand, ça faisait une palanquée de nombres,

Tout à fait, car cela fait, pour 40000 Pi en gros 40000 * 8 j , à calculer la position et l'index de dédut
Et si, au lieu de les stocker, on les utilisait au fur et à mesure de leur création ? OUI


- Donc tu cherches à fusionner s2 et s3 au prix du calcul de l'index associé

oui

pour mettre des 0, dans la liste nombres.

qui correspond au début de la phase de Criblage par pas de Pi..

En utilisant Pfam, je ne crois pas qu'on puisse faire mieux que l'existant...

Exact, c'est pour cela que je t'ai dit on ne gagnera peut être que 1 à 2 secondes pour 30 mds et pour une Famille criblée, estimation faite , d'après le temps mis dans la phase Si : Famille de Pi...Donc...???


il faut trouver la formule permettant à partir d'un j calculé, donc connaissant sa position dans Pfam,

Position qui est donnée après : if j%3!=0 and j%5!=0: ..; Par la ligne : fam =Dico[j%30]  ...qui par conséquent permet aussi de récupérer le début d'index en utilisant le quotient....Donc de le positionner au lieu de positionner J... 
               

à partir de cette position, faire comme si on venait de l'en extraire et enchaîner  directement sur le bloc s3.

Parfaitement, enchainer sur S3 qui est le criblage dans P8, pour marquer les [0] , dans nombres....par pas de Pi ...

Tu as parfaitement déroulé le fonctionnement du criblage dans le programme...

Si rien n'est évident,

Le programme est très bien fait comme il est, il n'y aura rien à changer....

Ce serait bien le diable s'il n'y avait rien à voir... Ce ne serra que de la logique et du paufinage, dans le déroulement des 2 phase S2 et S3..., Mais on ne pourra pas gagner grand chose ...en principe...Sauf : comme tu as tellement amélioré le fonctionnement du crible depuis l'origine en divisant le temps par 10  voir plus...

Alors pense d'abord à ta revues....Et avec un Grand merci...

Peut être que ce crible te permettra de formaliser mieux que je le fait et d'être le premier à montrer : que le nombre de nombres premiers lorsque n tend vers + l'infinie vaut:
n sur le log "nipeurien" de 2n au minimum ! ...De démontrer que ce ne sont que des corollaires du TNP et Du TFA, d'où en découle la conjecture de Goldbach....et le postulat de Bertrand passera à la postérité...car il ne sert vraiment à rien , concernant la répartition des nombres premiers, surtout de n à 2n.....

@+

yoshi
13-05-2018 19:35:13

Bonsoir,

Je pense avoir dissipé - en partie - les nuées :
- tu as remarqué que dans s2, on calculait Pfam et que pour n très grand, ça faisait une palanquée de nombres,
- tu as remarqué que dans s3, on passait alors en revue tous les nombres j stockés...
  Et tu t'es dit : Et si, au lieu de les stocker, on les utilisait au fur et à mesure de leur création ?
- Donc tu cherches à fusionner s2 et s3 au prix du calcul de l'index associé pour mettre des 0, dans la liste nombres.

En utilisant Pfam, je ne crois pas qu'on puisse faire mieux que l'existant...
Cela posé, on peut penser sereinement à cette histoire de fusion et donc d'index...

Je vais examiner de bcp plus près qu'avant la façon dont, à partir d'un nombre extrait de Pfam, on détermine à quelle position de ma liste nombres, on remplace un 1 par un 0.

Je pense que la problématique est la suivante :
il faut trouver la formule permettant à partir d'un j calculé, donc connaissant sa position dans Pfam, à partir de cette position, faire comme si on venait de l'en extraire et enchaîner  directement sur le bloc s3.
Dans les 3 semaines qui viennent, l'échéance de parution de "ma" revue approchant, je vais devoir m'y mettre sérieusement et je ne pourrai penser à ton programme qu'épisodiquement...

Je pense à pister nommément chaque nombre de Pfam et pour cela
- afficher leur position exacte dans Pfam au moment du stockage via append (bloc s2), dans l'ordre de leur apparition
- afficher en regard leur position exacte dans Pfam au moment de leur extraction et dans l'ordre (bloc s3)
- afficher en regard l'index qui permet d'écrire 0 dans nombres
- chercher alors le lien pour chaque j affiché entre les 3 valeurs ci-dessous.

Si rien n'est évident, je recommencerai en écrivant Pfam comme liste simple, en  y stockant de 8 en 8 les éléments des ex-sous-listes, idem avec nombres...

Ce serait bien le diable s'il n'y avait rien à voir...

@+

yoshi
12-05-2018 19:04:34

Salur,

Je rentre HS...
Je verrai demain

@+

LEG
12-05-2018 07:08:22

Pour info:
On peut calculer les rapports : (N / 3,75) / P(n). Où P(n) est le nombre d’entiers $[1]\not\equiv {30k}[P_i]$ = nombres de premiers P[N ; 2N] pour une limite N criblée.

Par exemple, criblage par tranche de 30 000 000 :
La fonction 2 = $\frac{N}{Ln 2N}$

  990000000 / Ln 1980000000 = 46 247 931 ;
Soit environ : 2*(960000000 / Ln 1920000000) – (930000000 / Ln 1860000000) = 46 249 791   ["suivant le principe d'une suite aritmétique, où $N \geqslant {30}$ progresse arithmétiquement de raison 15."]

(930000000/3,75) / 44211471 = 5,6094…
(960000000/3,75) / 45568107 = 5,6179….
(990000000/3,75) / 46923731 = 5,6261…
(1020000000/3,75) / 48277550 = 5,6340….
(1050000000/3,75) / 49629176 = 5,6418….
(1080000000/3,75) / 50979308 = 5,6493….
(1110000000/3,75) / 52326432 = 5,6567….

D'autres résultats :
G(n) fonction qui compte le nombre d'entiers $[1]\not\equiv {30k}[P_i]$

Si on prend la suite de G(n) par itération de 15:

G(15) = 4 ; G(30) = 7 ; G(45) = 10 ..etc..etc

La fonction 2, donne par itération de 15, le même principe qu’une suite arithmétique de raison 15, c’est-à-dire ≈ : Un+1 = 2Un – Un-1 , d’où cette fonction ne peut varier que de très peu, lorsque n =15k →∞ et ce, quel que soit 15k criblé = G(n) :

15/ln30 = 4,41…     = U1                                     pour un réel de 4.
30/ln60 = 7,32..      = U2                                      pour un réel de 7
45/ln 90= 10,00…   =U3 ;   ≈   V1 = 2* U2 – U1 = 10,24…           pour un réel de 10       
60/ln120 = 12,53… =U4            V2 = 2* U3 – U2 = 12,67…          pour un réel de 13
75/ln150 =14,96..   =U5            V3 = 2* U4 – U3 = 15,06…          pour un réel de 14
90/ln180 = 17,33..  =U6             V4 = 2* U5 – U4 = 17,40…         pour un réel de 17
105/ln210= 19,63.. =U7             V5= 2* U6 – U5 = 19,69…         pour un réel de 19
120/ln240 = 21,89.. =U8            V6 = 2* U7 – U6 = 21,94…           pour un réel de 22
135/ln270 = 24,11..  =U9            V7 = 2* U8 – U7 = 24,15…         pour un réel de 25
150/ln300 = 26,29..  =U10         V8 = 2* U9 – U8 = 26,33…          pour un réel de 27
165/ln330 = 28,45.. =U11          V9 = 2* U10 – U9 = 28,48…        pour un réel de 28
180/ln360 = 30,58..  =U12          V10 = 2* U11 – U10 = 30,60…      pour un réel de 31
195/ln390 = 32,68..  =U13         V11 = 2* U12 – U11 = 32,70…     pour un réel de 33 
210/ln420 = 34,76..  =U14         V11 = 2* U13 – U12 = 34,78…     pour un réel de 35

Etc...etc..Avec des oscillations de + ou - 1 nombre , jusque vers 990 , pour ensuite être en dessous de G(n).

En Conclusion, le crible de Goldbach, à les mêmes propriété qu le crible d'Eratosthène, de n à 2n , c'est un corollaire du T.N.P et du T.F.A,
d'où un entier naturel > 0, peut être congru de façon unique à l'ordre près de ses facteurs...
le nombre minimum de nombres premiers de $n$ à $2n$ , pour $n = 210$ est $39$, plus généralement pour $n$ de la forme de $30k$ et $ n \geqslant {210}$ vaut lorsque n tends vers + l'infini ,$\frac{n}{Ln 2n}$

LEG
11-05-2018 19:52:31

re bonsoir

Oui, je sais, tous les j de chaque sous-liste ci-dessus sont dans l'ordre croissant des j%30 : 1 7 11 13 17 19 23 29
Mais ça ne me dit pas qui ils sont.

Ce sont les 8 premiers termes de P8, en progression arithmétique de raison 30 et à part 1, qui n'est pas premier, ils vont servir de base pour calculer les [tex]j \in P8[/tex] dans la limite:[0 ; P_i*29] soit au maximum, 15 j pour chaque Pi, afin de cribler les entiers congrus à 2n%Pi, P premier, d'indice i. Soit Pi marquera 8 congrus sur Pi*8 nombres; en partant de l'index de j
Donc l'index de $J\in P8$ est le point de départ, marqué [0] de Pi qui va cribler par pas de Pi.

Au maximum pour Pi = 7 cela donnera 56 nombres ("pas 64"), qui seront criblés par les 5 Pi de bases,[tex]\leqslant\sqrt{2n}[/tex]
car 7*30 = 210 et 210/3,75 = 56. 3,75 et le coefficient pour obtenir les entiers de P8, par rapport aux entiers naturels positif >0 , quelque soit n.

Ce qui donnera pour n= 210 , ou 240 au maximum 39 nombres sur 56 , soit , comme Eratosthène, le crible de Goldbach donnera, 39 premiers sur 56 de n à 2n,Au minimum...

d'où attention à la modification de :

1) l'instruction dans, famille de Pi cette ligne ci-dessous, est la bonne ligne de code :

debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2

  ; qui  ne doit pas être modifier avec l'instruction : ,min(pi*29,n) :

Car elle modifie les J de pfam , dans de grandes proportions pour n > 3000, et fausse totalement le crible, en supprimant des j, ce qui a pour effet de supprimer des entiers congrus à 2n%pi , d'où augmentation importante du nombre de nombres premiers de n à 2n , sans même améliorer le temps ce qui est logique , par contre tu auras beaucoup plus de cellules [1] à compter.

C'est pour cette raison, juste dans le poste au dessus, que je t'ai dit tu as raison il ne faut pas toucher à pfam, sauf si on ne l'utilise plus, ["car le problème des j > n n'est que pour les valeur de n < 3000, d'où comme tu le signales, c'est effectivement en aval que tu peux éventuellement améliorer..."].
Il y a une explication très simple, la racine carrée de 2n progresse moins vite que n..! Donc les j, ne pourront plus dépasser n >3000
En exemple :
[tex]\sqrt{600}[/tex} = 24 dans le pire des cas tu as 23*30= 690 très au dessus de n = 300

[tex]\sqrt{3000}[/tex} = 54 dans le pire des cas tu as 53*30= 1590 A peine au dessus de n = 1500

[tex]\sqrt{30000}[/tex} = 173 dans le pire des cas tu as 173*30= 5190 bien en dessus de n = 15000 et en plus aucune erreur possible car la limite F, prime sur la limite n, pour les j; comme tu l'avais remarqué , tu peux très bien avoir un j , le dernier, tel que j(-1) +2*Pi = 14987 pourquoi pas, donc à la limite de 15000 .

L'instruction : que tu as mise; ,min(pi*29,n, elle marque d'office les premiers de la ligne n°0, qu'elle marque [0] peut être à cause
de ,min, ce qui te donne dans ton premier tableau les fameux cinq 0...mais en suite, elle fait le contraire elle supprime des j d'où augmentation de cellules [1] est résultat archi faux ; voici le résultat , avec cette mauvaise instruction , et en dessous les 2 tableaux avec la bonne instruction ci-dessus: le temps est identique, mais cela ne durerait pas car plus de[1] prendra du temps pour les compter...!

De la même Façon que ton idée pour compter la somme des 1, était très bonne car, l'inverse n'est pas possible, avec les [0].
D'autant plus, que ce que tu appelles les doublons, poseraient problème, du fait qu'ils correspondent à la décomposition unique en facteurs premiers d'un entiers positif de n à 2n, d'où le corollaire du TFA, un entier positif > 0, peut être congru de façon unique, à l'ordre près de ses facteurs, entrainant des doublons de j ...!
******************************************************************************************************
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:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 300000000
Phase d'initialisation: 0.28080034255981445 seconds ---
Famille de chaque Pi: : 0.28080058097839355 secondes ---
Criblage des 8 familles: 9.063616037368774 seconds ---
Extraction des premiers n à 2*n : 0.6396012306213379 seconds ---

**  15320277, résultat faux nombres trouvés en 10.26481819152832 secondes **
>>>
========== RESTART: E:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 600000000
Phase d'initialisation: 0.514801025390625 seconds ---
Famille de chaque Pi: : 0.561600923538208 secondes ---
Criblage des 8 familles: 19.234833478927612 seconds ---
Extraction des premiers n à 2*n : 1.2636022567749023 seconds ---

**  29579614  , résultat faux nombres trouvés en 21.574837684631348 secondes **

#############################################################################>>>

========== RESTART: E:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 300000000
Phase d'initialisation: 0.2964005470275879 seconds ---
Famille de chaque Pi: : 0.2964005470275879 secondes ---
Criblage des 8 familles: 8.985615730285645 seconds ---
Extraction des premiers n à 2*n : 0.6396012306213379 seconds ---

**  15072378 nombres trouvés en 10.218018054962158 secondes **  OK
>>>
========== RESTART: E:\executable algo P(30)\cribleG9Y_modulo30.py ==========
Donnez la valeur de n = 30k : 600000000
Phase d'initialisation: 0.514801025390625 seconds ---
Famille de chaque Pi: : 0.5772008895874023 secondes ---
Criblage des 8 familles: 18.798032999038696 seconds ---
Extraction des premiers n à 2*n : 1.248002052307129 seconds ---

**  29130002 nombres trouvés en 21.138036966323853 secondes **  OK

Ne touche surtout pas à pfam, comme tu le pensais...., car le nombre de j, de R à + (k*Pi) =15, dont 8 appartenant à P8.

Passe un bonweek end
@ A demain, mais ne te sent pas obligé, car il n'y a plus grand chose à modifier sauf si tu as envie de faire dans la foulée, famille de Pi et criblage avec les suppositions du post au dessus et J = 271 par ex:

Donc fam =Dico[271%30]==1et q==9 ; = Dico[1%30]=Dico[1:0] ; c'est à dire:

fam , Dico(j%30) donne le reste,et q; = Dico(1%30) donne Dico{1:0} soit P8 [1] et en récupérant le quotient , on a le début d'index = Dico{1:0} on continu , on part cribler par pas de Pi = 7; de 9 > à 8 dans ton exemple, ...etc
Ou tout simplement, mettre début d'index dans pfam de 0 à 7 à la place des j, de 0 à 7 et passer à la phase 3 criblage, ce qui supprime la division ; : ce passage:
for j in range(8):
            debut_index=(Pf[j]-P8[j])//30.

on passe au criblage:
for index in range(debut_index, nbcell,pi):

..ce qui est aussi...faisable...mais pour 2 secondes au grand max , je pense, pour 30mds et une famille...??

yoshi
11-05-2018 17:23:27

Re,

J'avais vu ce matin : 35 au lieu de 40.
Je m'y attendais à moitié...
Ce que tu as suggéré demande probablement d'autre modifs en aval (ou peut-être en amont dans l'initialisation) Et: j'ai pensé qu'on devait modifier la structure de Pfam et son remplissage et peut-être le remplissage de la liste nombres.
Voilà les deux listes en question :
Pfam =[
[151, 67, 11, 193, 137, 109, 53, 179],
[0, 7, 161, 73, 227, 139, 0, 29],
[181, 0, 0, 103, 77, 0, 233, 0],
[0, 157, 191, 0, 0, 0, 0, 89],
[0, 157, 0, 43, 0, 0, 233, 119]
]
Tu vas pouvoir vérifier si ladite liste est conforme à tes attentes ou pas (14 zéros sur 40, ça me paraît beaucoup + 2 doublons 157 et 233)
Ancienne version pour comparaison
[
[151, 67, 11, 193, 137, 109, 53, 179],
[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]
]
Pour nombres :

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

liste obtenue avec la dernière version fonctionnelle (pour comparaison) : 5 différences (et 40-35 = 5.)

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

Et le crible qui génère ça avec la seule modif indiquée :


 # INITIALISATION
    start_i= time()
    Primes_init = eratostene(n)
    nn,nbcell,nbcl=n*2,n//30,n//30-1
    nombres=[]
    for i in range(8):
        nombres.append([1]*nbcell)
    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),min(pi*29,n),pi*2 # seule modif : fin...
        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
 

Dernière partie S4 inchangée...

Normalement, tu as du grain à moudre...

Rappel : demain, je ne serais pas de retour avent 19 h 30/20 h)

@+

LEG
11-05-2018 15:13:15

dans ta dernière version que tu utilises, cette ligne cause une erreur ;

debut,fin,pas=r+pi*(1-r%2),1+r+pi*29,pi*2  / si je remplace /  1+r+pi*29  (par;)  min(pi*29,n)

cela m'affiche 35 premiers au lieu de 40 ...???

Mais par contre , ta remarque est justifiée, de ne pas toucher à pfam , car ce n'est que sur les petites valeur de n qu'il y a beaucoup de j <= f mais qui dans pfam, dépassent n .

Par contre dès que l'on passe à n >1500, il est pratiquement évident que le phénomène se réduit à moins d'une douzaine , donc sans incidence de temps ou de mémoire..
En effet, si je prend n = 3000 , sqrt de 2n = 77 , donc le maximum pour Pi; et 77*30 = 2310 = limite f...§ Je n'avais pas fait attention à ce cas...!

Et pourtant tout l'indiquait... les temps pour initialisation , et famille de Pi qui sont vraiment minime par famille....

Alors je pense, qu'il ne serait peut être bon de le laisser à la version finale cribleG9y_modulo30....avec tous mes remerciement....mon offre tient toujours...pour te remercier...tu vas pouvoir aller à la pêche.....LoLLLL

@++ Gilbert

LEG
11-05-2018 12:41:22

attend Yoshy:
j'ai repris l'exemple de tes explications en abrégeant ok.. où tu as cité le processus des 2 lignes:

 if j%3!=0 and j%5!=0:
                fam =Dico[j%30]

   

  .. je vais faire dans fam = Dico[j%30] c'est à dire (271 -13) / 30 != 0 , puis (271 - 1) / 30==0  et quotient = 9 donc j'ai ramené cela à :

je vais faire dans: fam = Dico[j%30] c'est à dire (271 -13), 13%30 != 0 , puis (271 -1)= 1%/ 30 == 0  cette ligne calcul le reste
ensuite  c'est  et quotient = 9 ..c'est tout.

R doit donc être probablement P8[1]...

Effectivement...puisque c'est le rôle de cette ligne de programme , pour ensuite envoyer Pfam [.......] dans le boc de criblage ..

Je présume donc qu'il faut lire : (271 - 1) % 30==0  et quotient = 9.
Si oui, alors on écrit :
q,reste=divmod((j-1),30)

Quelques calculs d'illustration obtenus via la fonction divmod():

Donc c'est Exactement ce qu'il faudrait faire ici :,

 if j%3!=0 and j%5!=0:
                fam =Dico[j%30]

   

mais comme ceci:

Pour j =   7 on a : (  7-1)//30 = 0  et (  7= Dico[j%30] == 0  soit [7:1] on a son index=0 , famille qui dans
Dico = {..,7:1,..}

Pour j =  29 on a : ( 29-1)//30 = 0  et (29= Dico[j%30] == 0  soit [29:7] on a son index =0 , famille qui dans
Dico = {..,7:1,.............,29:7}

Pour j =  51 on a : ( 51-1)//30 = 1  et  multiple de 3
Pour j =  73 on a : ( 73-1)//30 = 2  et 73= Dico[j%30] == 0  soit [13:3] on a son index=2, famille qui dans
Dico = {..,7:1,..,13:3,.. ... ...,29:7}

Pour j =  95 on a : multiple de 5
Pour j = 117 on a : multiple de3

Pour j = 139 on a : (139-1)//30 = 4  et (139= Dico[j%30] == 0  soit [19:3] on a son index=4, famille ,
Dico = {..,7:1,..,13:3,.. ,19:5 ...,29:7}

Dans la foulée, et des que j dépasse > 240 , pour cet exemple , on passe au suivant..non?

tout d'abord, je ne me permettrait pas de penser quoi que ce soit sur tes capacités.....qui m'ont permis de comprendre le processus du déroulement du programme, de tout ce que tu m'as apporté...! et excuse moi , si je m'exprime mal.

Pour utiliser le bloc S2, il y a au moins un prérequis : Pfam.

Comment alors empêcher J, dans Pfam de dépasser n..?
la seule solution était à mon sens de s'en passer, et de calculer  les J au fur est à mesure
et effectivement le fonction Dico , permet de faire les deux et pourrait être utilisé pour les index, comme tu viens de le voir...
Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}. famille
Dico={. ...................................................}. index

dès lors, je pense que ce problème de limite même en laissant while <= f ne  éviterait de calculer des j qui sont > n inutilement car, il y en a énormément ce, qui bouffe de la mémoire et du temps ..

tout cela était dans le but de finir, afin d'améliorer la partie crible qui te tenait...Car il ne faut quand même pas oublier comment tu as modifié ce programme pour le rendre parfait...
.........................................................................................................................................................
voici d'ailleurs les nombres premiers q de 240 à 480.., du premier crible de base...avant même que je modifie sa limite j<= f
tu en conviens , d'avoir les nombres premiers, ne sert pas à grand chose  ça ne sert pas à grand chose :
.............................................................................................................................................................
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3_modulo30.py =====
Donnez la valeur de n = 30k : 240
CribleG3 mod30 : Famille de chaque Pi: 0.0 seconds ---
CribleG3 mod30 : Criblage des 8 familles: 0.0 seconds ---
[269, 359, 389, 419, 449, 479, 263, 293, 353, 383, 443, 349, 379, 409, 439, 257, 317, 347, 467, 283, 313, 373, 433, 463, 251, 281, 311, 401, 431, 461, 277, 307, 337, 367, 397, 457, 241, 271, 331, 421]
On a 40 nombres premiers

pour rappel : le programme d'origine :


# ATTENTION: n doit être multiple de 30
def crible_mod30(n):
   # INITIALISATION
   start_time = time.time()
   nbcell = int(n/30)
   nombres = [[1 for _ in range(nbcell)] for _ in range(8)]
   p = eratostene(int(n))
   p = p[3:]
   lenp = len(p)
   r = []
   p8 = [1, 7, 11, 13, 17, 19, 23, 29]
   pfam = []
   print("Crible mod30 : Initialisation: %s seconds ---" % (time.time() - start_time))

   # FAMILLES POUR CHAQUE Pi
   start_time = time.time()
   for i in range(lenp):
      r.append(2*n % p['i])
      pfam.append([0, 0, 0, 0, 0, 0, 0, 0])
      j = r[i]
      incr = p[i]*2
      d_c = str(j)[-1]
      # On elimine les restes pairs
      if d_c == '0' or d_c == '2' or d_c == '4' or d_c == '6' or d_c == '8':
         j += p[i]
         d_c = str(j)[-1]
      while j < n:
         if d_c == '5' or j % 3 == 0:  # on passe au suivant
            fam = -1
         elif d_c == '1':  # on vérifie 1 et 11
            if j % 30 == p8[0]:
               fam = 0
            else:
               fam = 2
         elif d_c == '3':  # on vérifie 13 et 23
            if j % 30 == p8[3]:
               fam = 3
            else:
               fam = 6
         elif d_c == '7':  # on vérifie 7 et 17
            if j % 30 == p8[1]:
               fam = 1
            else:
               fam = 4
         else:  # on vérifie 19 et 29 (d_c = 9)
            if j % 30 == p8[5]:
               fam = 5
            else:
               fam = 7
         if fam != -1 and pfam[i][fam] == 0:
            pfam['i][fam] = j
         j += incr
         d_c = str(j)[-1]

   print("Crible mod30 : Famille de chaque Pi: %s seconds ---" % (time.time() - start_time))

   # ON CRIBLE LES 8 COLONNES AVEC CHAQUE FAMILLE DE Pi
   start_time = time.time()
   lenpfam = len(pfam)
   for i in range(lenpfam):
      for j in range(8):
         index = int((pfam[i'][j] - p8[j]) / 30)
         while index < nbcell:
            nombres[j][index] = 0
            index += p['i]
   print("Crible mod30 : Criblage des 8 familles: %s seconds ---" % (time.time() - start_time))

   # AFFICHAGE
   for i in range(8):
      count = 0
      for cell in nombres['i]:
         if cell == 1:
            count += 1

   # CALCUL DES NOMRES PREMIERS ENTRE N ET 2*N
   start_time = time.time()
   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])
            premiers.append(premier)
   print("Crible mod30 : Extraction des premiers n à 2*n : %s seconds ---" % (time.time() - start_time))
   print(premiers)
   premiers.sort()
   return premiers


n = int(input("Donnez la valeur de N = 30k : "))
#nb = len(crible_G(n))
#print("On a "+str(nb)+" nombres premiers")
#print("---------------------------------------------------------")
nb = len(crible_mod30(n))
print("On a "+str(nb)+" nombres premiers")
os.system("pause")
 

Je pense qu'on devrait
- d'abord utiliser la méthode avec Pfam et la modifier/simplifier jusqu'à ce qu'elle donne satisfaction,
- ensuite, instruits par l'expérience, tenter de s'en passer...

Là , c'est toi le mieux placé pour juger....! Mais effectivement tu as entièrement raison
@+

yoshi
11-05-2018 10:51:40

Salut,

Je vois qu'on est entré dans un dialogue de sourds.
Je vais essayer d'être beaucoup plus bref...

re Yoshi

    Ça, je sais, je vois, c'est la réponse à comment sont-ils fabriqués ?

voyons , ils sont fabriqué à partir du reste R de 2n%pi puis on les augmente de k*Pi comme pour fabriquer les multiples de Pi dans Eratosthène ...Pour n=240, et Pi =7 , 480 % 7 == 4, qui est le premier R congru à 480 [7] ,d'où, R  +7+7+7..etc <= n , j'ai tous les entiers congru à 480[7; de même pour les multiples de 7, en partant de 7.+7+7..<=n]

Citation complète :

je pensais que tu savais, que ces nombres dans pfam sont les nombres qui sont congrus à 2n modulo Pi (pi ?)

Ça, je sais, je vois, c'est la réponse à comment sont-ils fabriqués ?

Traduction :
je vois et je sais que  ces nombres dans pfam sont les nombres qui sont congrus à 2n modulo Pi pi, ce n'est pas la question que je me pose puisque je connais la réponse..
Me dire que ces nombres dans pfam sont les nombres qui sont congrus à 2n modulo Pi pi, c'est croire que je ne n'ai pas vu, pas retenu, pas compris comment ils sont construits. Et ce n'est pas le cas.
Donc, j'abandonne ce sujet...

A l'avenir, je vais essayer de formuler des phrases courtes, sans question.
En outre, si tu continues à utiliser tantôt des majuscules tantôt des minuscules pour désigner le même objet, je ne ferai pas l'effort de chercher. J'ai déjà commence. Exemple :

Qui est R ? Connais pas...

Ah bon..et c'est quoi que tu calcules depuis le début.. 2n%pi...? si c'est pas R, ...?

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

j'ai : j = 271 obtenu à partir de R =7 et pi = 11
, qui a passé les tests j%3 et j%5

donc fam:

bloc famille de Pi :
je vais faire dans fam = Dico[j%30] c'est à dire (271 -13) / 30 != 0 , puis (271 - 1) / 30==0  et quotient = 9
je place j dans pfam [271:0 , jx:1, jy:2...etc jz:7] ; pfam est rempli, donc ok , pour le bloc : crible les 8 colonne....

Tu écris : 271 obtenu avec R=7 et pi=11
Puis, tu enchaînes avec (271-13)/30  !=0 et (271 - 1)/30 == 0...
11 annoncé puis 13, puis 1 utilisé. Bizarre...
R doit donc être probablement P8[1]...

Tiens, pour ta gouverne :
puis (271 - 1) / 30==0

 :
>>> (271-1)/30==0
False
>>> (271-1)/30
9.0
>>> (271-1)//30
9
 

L'un des quotients est un float, l'autre un integer : la place mémoire utilisée et la vitesse de traitement ne sont pas les mêmes...
(271 - 1) / 30==0  et quotient = 9
Moi qui toujours cru que / donnait un quotient...

Je présume donc qu'il faut lire : (271 - 1) % 30==0  et quotient = 9.
Si oui, alors on écrit :
q,reste=divmod((j-1),30)

Quelques calculs d'illustration obtenus via la fonction divmod():

Pour j =   7 on a : (  7-1)//30 = 0  et (  7-1)%30 =  6
Pour j =  29 on a : ( 29-1)//30 = 0  et ( 29-1)%30 = 28
Pour j =  51 on a : ( 51-1)//30 = 1  et ( 51-1)%30 = 20
Pour j =  73 on a : ( 73-1)//30 = 2  et ( 73-1)%30 = 12
Pour j =  95 on a : ( 95-1)//30 = 3  et ( 95-1)%30 =  4
Pour j = 117 on a : (117-1)//30 = 3  et (117-1)%30 = 26
Pour j = 139 on a : (139-1)//30 = 4  et (139-1)%30 = 18
Pour j = 161 on a : (161-1)//30 = 5  et (161-1)%30 = 10
Pour j = 183 on a : (183-1)//30 = 6  et (183-1)%30 =  2
Pour j = 205 on a : (205-1)//30 = 6  et (205-1)%30 = 24
Pour j = 227 on a : (227-1)//30 = 7  et (227-1)%30 = 16
Pour j = 249 on a : (249-1)//30 = 8  et (249-1)%30 =  8
Pour j = 271 on a : (271-1)//30 = 9  et (271-1)%30 =  0

Voilà les blocs S2 et S3 (moi j'utilise ceux-là) :

   
    # 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),min(pi*29,n),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]//10//3
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0
 

Pour utiliser le bloc S2, il y a au moins un prérequis : Pfam.

Tu m'as noyé sous des pages, et je n'ai pas l'envie de les lire et relire pour trouver les éléments qui me permettraient de démarrer :
- Savoir si on se passe ou pas de ce Pfam,
  * Si oui, ce qu'on utilise à la place
  * Si non, comment le construire
- Savoir ce qu'on va faire de Dico={1:0,7:1,11:2,13:3,17:4,19:5,23:6,29:7}.
  Parce que j'ai eu la curieuse impression que tu voulais utiliser un Dico qui contienne l'index de chaque j.

Tu sembles dire que la solution min n'est pas bonne...
Alors, cela signifie que je n'ai toujours pas compris ce que tu veux dire par :

doit être au maximum <= f = pi*29 et et si j >= n break , on passe à Pi et R suivant;  tel que j <= n {ce que je n'ai pas réussi à faire ce matin car il y a une limites maxi pour les Pi petits  donc j <= f et si j >= n break , pour les Pi plus grands, tel que Pi*29 > n limite donc j >n l'instruction break , fait passer à Pi et R suivant; car ils cribleront  moins de 8 fam...

ni en quoi, ma suggestion n'est pas bonne..

Désolé, si mon intelligence te paraît limitée : je suis né comme ça :-((.
Tu devrais peut-être essayer de trouver un cerveau plus réceptif : je t'aurais bien conseillé developpez.net, mais là-bas, s'ils sont (très) bons, je trouve que, souvent, on y manque de compréhension et de tact avec des demandeurs qui sont pourtant les auteurs des scripts présentés, avec les envoyant bouler avec quelque chose du genre : "Ouvrez un tuto et lisez-le, faites-en les exos", quant à ta tentative sur l'Île Maths, t'as vu ce qu'elle a donné...

Je pense qu'on devrait
- d'abord utiliser la méthode avec Pfam et la modifier/simplifier jusqu'à ce qu'elle donne satisfaction,
- ensuite, instruits par l'expérience, tenter de s'en passer...

J'ai encore plein de remarques à faire sur ce que tu m'écris (qui empêche le matheux que j'étais de comprendre, parce que source de confusion), mais j'ai déjà été bien plus long que voulu.

@+

LEG
10-05-2018 20:43:58

pour faire simple est résumer:n=240
j'ai : j = 271 obtenu à partir de R =7 et pi = 11
, qui a passé les tests j%3 et j%5

donc fam:

bloc famille de Pi :
je vais faire dans fam = Dico[j%30] c'est à dire (271 -13) / 30 != 0 , puis (271 - 1) / 30==0  et quotient = 9
je place j dans pfam [271:0 , jx:1, jy:2...etc jz:7] ; pfam est rempli, donc ok , pour le bloc : crible les 8 colonne....


ce bloc ,l'appel :
lenpfam = len(pfam) etc etc.

il va calculer encore le quotient entier soit: index = ((pfam['i][j] - p8[j])// 30) soit 271 //30 == 9,...

pour aller cribler en partant de 9 à 8 par pas de 7 (" car c'est bien pi= 7 qui crible...")

je pense que cela aurait pu se faire en une seule fois dans la foulée, sans même avoir besoin de faire:  pfam.append([0,0,0,0,0,0,0,0]) et du coup, même d'éviter j = 271 > 240...au niveau du bloc de famille de Pi et criblage....Non ?

Le problème qu'il y avait , tout au début dans le programme, la limite était while j <= n..ok , mais il calculait les j, jusqu'à n...et quelque soit n, il s'en suivait l'erreur que tu as remarquée, pour les petites valeur de n < 1200, je t'ai ensuite signalé que j'avais trouvé d'où cela venait..cette limite que j'ai changée en while j<= f. en définissant f .
mais cette limite n'empêche pas non plus de limiter j dans la zone de 7 à n, exemple du post ci dessus , de ton petit tableau...

le seul moyen et de cribler dans la foulée comme expliqué ci-dessus.. si possible.. bien entendu.

je reprend l'exemple de n = 240 soit 2n = 480., pour marquer "tes candidats" , multiples de Pi ⩽ √2n, ["selon Eratosthène mais, dans les congruences"] en marquant les entiers n tel que définis, à savoir : [tex] \equiv  {2n} {[P_i]}[/tex]

avec [tex]P_i = 11[/tex]; donc je calcule R = 2n%Pi .soit : R = 7, Pi = 11, incr = 2*11 while j<= f==326
Ri = j : 7 + incr....> 326 =
j'établis le liste des j congrus 2n%11
7   29    51    73    95    117    139    161    183    205    227    249    break > 240 271    293    315    337
je marque uniquement les congrus appartenant à P8, donc ce qui sont : !=j%3 ou j%5 et donc < 240...! ;

Afin d'éliminer les multiples de Pi de n à 2n . En notant le fait que je n'ai pas besoin de m'en occuper, car il me suffira , de compter les [1] de 7 à n, qui sont donc [tex]\not\equiv {480}[11][/tex].

congrus à 480[11] < 240 : [7, 29, 73, 139, 161, 227 ] soit 6 éléments qui aurait dû être dans Pfam(1) .. pour ensuite aller,calculer leur index, et les placer dans leur famille respective..

ce que je vais faire avec fam = Dico[j%30] : avec le reste et le quotient; R =0 indique la famille dans Dico, est le quotient indique l'index de j: ;   {"on marque la celllule [1] en [0], ce qui indique que l'entier est congrus 2n%Pi"}

7:
donc fam =Dico[j%30]=Dico[7%30]= Dico[7]est le quotient ==(0) je vais mettre (0) dans P8 == 7, indice 0 , je marque par pas de 7, de 0 à 7, car nbcell = 240/30 = 8; indice de 0 à 7, ce que tu m'as montré..

29:
fam =Dico[j%30]=Dico[29%30]= Dico[29]est le quotient ==(0) je vais mettre (0) dans P8 == 29, indice 0 , je marque par pas de 7, de 0 à 7,

73:
fam =Dico[j%30]=Dico[73%30]= Dico[13]est le quotient ==(2) je vais mettre (2) dans P8 == 13, indice 2 , je marque par pas de 7, de 2 à 7,

139:
fam =Dico[j%30]=Dico[19%30]= Dico[19]est le quotient ==(4) je vais mettre (4) dans P8 == 19, indice 4 , je marque par pas de 7, de 4 à 7,

161:
fam =Dico[j%30]=Dico[11%30]= Dico[11]est le quotient ==(5) je vais mettre (5) dans P8 == 11, indice 0 , je marque par pas de 7, de 5 à 7,

227:
fam =Dico[j%30]=Dico[17%30]= Dico[17]est le quotient ==(7) je vais mettre (7) dans P8 == 17, indice 7 , je marque par pas de 7, de 7 à 7,  ..fin du criblage pour pfj
qui ne peut donc cribler , que 8 familles ...! et marqué [0] 8 entiers  au total. Ce qui correspondent aux multiples de 11 , dans n à 2n...! D'où il n'est nul besoins de s'en occuper...!

je passe donc à Pi et R suivant = 13 et 12  , afin de réitérer la suite du criblage modulo 7.
........................... j'établis la liste des j > 12: congrus 2n%13
[12%2==0] + 13 = j
[25    51    77    103    129    155    181    207    233    259 >240 break] 285    311    337    363    389    415
..........................................
77:
fam =Dico[j%30]=Dico[17%30]= Dico[17]est le quotient ==(2) je vais mettre (2) dans P8 == 17, indice 2 , je marque par pas de 7, de 2 à 7,

103:
fam =Dico[j%30]=Dico[13%30]= Dico[13]est le quotient ==(3) je vais mettre (3) dans P8 == 13, indice 3, je marque par pas de 7, de 3 à 7, 

181:
fam =Dico[j%30]=Dico[1%30]= Dico[1]est le quotient ==(6) je vais mettre (6) dans P8 == 1, indice 6 , je marque par pas de 7, de 6 à 7,

233:
fam =Dico[j%30]=Dico[23%30]= Dico[23]est le quotient ==(7) je vais mettre (7) dans P8 == 23, indice 7, je marque par pas de 7, de  à 7, 

fin du criblage pour Pfj; qui aura marqué 4 entiers [0] congrus 2n%13

je passe à Pi et R suivant .....etc,

A la fin le programme compte les [1], qui indique le nombre de nombres premiers q, de n à 2n ;sans avoir eu besoins de s'en occuper.
Car les congrus à 2n%Pi de 7 à n , ont indiqués les multiples de Pi >= n, .....> 2n

LEG
10-05-2018 19:55:57

re Yoshi

Ça, je sais, je vois, c'est la réponse à comment sont-ils fabriqués ?

voyons , ils sont fabriqué à partir du reste R de 2n%pi puis on les augmente de k*Pi comme pour fabriquer les multiples de Pi dans Eratosthène ...Pour n=240, et Pi =7 , 480 % 7 == 4, qui est le premier R congru à 480 [7] ,d'où, R  +7+7+7..etc <= n , j'ai tous les entiers
congru à 480[7; de même pour les multiples de 7, en partant de 7.+7+7..<=n]

Moi, ce qui m'intéresse, c'est qui ils sont, ce qu'ils représentent par rapport
- soit à l'ensemble des nombres  de 240 à 480

pour le premier = R +7 ==11, 11 est congru à 480[7]  d'où 480 -11 , ne peut être premier car divisible par 7; propriété des entiers A congru à B [pi] , pi divise la différence A -B,
je te l'ai expliqué..tu n'as peut être pas fait attention..avec tous ces massage.

comme on s'intéresse aux entiers non multiple de 2,3 ou 5, donc à l'ensemble des entiers congrus à 1 modulo 30, ou à Pi modulo 30, pour Pi premier appartenant à [7 : 29] donc : P8= [1,7,11,13,17,19,23,29];
mes entiers > n , qui sont tes candidats > n
et comme on sait que si un entier de cet ensemble appartenant à [ 7 ; n] , n'est pas congru à 2n % Pi, et bien il est premier appartenant à [n ; 2n] , soit nos candidats..je t'ai même expliqué pourquoi j'étais sûr d'extraire tous les nombres premiers appartenant à [n ;2n] en te disant, c'est trivial...:
Car il suffit de barrer de n à 2n les multiples de [[tex]P_i\leqslant\sqrt{2n} [/tex]] selon le principe Eratosthène, mais en utilisant les congruences. ie) marquer les entiers [tex] n\equiv {2n} [p_i] [/tex] de n à 2n, selon ce même principe, mais avec les [tex]P_i\leqslant\sqrt{2n} [/tex] ....!; avec n appartenant aux familles arithmétique P8[....], de raison 30.. D'où tes candidats comme les miens de n à 2n font bien partie de l'ensemble P8, en progression arithmétique..!

ensuite c'est pour cela, qu'on limite pour cribler jusqu'à n avec Pi, les J <= min(j+pi*29, n) en partant de j , car on aura les 8 j  , dont un seul par famille de P8. On partira du rang de ce j par pas de Pi , soit 7 pour cet exemple...

donc il nous faut l'index de départ ou le rang dans sa famille, pour marquer les entiers congrus à 2n%Pi par pas de Pi ....> n/30 puisque l'on est en progression arithmétique de raison 30 dans les 8 familles de P8. Comme le principe d'Eratosthène...

d'où on a besoin d'utiliser p8%30 conjointement avec Dico%30 à) pour l'index, b) pour la famille à qui appartient l'index de j. je te l'ai détaillé , en reprenant tes explication..
tu me dis :

Qui est R ? Connais pas...

Ah bon..et c'est quoi que tu calcules depuis le début.. 2n%pi...? si c'est pas R, ...?
j = Ri... Attention, tantôt tu écris <n tantôt ⩽... Sois plus rigoureux... ok...

j⩽min(pi∗29,n) : j doit être toujours être inférieur à la plus petite des deux valeurs entre n et pi*29, (min(a,b) = minimum de a et b en Python).

On est bien d'accord, mais tu oublies, dans l'exemple que l'on utilise avec n = 240 quand tu incrémentes les j +2*Pi..tu ne dépasses pas  n...? a QUOI BON , PUISQU' ALORS j n'est plus <= à 240  à quoi sert 'il, c'est 2n - (n-1 = j) qui nous intéresse..pour marquer les n <= 2ncongrus 2n%pi .c'est pour cela que dans pfam il est inutile d'avoir des j >= 240

ton tableau que j'ai bien compris min (29*pi) mais avec n=240 comment limiter avec pi = 11, puis 13, puis 17 et 19 que j lorsqu 'on les teste et qu'on les incr , on s'arrête à n<= 240...

pi> 5   29*pi    n     min(29*pi,n)
             
  7     203     240       
11    319     240    480 -253 n'est pas entre n et 2n..il ne peut surement éliminer un entier non premier de n à 2n   
13    377     240   ..etc ..480 - 353, il est > 240, d'où il ne peut supprimer un multiple de[tex]P_i\leqslant\sqrt{2n} [/tex] de n à 2n
17    493     240   ...etc ..480 -259, il est > 240, d'où il ne peut supprimer un multiple de[tex]P_i\leqslant\sqrt{2n} [/tex] de n à 2n
19    551     240 
  480 - 499  =..? > 240 et > 480 ....idem....

Le but du crible est bien d'éliminer entre n et 2n, les entiers non premiers,  ie): multiple de[tex]P_i\leqslant\sqrt{2n} [/tex]; en marquant [0]:
les entiers <= n, qui sont congru à 2n%Pi
.

avec effectivement: Tu veux parler de modulo pi avec pi∈Pi ? bien sûr , et Pi <= sqrt de 2n...

En modifiant quoi ? q,reste=divmod(j,30) ? alors tu calcules comment ton index ?

on a bien dans le processus :
après les 2 testes :if j%3!=0 and d_c!=5:

  j = X, appartenant à [7;n] et il n'est pas multiple de 3, ni de 5

donc cette ligne:
               fam =Dico[j%30] ["calcule à qu'elle famille X appartient si R==0, et comment on obtient en même temps le quotient
                if pfam['i][fam] == 0:  ..........................
                    pfam['i][fam] = j    ..........................
ce qui nous donnerait aussi l'index de X, et on par pour cribler , avec les instructions qui vont avec....on ferait le criblage à la suite..tu as détaillé toi même comment on obtient l'index dans le processus.. index = ((pfam[i'][j] - p8[j])// 30).
comme le fait ce bloc en dessous , sans avoir besoin d'appeler à nouveau pfam[0], puis [1]...[4]

je reprend ton exemple post#194: Exemple avec j=0 : Pf[0] c'est Pfam[1][0] qui vaut 271 (> 240) inutile de calculer...
              ici debut_index= (271- 11)//30 = 9  = quotient  (Le 1 c'est P8|0]

bloc que j'utilise dans la version G8Y par famille, et qui marche aussi bien que la dernière dans G9y peut importe l'une ou l'autre
.................................................................................................

#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
 

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

si on teste, puis on détermine la fam , et on index, j alors dans la foulée  on peut aller cribler .....!
sans avoir à passer par le bloc ci dessus qui fait le même travail que le bloc famille pour chaque Pi ... qui lui ne fait que remplir pfam[n] pour le bloc on crible les 8 colonne,
alors qu'il place les j dans les bonnes famille ...tu as détaillé ce processus , moi j'ai vu connaissant l'algorithme, que l'on pouvait obtenir le quotient pour indexer j et donc aller cribler..dans la foulée  ...

donc  on aurait pas non plus besoin "en principe"  de faire appel à: pfam.append([0,0,0,0,0,0,0,0]) que l'on supprime, puisqu'il n'est plus question de remplir et de positionner les j, dans pfam pour les envoyer ensuite au bloc criblage......non..?

yoshi
10-05-2018 17:37:35

Re,

je pensais que tu savais, que ces nombres dans pfam sont les nombres qui sont congrus à 2n modulo Pi (pi ?)

Ça, je sais, je vois, c'est la réponse à comment sont-ils fabriqués ?
Moi, ce qui m'intéresse, c'est qui ils sont, ce qu'ils représentent par rapport
- soit à l'ensemble des nombres  de 240 à 480
- soit à mes candidats à la primature : [241, 247, 251, 253, 257, 259, 263, 269, 271, 277, 281, 283, 287, 289, 293, 299, 301, 307, 311, 313, 317, 319, 323, 329, 331, 337, 341, 343, 347, 349, 353, 359, 361, 367, 371, 373, 377, 379, 383, 389, 391, 397, 401, 403, 407, 409, 413, 419, 421, 427, 431, 433, 437, 439, 443, 449, 451, 457, 461, 463, 467, 469, 473, 479]
- soit à la liste nombres (on passe de 40 nombres à 64 : ça m'a toujours épaté :)
[
[1, 1, 1, 1, 1, 0, 0, 1],
[0, 1, 0, 1, 1, 0, 1, 1],
[0, 1, 1, 1, 1, 0, 0, 0],
[1, 0, 0, 0, 1, 1, 0, 1],
[1, 1, 0, 1, 0, 1, 1, 0],
[1, 1, 1, 0, 0, 1, 1, 1],
[1, 0, 1, 1, 1, 1, 1, 0],
[0, 1, 0, 0, 1, 0, 1, 1]
]

En 1 mot comme en 100, je ne sais toujours ce que tu souhaites que je fasse.
Je dois m'inspirer de ce que tu as écrit ci dessous et de l'exemple traité après :

n=240,
Pi = [7,11,13,17,19] index de 0 à 4, et pfam de 0 à 4
j doit être au maximum <= f = pi*29 et et si j >= n break , on passe à Pi et R suivant;  tel que j <= n {ce que je n'ai pas réussi à faire ce matin car il y a une limites maxi pour les Pi petits  donc j <= f et si j >= n break , pour les Pi plus grands, tel que Pi*29 > n limite donc j >n l'instruction break , fait passer à Pi et R suivant; car ils cribleront  moins de 8 fam...

Qui est R ? Connais pas...
Attention, tantôt tu écris $<$n tantôt $\leqslant$... Sois plus rigoureux...

Il y a aussi que tu utilises des versions déjà modifiées (ce n'est pas la première fois !).
Par exemple, tu évoques ce bloc :

for i in range(lenpfam) :
        for j in range(8):
            index = int((pfam['i][j] - p8[j]) / 30)          
            while index < nbcell:
                nombres[j][index] = 0
                index += p['
i]

Alors qu'il date...
La dernière version en cours est celle-ci :

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

Si tu ne l'utilises pas, pourquoi ? que lui reproches-tu ?
Pour mémoire,
Primes_init pour n = 240 est : [7, 11, 13, 17, 19]. C'est bien ce que tu appelles Pi ?

j doit être au maximum <= f = pi*29 et et si j >= n break , on passe à Pi et R (?) suivant ;  tel que j <= n

Il y a deux cas de figure possibles
[tex]n\leqslant pi*29[/tex]  ---> On doit avoir [tex]j\leqslant n\; ***;\leqslant pi*29[/tex] et j ne peut pas être dans la zone [tex]***[/tex]
et
[tex]pi*29\leqslant n[/tex]  ---> On doit avoir [tex]j\leqslant pi*29\;***\;\leqslant n  [/tex] et j ne peut pas être dans la zone [tex]***[/tex]
Si oui, alors tu as parcouru mon grand tableau d'un œil distrait, parce que c'était bien mon interprétation première :
[tex]j \leqslant min(pi*29,n)[/tex] : j doit être toujours être inférieur à la plus petite des deux valeurs entre n et pi*29, (min(a,b) = minimum de a et b en Python).

>>> print (min(7,2))
2

 pi   29*pi    n     min(29*pi,n)
  1    29     120        29
  7   203     120       120
 11   319     120       120
 13   377     120       120
 17   493     120       120
 19   551     120       120
 23   667     120       120
 29   841     120       120

  1    29     300        29
  7   203     300       203
 11   319     300       300
 13   377     300       300
 17   493     300       300
 19   551     300       300
 23   667     300       300
 29   841     300       300

tu as les j  de pfam les entiers congrus à 2n [Pi]

Non, il ne peut pas y avoir de congruence modulo une liste : Pi = [7, 11, 13, 17, 19]. Tu veux parler de modulo pi avec [tex]pi \in Pi[/tex] ?
Attention, en Python, pi ou Pi ne désignent pas le même objet...
C'est pour ça que (habitude personnelle) je prends une initiale en minuscules pour une variable numérique et en capitales pour listes, Dictionnaires, chaînes...)

A.append(debut_index) --> désolé c'est une scorie non supprimée lors de mes essais
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0

Cette ligne ne me servait qu'à stocker tous les debut_index pour les examiner après.
N'a rien à faire dans le bloc.

Donc

    for i,Pf in enumerate(Pfam):                           # on garderait ces lignes ou pas ?
        pi=Primes_init[i]                                  # Si : non
        for j in range(8):                                 # Quoi à la place ?
            debut_index= ? # telle est la question clé ...
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0

Utiliser le quotient
lequel ? celui-ci : j//30 ?....... Réponse : oui ou non ?
On abandonnerait Dico[j%30] ? ...Non
Si on garde les deux, on peut les obtenir d'un coup : Excellente idée et en modifiant
q,reste=divmod(j,30)

En modifiant quoi ? q,reste=divmod(j,30) ? alors tu calcules comment ton index ?

J'arrête là parce que j'ai entrevu que tu as modifié ton post...

@+

LEG
10-05-2018 13:29:23

bonjour Yoshi
1)

j doit être au minimum <= f = pi*29 et au maximum <= n ;  tel que j <= n :

erreur de ma part j'ai rectifié ce matin..

2) j'ai repris le post d'hier que j'ai entièrement rectifié ce matin et que j'aurai dû supprimer  #post 220 juste au dessus de ta réponse..
c'est celui ci qu'il faut prendre en compte.

3) oui pour la suppression de append  pf=[0,0,0,0,0,0,0,0]
la raison est dans le processus du post #220 qui est en principe évidente suite aux explications que tu m'as donné hier et avant hier dans le processus des deux Phases..

4)

Je ne comprends pas tes notations ;
- que veulent dire les "deux points" 0:271 et 6:293 ?

ce sont tes notation que j'ai écris à l'envers par erreur dans Dico={271:0........293:6...} fam 1:0 et fam 23:6

5)

Utiliser le quotient
lequel ? celui-ci : j//30 ?....... 
On abandonnerait Dico[j%30] ? ...Non
Si on garde les deux, on peut les obtenir d'un coup : Excellente idée et en modiffiant
q,reste=divmod(j,30) :

ce bloc,  à la place de:  fam =Dico[j%30]  à fin d'avoir l'index , pour cribler directement à partir du rang de l'index, en modifiant les deux lignes qui suivent...par celle du criblage en phase S3 :
 

if j%3!=0 and j%5!=0:
                fam =Dico[j%30]      
               [b] if Pf[fam] == 0:
                    Pf[fam] = j[/b]

A.append(debut_index)
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0

Voila l'idée, et on se passerait de Pfam...Non ?....

6)

Essaie de m'expliquer de façon "ramassée" quelle est exactement ton idée.
Tu veux te passer de Pfam ?
Je t'ai déjà demandé 2 fois (si ce n'est 3) de me dire ce que représentent les nombres de Pfam, comment tu peux les qualifier...

depuis le début, on est dans les congruences je pensais que tu savais, que ces nombres dans pfam sont les nombres qui sont congrus à 2n modulo Pi

J'ai vu que:

Pfam =[
[151,  67,  11, 193, 137, 109, 53, 179]
  5    2     0    6    4    3   1    5          .......> j//30. que l'on peut remplacer  dans la phase S2, de par tes explications :
:donc fam =Dico[j%30]=Dico[7%30]= Dico[7]est le quotient ==(0)....Non..?

[271,  7, 161,  73, 227, 139, 293,  29]   ..............> :  480-271 = 209 non premier mais de 7 à n ?
  9    0     5   2    7    4    9    0
[181, 337, 311, 103,  77, 259, 233, 389]  .....> 480-337 =143 non prime de 7 à n..?, idem 480-311 , idem 480- 259..etc
  6    11   10    3    2    8    7   12
[361, 157, 191, 463, 497, 259, 293,  89]  ....>on criblerai à l'envers si dans pfam on prend des j > 240...!..en plus des non primes..
12    5     6   15   16    8    9    2
[271, 157, 461,  43, 347, 499, 233, 119] 
    9   5   15    1   11   16    7    3
]

(C'est de là que viennent les (0) (6) vus plus haut ?

Pas du tout..
tu as les j  de pfam les entiers congrs à 2n [Pi] et dessous  les index des j , qui déterminent le rang dans les colonnes = Familles ou l'indice des lignes, dans les colonnes ..comme tu veux..,

Exemple Pfam [0] l'entier j = 151 famille 1; partira du 5ème rang par pas de 7 de 5 à 8 ; pour changer les nbcell[1] en [0]
comme pour 240/30 tu n'as que 8 lignes numéroté de 0 à 7 ...on passe au j suivant...67 , rang 2 famille 7; par pas de 7 de 2 à 8...etc

voila pourquoi on criblerai directement de la phase S2, sans avoir même besoin de faire append fam [0,0,0,0,0,0,0,0].
suivant ton processus expliqué, que le programme exécute, et qui correspond vraiment à l'algorithme du crible...
processus décrit entièrement au dessus, post #220...

suite à ce processus :
ce qui suit ci dessous ne sert strictement à rien , déjà à cause des j > n = 240...tu en conviendras.

Je peux modifier Pfam (une ligne) pour que les j %30 d'une même sous-liste, soient les mêmes, comme ça : (inutile)
[
[151, 271, 181, 361, 271]
[67, 7, 337, 157, 157]
[193, 73, 103, 463, 43]
[137, 227, 77, 497, 347]
[109, 139, 259, 259, 499]
[53, 293, 233, 293, 233]
[179, 29, 389, 89, 119]

Ceci est le résultat de tes explications, dans le processus de la phase S3, criblage.
Qui met tout en évidence, et les erreurs qu'à fait mon petit fils dans le déroulement du programme ...

y compris de ne pas limiter les j = entiers congrus 2n%Pi, dans les pfam, > n; heureusement sans incidence ...puisque cela nous donnerai les entiers de 7 à N et non de N à 2n, qui ne sont pas premiers..bref...comme dirait pépin...

@ +

yoshi
10-05-2018 12:16:37

Bonjour,

Je commence à regarder ce que tu as écrit...

j doit être au minimum <= f = pi*29 et au maximum <= n ;  tel que j <= n

Alors là, il faut simplifier :
si tu as :
[tex]\begin{cases}j\leqslant pi*29\\j\leqslant 240\end{cases}[/tex]
et si j'ai bien compris ce que tiu veux dire,il y a une des deux lignes inutiles ..
En  effet


pi           pi*29         n           2n
 1            29          240         480
 7           203          240         480
11           319          240         480
13           377          240         480
19           493          240         480

pour les deux premières lignes si j<=pi*29 cette condition prime sur l'autre : alors  j est automatiquement <=240
pour les autres, si j<= 240 alors cette condition prime sur l'autre : alors  j est automatiquement <=pi*29
Tout dépend de n et de pi...
On doit avoir, à partir de pi=7, [tex]j\leqslant \min(29*pi,n)[/tex]
Vérification :


 pi   29*pi    n     min(29*pi,n)
  1    29      30        29
  7   203      30        30
 11   319      30        30
 13   377      30        30
 17   493      30        30
 19   551      30        30
 23   667      30        30
 29   841      30        30

  1    29     120        29
  7   203     120       120
 11   319     120       120
 13   377     120       120
 17   493     120       120
 19   551     120       120
 23   667     120       120
 29   841     120       120

  1    29     210        29
  7   203     210       203
 11   319     210       210
 13   377     210       210
 17   493     210       210
 19   551     210       210
 23   667     210       210
 29   841     210       210

  1    29     300        29
  7   203     300       203
 11   319     300       300
 13   377     300       300
 17   493     300       300
 19   551     300       300
 23   667     300       300
 29   841     300       300

  1    29     390        29
  7   203     390       203
 11   319     390       319
 13   377     390       377
 17   493     390       390
 19   551     390       390
 23   667     390       390
 29   841     390       390

  1    29     480        29
  7   203     480       203
 11   319     480       319
 13   377     480       377
 17   493     480       480
 19   551     480       480
 23   667     480       480
 29   841     480       480

  1    29     570        29
  7   203     570       203
 11   319     570       319
 13   377     570       377
 17   493     570       493
 19   551     570       551
 23   667     570       570
 29   841     570       570

  1    29     660        29
  7   203     660       203
 11   319     660       319
 13   377     660       377
 17   493     660       493
 19   551     660       551
 23   667     660       660
 29   841     660       660

  1    29     750        29
  7   203     750       203
 11   319     750       319
 13   377     750       377
 17   493     750       493
 19   551     750       551
 23   667     750       667
 29   841     750       750

  1    29     840        29
  7   203     840       203
 11   319     840       319
 13   377     840       377
 17   493     840       493
 19   551     840       551
 23   667     840       667
 29   841     840       840

  1    29     930        29
  7   203     930       203
 11   319     930       319
 13   377     930       377
 17   493     930       493
 19   551     930       551
 23   667     930       667
 29   841     930       841

  1    29    1020        29
  7   203    1020       203
 11   319    1020       319
 13   377    1020       377
 17   493    1020       493
 19   551    1020       551
 23   667    1020       667
 29   841    1020       841

  1    29    1110        29
  7   203    1110       203
 11   319    1110       319
 13   377    1110       377
 17   493    1110       493
 19   551    1110       551
 23   667    1110       667
 29   841    1110       841

  1    29    1200        29
  7   203    1200       203
 11   319    1200       319
 13   377    1200       377
 17   493    1200       493
 19   551    1200       551
 23   667    1200       667
 29   841    1200       841

  1    29    1290        29
  7   203    1290       203
 11   319    1290       319
 13   377    1290       377
 17   493    1290       493
 19   551    1290       551
 23   667    1290       667
 29   841    1290       841

ou alors ce que tu as voulu écrire est plutôt :
[tex]29*pi\leqslant <\leqslant n[/tex] ?

Parce que ça, sinon :

j doit être au minimum <= f = pi*29 et au maximum <= n ;  tel que j <= n

, mathématiquement, je ne sais pas ce que ça veut dire : un minimum, c'est une valeur plancher, comment j peut-il être inférieur ou = à un minimum ?

n = 240,
le premier index = 0:271 étant > 240 il ne devrait pas y être, ni 6:293
(...)
P8 = [1 , 7 , 11 ,  13 , 17 , 19 , 23 , 29]
....[(5),(2),(0), (6), (4), (3), (1),(5) ]

Je ne comprends pas tes notations ;
- que veulent dire les "deux points" 0:271 et 6:293 ?
- 0 et 6 correspondent à quoi ? des valeurs de i du bloc ?
- (0), (6) : ce 0 et ce 6 sont obtenus de la même façon que ci-dessus ? Sinon; comment ? Pourquoi ces parenthèses ?

post#216 a écrit :

A-t-on j%3==0 ou j%5==0 ?
   Non.
   | Donc fam =Dico[j%30]=Dico[11%30]=Dico[11] , (OK ..et le quotient pourquoi ne pas l'utiliser..?)
, soit fam=2. Et puisque Pf[2] (c'est à dire Pfam[0][2]) ==0,  à la place du 0, on écrit 11 :  Alors que l'on aurait dû cribler , en partant de  (0):2 qui serra le rang , l'index de  de la famille 11:2..à cet étape ..Non...?

Utiliser le quotient
lequel ? celui-ci : j//30 ? Et tu en ferais quoi exactement ?
On abandonnerait j%30 et Dico[j%30] ?
Si on garde les deux, on peut les obtenir d'un coup :
q,reste=divmod(j,30) :

>>> q,reste=divmod(693,30)
>>> q
23
>>> reste
3
>>>

Un peu de synthèse.
Soient les deux blocs :

    # FAMILLES POUR CHAQUE Pi
    start_time = time()
    Debuts_i=[]
    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]//10//3
            A.append(debut_index)
            Nombres_j=nombres[j]
            for index in range(debut_index, nbcell,pi):
                Nombres_j[index] = 0

Seul le 2e bloc "On crible les 8 colonnes" va être modifié ?
Là  ?


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

Essaie de m'expliquer de façon "ramassée" quelle est exactement ton idée.
Tu veux te passer de Pfam ?
Je t'ai déjà demandé 2 fois (si ce n'est 3) de me dire ce que représentent les nombres de Pfam, comment tu peux les qualifier...
J'ai vu que


Pfam =[
[151,  67,  11, 193, 137, 109, 53, 179]
  5    2     0    6    4    3   1    5          j//30
[271,  7, 161,  73, 227, 139, 293,  29]
  9    0     5   2    7    4    9    0
[181, 337, 311, 103,  77, 259, 233, 389]
  6    11   10    3    2    8    7   12
[361, 157, 191, 463, 497, 259, 293,  89]
 12    5     6   15   16    8    9    2
[271, 157, 461,  43, 347, 499, 233, 119]
    9   5   15    1   11   16    7    3
]

(C'est de là que viennent les (0) (6) vus plus haut ? j//30 ? Le j%30 =12 sera utilisé comment pour index ?)


il y  40 éléments dans Prefam, alors que nombres contient 64 éléments (des 1 et des 0)...
Oui, je sais, tous les j de chaque sous-liste ci-dessus sont dans l'ordre croissant des j%30 : 1 7 11 13 17 19 23 29
Mais ça ne me dit pas qui ils sont.
Je peux modifier Pfam (une ligne) pour que les j %30 d'une même sous-liste, soient les mêmes, comme ça :
[
[151, 271, 181, 361, 271]
[67, 7, 337, 157, 157]
[193, 73, 103, 463, 43]
[137, 227, 77, 497, 347]
[109, 139, 259, 259, 499]
[53, 293, 233, 293, 233]
[179, 29, 389, 89, 119]
]
Au lieu d'avoir 5 sous-listes de 8, j'ai 8 sous-listes de 5 de restes dans la division par 30 : 1 7 11 13 17 19 23 29...
Je vois comment les fabriquer, les regrouper différemment, mais ça ne me dit pas qui ils sont, pourquoi il y en a 40, pourquoi dans nombres on passe à 64.
Je vois le détail de ces calculs, je peux les décrire (je l'ai déjà fait), mais ça ne me dit pas pourquoi...

J'ai encore aujourd'hui et demain...
Samedi c'est l'AG de mon Assoc, et à partir de lundi, je devrai m'occuper en priorité de notre revue (le n° de juin)...

@+

LEG
10-05-2018 08:03:01

pour répondre au 2 posts ci -dessus, en espérant t'éviter à nouveau tes explications , suivant ces dernière j'ai répété ton processus,dans l'ordre en partant de R; afin de te montrer ce problème de dépassement de j >= n , et dans ton cas précis n=240
...................................
Tes explications du 7/5, post #194 ;  et 85
Désolé, je me suis absenté...
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.
Pfam : (en gras les j > n=240 , il y en a 1/3
[
[151, 67, 11, 193, 137, 109, 53, 179],                --->Pf =   Pfam[0]  ;  pi=Primes_init[0] = 7
[271, 7, 161, 73, 227, 139, 932, 29],                  --->Pf =   Pfam[1]  ; pi=Primes_init[1]  =11
[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
Suite…
***********************************************************************************
n=240,
Pi = [7,11,13,17,19] index de 0 à 4, et pfam de 0 à 4
j doit être au maximum <= f = pi*29 et et si j >= n break , on passe à Pi et R suivant;  tel que j <= n {ce que je n'ai pas réussi à faire ce matin car il y a une limites maxi pour les Pi petits  donc j <= f et si j >= n break , pour les Pi plus grands, tel que Pi*29 > n limite donc j >n l'instruction break , fait passer à Pi et R suivant; car ils cribleront  moins de 8 fam...

On peut peut-être procéder comme ci-dessous :

Exemple, suivant le processus de tes deux exemples entre phase s2 et phase s3: pour ne faire qu’un processus

On a déjà fait Pi[0] =7 , pfam[0]
………..
d’où en exemple, on passe à Pi[1] suivant = 11 ;  f = 11*29 = 319 > n… ? alors  on doit limiter dans pfam[1] la limite de j :

[«  ceci est ton ex pfam[1]: [271, 7, 161, 73, 227, 139, 293, 29],                  --->Pf =   Pfam[1]  ; pi=Primes_init[1]  =11
suivant le processus ci-dessous : »]

pi[1] =11, R(1) = 7

j=7
à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[7%30]= Dico[7]est le quotient ==(0)
soit fam 1 et puisque Pf[21], (c'est à dire Pfam[0][1]) index(0)) on part cribler par pas de Pi[0] = 11 de (0) à 8 (nbcell = 8)et on passe à j suivant.

J =7+22= 29
à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[29%30]= Dico[29]est le quotient ==(0)
soit fam 6 et puisque Pf[6], (c'est à dire Pfam[0][6]) index(0))on part cribler par pas de 11 de (0) à 8 (nbcell = 8)et on passe à j suivant.
J= 29+22 =51

à t’on j%3==0 ou j%5 ==0
oui : On passe directement au j suivant :: j = 51+22 = 73

à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[73%30]= Dico[13]est le quotient ==(2)
soit fam  et puisque Pf[3], (c'est à dire Pfam[0][3]) index(2))on part cribler par pas de 11 de (0) à 8 (nbcell = 8) et on passe à j suivant.
J =73+22 = 95

à t’on j%3==0 ou j%5 ==0
oui ; On passe directement au j suivant :: j = 95+22 = 117

à t’on j%3==0 ou j%5 ==0
oui ; On passe directement au j suivant :: j = 117+22 = 139

à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[139%30]= Dico[19]est le quotient ==(4)
soit fam  et puisque Pf[5], (c'est à dire Pfam[0][5]) index(4))on part cribler par pas de 11 de (0) à 8 (nbcell = 8) et on passe à j suivant.
J = 139 +22 = 161

à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[161%30]= Dico[11]est le quotient ==(5)
soit fam  et puisque Pf[2], (c'est à dire Pfam[0][2]) index(5))on part cribler par pas de 11 de (0) à 8 (nbcell = 8) et on passe à j suivant.
J = 161 + 22 =183.

à t’on j%3==0 ou j%5 ==0
oui ; On passe directement au j suivant :: j = 183+22 = 205

à t’on j%3==0 ou j%5 ==0
oui ; On passe directement au j suivant :: j = 205+22 = 227

à t’on j%3==0 ou j%5 ==0
non
donc fam =Dico[j%30]=Dico[227%30]= Dico[17]est le quotient ==(7)
soit fam  et puisque Pf[4], (c'est à dire Pfam[0][4]) index(7))on part cribler par pas de 11 de (0) à 8 (nbcell = 8) et on passe à j suivant.

J = 227 +22 = 249 > n = 240 Break  Cela met fin au processus de pfam[1]; on passe Pi[2] et R[2] .... ;
le criblage des fam, serra dans l'ordre de [p8 = [1,6,3,5,2,4] ] sur 8......> pi suivant.

on passe à Pi [2] suivant et R[2] ; on réitère le processus. Jusqu’au dernier Pi[4] .

Les Pi étant de plus en plus grand, le processus serra de plus en plus court, de ce fait l’algorithme accélère … en phase de criblage final.

Mais cela nous évite de passer par cette étape :

for i in range(lenpfam) :
        for j in range(8):
            index = int((pfam['i][j] - p8[j]) / 30)           
            while index < nbcell:
                nombres[j][index] = 0
                index += p['i]
………………………………………….

Pied de page des forums