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
\(n\leqslant pi*29\) ---> On doit avoir
\(j\leqslant n\; ***;\leqslant pi*29\) et j ne peut pas être dans la zone
\(***\)
et
\(pi*29\leqslant n\) ---> On doit avoir
\(j\leqslant pi*29\;***\;\leqslant n \) et j ne peut pas être dans la zone
\(***\)
Si oui, alors tu as parcouru mon grand tableau d'un œil distrait, parce que c'était bien mon interprétation première :
\(j \leqslant 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).
>>> print (min(7,2))
2
pi 29*pi n min(29*pi,n)
[s] 1 29 120 29[/s]
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
[s] 1 29 300 29[/s]
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
\(pi \in Pi\) ?
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...
@+