Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#401 31-10-2024 11:10:14
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
Bonjour LEG,
Je vais regarder ça, mais il va falloir que je me replonge dedans pour me remettre en mémoire l'architecture développée avec ton cahier des charges...
Quand j'aurai trouvé, je réfléchirai à la façon d'utiliser le module mathématique numpy qui gère de vrais tableaux et non pas des Listes : ce qui améliorerait encore sensiblement la vitesse d'exécution...
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#402 31-10-2024 11:57:27
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Bonjour Yoshi
je vois que tu as toujours plein de bonnes idées...
en définitive il me faut uniquement "taper" cribler uniquement la racine carrée du tableau de [1] construit à cette étape :
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int((n)**0.5)
# On génère un tableau de N/30 cases rempli de 1
lencrible = ((n1//30)+1)
soit un tableau de 1:
$((\sqrt{n} )// 30 )*1$
D'autant que l'on peut conjecturer que pour toute limite $n$ fixée il y a toujours par famille $30k+i$ tel que défini dans l'algorithme, une solution d'une décomposition de $2n =(p+q)$ , tel qu'il existe un nombre premier $p'\not\equiv{2n}[P]$ de $1 \; à \;\sqrt{n}$ en progression arithmétique de raison 30 pour $n \geqslant{10^9}$ , autrement dit la conjecture serait vrai à partir de cette limite et par famille quelque soit l'une des 8 familles $30k+i$ fixée...
Merci @+
Dernière modification par LEG (01-11-2024 08:15:49)
Hors ligne
#403 01-11-2024 06:35:55
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Bonjour @Yoshi
la nuit porte conseil...
voila ce que je viens de modifier, dans le programme Crible modulo 2 - EG_2N.py , (qui est le même que celui posé ci-dessus modulo 30)
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int((n)**0.5)
# Attention , On génère un tableau de N/2 cases rempli de 1 car on travaille dans l'ensemble des netiers naturel impairs
lencrible = ((n1//2)*1)
crible=[1 for _ in range(lencrible)] ## c'est plus propre comme ça
ce programme lui : il crée un tableau de 1 $\leqslant\sqrt{n}$, donc uniquement inférieur à racine de $n$ ; puis il crible les nombres premiers $p'\not\equiv{2n}[2]\leqslant \sqrt{n}$ afin de vérifier si il existe une solution telle que : $2n =(p'+q)$ en utilisant uniquement les premiers $p'\leqslant\sqrt{n}$ ...
Qui peut le moins peut le plus ,
Car effectivement si la conjecture de Goldbach a été vérifié pour tout $2n > 4$ jusqu'à $4\times{10^{21}}$
La question est : est ce qu'elle est toujours vrai , en utilisant les entiers premiers $p'$ uniquement inférieur à la racine de $n$ en prenant au minimum $n\geqslant{10^9}$ afin de vérifier plus loin : $n\geqslant{10^{22}}$cette conjecture
Voici le résultat pour la valeur de $n=900$ en choisissant les entiers impairs , donc modulo 2....
Donnez N: 900
Nombre premiers p' criblés >2, famille 1 (entiers impairs) : 12 ----- 0.0
crible É ET G: [0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1]
Nombres p' non congru 2n[P] ou couple p'+ q = 2N, de (1) à sqrt{900} entiers A impairs , 1 modulo 2 : 4 ----- 0.0
je vais donc faire la même modification pour le crible modulo 30 que je viens de modifier sur le post #402 juste au-dessus ...
en définitive ça paraissait relativement simple...
ça fonctionne
résultat pour N (modulo 30) = 900
Donnez N: 900
crible Ératosthène : [1, 1]
Nombre premiers criblés famille 19 : 2 ----- 0.0
crible É ET G: [0, 0]
Nombres P' non congru 2n[pi] < sqrt n , ou couple P'+q = 2N, de (1) à sqrt de 900 famille 19 : 0 ----- 0.0
Donnez N: 300000
crible Ératosthène : [1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0]
Nombre premiers criblés famille 19 : 12 ----- 0.0
crible É ET G: [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0]
Nombres P' non congru 2n[pi] < sqrt n , ou couple P'+q = 2N, de (1) à sqrt de 300000 famille 19 : 5 ----- 0.0
Mais attention il y a des erreurs nb de couples p+q en plus par rapport au c++ ... je suppose que le criblage modulo 30 doit créer un souci en python, car on part du reste $R$ de $2n$ par $P$ , que l'on doit indicer , or si le $R$ de $2n$ par $P$ est supérieur à la valeur de la racine carré de $n$ du tableau à cribler il y a des nombres premiers qui ne pourront pas cribler , d'où augmentation du nombre de solutions qui décomposent 2n ...!
Alors que si on crible modulo 2 les entiers impairs donc des 8 familles c'est identique au C++.
je vais donc voire en C++ ce qu'il faut faire... pour modifier cette instruction...(je pense que c'est la dernière ligne ) :
size_t lencrible = sqrt(limite)/30; // attention on crible les $p'\not\equiv{2N}[P] \leqslant \sqrt{n}$ qui est la limite $n$ fixée
Je joins le programme modifié pour ne cribler que les $p'$ inférieur à racine de $n$ :
// -*- compile-command: "/usr/bin/g++ -g goldbachs.cc" -*-
#include <vector>
#include <iostream>
#include <cmath>
#include <stdlib.h>
#include <time.h>
using namespace std;
// fill Erathosthene sieve crible for searching primes up to 2*crible.size()*32+1
// crible is a (packed) bit array, crible[i] is true if 2*i+1 is a prime
// crible must be set to true at startup
void fill_crible(vector<unsigned> &crible, unsigned p)
{
crible.resize((p - 1) / 64 + 1);
unsigned cs = crible.size();
unsigned lastnum = 64 * cs;
unsigned lastsieve = int(std::sqrt(double(lastnum)));
unsigned primesieved = 1;
crible[0] = 0xfffffffe; // 1 is not prime and not sieved (2 is not sieved)
for (unsigned i = 1; i < cs; ++i)
crible[i] = 0xffffffff;
for (; primesieved <= lastsieve; primesieved += 2)
{
// find next prime
unsigned pos = primesieved / 2;
for (; pos < cs; pos++)
{
if (crible[pos / 32] & (1 << (pos % 32)))
break;
}
// set mutiples of (2*pos+1) to false
primesieved = 2 * pos + 1;
unsigned n = 3 * primesieved;
for (; n < lastnum; n += 2 * primesieved)
{
pos = (n - 1) / 2;
crible[(pos / 32)] &= ~(1 << (pos % 32));
}
}
}
unsigned nextprime(vector<unsigned> &crible, unsigned p)
{
// assumes crible has been filled
++p;
if (p % 2 == 0)
++p;
unsigned pos = (p - 1) / 2, cs = crible.size() * 32;
if (2 * cs + 1 <= p)
return -1;
for (; pos < cs; ++pos)
{
if (crible[pos / 32] & (1 << (pos % 32)))
{
pos = 2 * pos + 1;
// if (pos!=nextprime(int(p)).val) CERR << "error " << p << endl;
return pos;
}
}
return -1;
}
typedef unsigned long long ulonglong;
size_t ECrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{ //on va contruire un tableau d'entier A modulo 30 représenté par des 1 et rappeler les premiers p
int cl = clock();
// size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on va contruire un tableau de 1 modulo 30 en divisant N par 30
//vector<bool> crible(lencrible, true); // on rappelle les nombres premiers p d'Eratotene ci dessus
// ulonglong n2=2*n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong produit;
int GM[] = {7, 11, 13, 17, 19, 23, 29, 31}; // on va calculer le produit de p par un element du groupe GM
for (size_t j = 0; j < sizeof(GM) / sizeof(int); j++)
{
produit = p * GM[j]; // calcul du produit, jusqu'a ce que le produit soit égale à fam modulo 30
if (produit % 30 == fam)
{
produit /= 30; // puis on va va calculer l'indice, afin de commencer à cribler de l'indice à n/30 et on réitère
break;
}
}
indices[i] = produit;
}
ulonglong nslices = lencrible / 1500000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]);
cout << " Nbr p' criblés Fam " << fam << " < à " << n << ": " << total;// " time " << (clock() - cl) * 1e-6 << endl;
return total; // à la fin du crible on return le résultat est le temps mis
}
size_t GCrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{
int cl = clock();
//size_t lencrible = n / 30,
size_t nbpremiers = premiers.size(); //on utilise le tableau des A mod 30 représenter par des 1, criblé par Ératosthène ci dessus
//vector<bool> crible(lencrible, true); //on rappelle le tableau criblés d'Eratotene ci dessus avec ses nombres premiers p
ulonglong n2 = 2 * n;
vector<ulonglong> indices(nbpremiers);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
ulonglong reste = n2 % p; // on calcule le reste r de 2n par p
if (reste % 2 == 0)
reste += p;
ulonglong pi2 = 2 * p;
while (reste % 30 != fam) // tant que le reste += p n'est pas = à Fam % 30 on rajoute 2*p
reste += pi2;
reste /= 30; // ensuite on va calculer l'indice pour commencer à cribler le tableau de 1.1.1.... avec p, de l'indice à n/30
indices[i] = reste;
}
ulonglong nslices = lencrible / 1500000, currentslice = 0;
if (nslices == 0)
nslices = 1;
for (; currentslice < nslices; ++currentslice)
{
size_t slicelimit = currentslice + 1;
slicelimit = slicelimit == nslices ? lencrible : (currentslice + 1) * (lencrible / nslices);
for (size_t i = 0; i < nbpremiers; ++i)
{
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]); // le criblage du tableau de 1 modulo 30 jusqu'a n/30 (1.1.1.1...etc) est fini on va retourner le résultat
cout << " Nbr couple p+q criblés Fam " << fam << " : " << total;// " time " << (clock() - cl) * 1e-6 << endl;
return total;
}
int main(int argc, char **argv)
{
vector<unsigned> temp;
ulonglong debut = 900000000000000; // on rente le début de la limite n fixée , puis la fin augmenté de 15 pour cribler jusqu'à la limite ou la sqrt (limite) ligne 186
ulonglong fin = 900000000000015;
vector<int> familles;
//familles.push_back(1);
familles.push_back(7);
familles.push_back(11);
//familles.push_back(13);
//familles.push_back(17);
//familles.push_back(19);
//familles.push_back(23);
//familles.push_back(29);
for (int i = 0; i < familles.size(); i++)
{
int fam = familles[i];
for (ulonglong limite = debut; limite < fin; limite += 15){
cout << "--> limite : " << limite << endl;
double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
fill_crible(temp, sqrt2N);
vector<ulonglong> premiers;
for (ulonglong p = 7; p <= sqrt2N;)
{
premiers.push_back(p);
p = nextprime(temp, p);
if (p == unsigned(-1))
break;
}
size_t lencrible = sqrt(limite)/30; // attention on crible les p' non congru 2n[P] < ou = à racine de la limite n fixée
vector<bool> crible(lencrible, true);
ECrible(premiers, limite, fam, crible, lencrible);
GCrible(premiers, limite, fam, crible, lencrible);
}
}
}
Sachant que pour cette conjecture : La conjecture de Goldbach est vérifiée pour tous les entiers pairs jusqu’à $4.10^{18}$ (Tomás Oliveira e Silva, Siegfried Herzog et Silvio Pardi12 en juillet 2014)
Sachant qu'il existe toujours une solution pour décomposer un entier $2n$ en somme de deux nombres premiers $p'+q$, pour une limite $n$ fixée de 1 à la racine carré de cette limite $n$ criblée
C'est à dire qu'il n'est nul besoin d'utiliser tous les nombres premiers inférieur à $n$, mais seulement $\leqslant\sqrt{n}$ ce qui veut dire ,qu'il y a toujours un nombre premiers $p'$ tel que $p'\not\equiv{2n}[P]\leqslant\sqrt{n}$ qui est solution pour décomposer l'entier $2n$ au minimum, $> 6000000$ en somme de deux nombres premiers $(p'+q)$ et par famille !
Rien qu''avec mon PC et le crible de Goldbach en C++, on peut dépasser cette limite par Famille $30k+i$ , déjà jusqu'à $9*10^{18}$;
Alors avec un calculateur on dépasse allègrement les $10^{30}$ plus loin que la conjecture faible de H Elfgott...
@+
Dernière modification par LEG (Hier 16:10:49)
Hors ligne
#404 01-11-2024 13:43:13
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
Bonjour,
Si je veux tester, il va falloir que je retraduise en Python.
Et ensuite que je passe un coup de numpy dessus...
Mais, depuis hier, je m'interroge sur une apparente subtilité.
On génère un tableau de N/30 cases rempli de 1
lencrible = ((n1//30)+1)
Ci-dessous : à quoi sert de multiplier par 1 ? (subtilité propre à C++ ?
# Attention , On génère un tableau de N/2 cases rempli de 1 car on travaille dans l'ensemble des entiers naturel impairs
lencrible = ((n1//2)*1)
D'autant que lencrible n'est pas un tableau rempli de 1 mais le nombre d'éléments du tableau qui est construit après :
crible=[1 for _ in range(lencrible)] ## c'est plus propre comme ça
En outre, le 1er lencrible calculé est supérieur de 1 au 2e...
c'est plus propre comme ça
Ah bon ? Et en quoi ce serait plus propre que par exemple : crible=[1 for i in range(lencrible)] ?
Je vais faire plus de 600 tests de 10 en 10 où je vais tester l'égalité des résultats sans multiplier par 1 et en effectuant la multiplication
>>> vrais, nb_tests=0,0
>>> for i in range(357, 1008):
nb_tests+=1
l, l1=(i//2),(i//2)*1
if l==l1:
vrais+=1
>>> print (nb_tests, vrais)
651 651
>>>
L'égalité des 2 résultats est vraie 651 fois sur 651.
Je pourrais recommencer avec 2000 nombres entiers i tirés au hasard entre 6500 et 56000 (par exemple), j'arriverais au même constat
Conclusion : la multiplication par 1 est, en Python donc et en maths en général, une opération "blanche" :.
En effet, le nombre 1 est élément neutre pour la multiplication dans $\mathbb C$ (l'ensemble des nombres complexes dans lequel sont inclus tous les autres ensembles de nombres :
$\mathbb N \subset \mathbb Z \subset \mathbb D \subset \mathbb Q \subset \mathbb R \subset \mathbb C$
Cela signifie que : $\forall z \in \mathbb C, z * 1 = 1* z = z$ ($\forall$= Pour tout, Quel que soit)
Alors ici :
si ne note $l=(n1//2)$, alors $\forall\; l \in \mathbb N, l*1 = 1*l= l$
D'où ma question : pourquoi cette multiplication ?
Autres remarques
1. Lu dans la dernière version Python :
def demander_N():
n = input("Donnez N: ")
n = int(n.strip().replace(" ", ""))
#n = int(30 * round(float(n)/30))
#print(f"On prend N = {n} (30 * {int(n/30)})")
return n
et plus particulièrement cette ligne :
n = int(n.strip().replace(" ", ""))
(J'ai vérifié avant de la signaler)
En Python, la méthode strip() retire tous les espaces en début et fin de chaîne :
>>> S=" 12345 "
>>> S.strip()
'12345'
>>>
Mais, sur les espaces intérieurs, strip() est inopérant !
>>> S=" 1 2 3 4 5 "
>>> S.strip()
'1 2 3 4 5'
>>>
Et donc, vous avez rajouté la méthode replace et maintenant, c'est bon :
>>> S=" 1 2 3 4 5 "
>>> S.strip().replace" ","")
'12345'
>>>
Bin, alors, diras-tu, où est le souci ?
Il n'y a pas de souci, juste que dans ce cas, strip() ne sert à rien, replace() se charge de tout le boulot toute seule :
>>> S=" 1 2 3 4 5 "
>>> S.replace(" ","")
'12345'
>>>
2. n=input("Donner N :")
Là, par contre, il y a constamment des alternances joyeuses entre minuscules et capitales...
Moi, ça me gêne beaucoup et d'autres probablement pas du tout. Je n'y peux rien, je suis comme ça, je trouve ça malsain....
J'aurais préféré lire : n=input("Donner n :") même si ça ne change rien au fonctionnement.
J'ai pris cette habitude, de désigner les variables numériques par des minuscules, les ensembles, les listes, les dictionnaires, les chaînes par des capitales...
3. Lire pi = ..., me chiffonne aussi...
Que ce soit Pi ou pi, chaque fois je dois obliger mon cerveau à ne pas lire $\Pi$ ou $\pi$.
Là encore, je (pour insister que c'est totalement subjectif), j'aurais préféré P_i ou p_i, soit : $P_i$ ou $p_i$
Bon, je vais aller casser la croute, puis j'imprimerai tes deux codes Python (le dernier dispo) et C++ et commencer à faire ma traduction.
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#405 01-11-2024 15:34:05
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Bon appétit
attention c'est bien toi qui m'a refait les programmes ...
Ci-dessous : à quoi sert de multiplier par 1 ? (subtilité propre à C++ ?
1) on a définie la taille du tableau de 1 à cribler .....ok ? les 1 représentent les entiers $30k+i$ en progression arithmétique de raison 30 de premier terme i
[19,49,79,.....etc 19modulo 30 ....
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int((n)**0.5)
de sorte que la taille du tableau à cribler est $\leqslant\sqrt{n}$
d'où
lencrible = (n1//30)
Exemple je fixe la limite $n=300001$ je fixe la Fam =19 en fin de programme , pour avoir le nombre de solutions ou de $p'\not\equiv{2n}[P]$ c'est à dire le nombre de couples $(p'+q)=2n=600002$ .... ok ?
résultat :
Donnez N: 300001
crible É ET G: [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0] ## les 3 p' non conguent à 2n
Nombres P' non congru 2n[pi] < sqrt n , ou couple P'+q = 2N, de (1) à sqrt de 300001 famille 19 : 3 ----- 0.0
tu as bien tes 3 couples $(p'+q)=2n = 600002$ inférieur à racine de n , qui sont 19 , (19+18) = 199 et (199+180) = 379
D'autant que lencrible n'est pas un tableau rempli de 1 mais le nombre d'éléments du tableau qui est construit après :
ça je te laisse ... voir .
mais je vais essayer ,: effectivement lencrible = (n1//30) le + 1 , ne sert à rien ; et j'ai modifié car il rajoute une cellule en plus : en effet ,
$\sqrt{300001} // 30 = 18$ et non 19
pour le reste : il me semble que c'était pour arrondir la valeur de n divisible par 30 au cas ou une valeur n'était pas un multiple de 30 mais je n'en suis pas sûr...
def demander_N():
n = input("Donnez N: ")
n = int(n.strip().replace(" ", ""))
#n = int(30 * round(float(n)/30))
return n
Ça je te laisse faire ...si cela améliore...ou pas
avec l'exemple ci dessus tu dois pouvoir vérifier facilement
pour pi2 = 2*premiers il suffit simplement d'écrire p2 = 2*premier , ce que je viens de faire ...c'est ok
pour le c++ , il n'y avait qu'une ligne à modifier pour cribler le tableau de 1 jusqu'à la racine de n , en fin de programme .
et la limite du criblage est jusquà la racine carrée de : $n=9\times10^{18}$ , il prend au delà mais il indique une erreur :
warning : integer constant is too large for its type ...
et je pense qu'il ne crible pas correctement , alors que pour $n = 9*10^{18} +1$ aucun souci et en 68 secondes ... pour la fam 30k+1
ulonglong debut = 9000000000000000001;
ulonglong fin = 9000000000000000016;
résultat nombre $p' \leqslant\sqrt{9*10^{19}}+1 = 18054607 $ et un nombre de $p'\not\equiv{2n}[P] =1537856$ , soit un : $1537856$ , $p'+q =2n$
@
Dernière modification par LEG (01-11-2024 17:14:49)
Hors ligne
#406 01-11-2024 18:31:10
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
Re,
attention c'est bien toi qui m'a refait les programmes ...
Oh, mais quelqu'un est passé derrière :
- Les commentaires : # c'est plus propre comme ça, ne font pas avancer la compréhension du programme --> à supprimer !
- le _ de "for _ in range...) n'est pas (à tort) dans mes habitudes,
- L'emploi de yield, par contre, c'est bien vu, je n'y avais pas pensé. yield fige le calcul et, à chaque rappel, permet de reprendre le calcul
là où il s'était arrêté d'où le eachnumber : ainsi on n'utilise pas de place mémoire en construisant une liste complète, mais on construit
et utilise un nombre après l'autre, à la demande,
- J'ai peut-être refait le programme, mais je ne vois pas en train d'écrire que je multiplie un nombre par 1...
Ne pas confondre avec [1]*10 --> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Tout ce que tu m'expliques me sera utile un peu plus tard, là je n'ai fait que relever que :
- lencrible = ((n1//2)*1) ou lencrible = n1//2 c'était "kif kif bourricot"...
- lencrible = ((n1//2)+1) oui, ça a du sens...
Fixer en Python l'arrêt d'une une boucle à n, c'est en réalité s'arrêter à n-1, d'où le +1 si on veut vraiment aller jusqu'à n.
J'avais pensé hier à une faute de frappe, revoyant le *1 aujourd'hui, je me suis dit que ce n'était pas anodin, d'où mon interrogation...
Si on veut chipoter davantage, dans tous les cas il y a des parenthèses inutiles :
lencrible = ((n1//2)*1) n'importe quel logiciel de programmation respecte la bases du calcul algébrique : la priorité des opérations...
Et donc :
lencrible = n1//2+1 fait parfaitement l'affaire et c'est... "plus propre" ^_^
De même que :
int(n**0.5) à la place de int((n)**0.5) fait aussi parfaitement le job, même si n était décimal, parce que (n)**0.5 ou n**0.5 te donnera le même résultat...
Par contre int(n)**0.5 $\neq$ int(n**0.5) avec n décimal, par exemple avec n=3800.99 on obtiendrait :
int(n)**0.5 $\approx$ 61.644140029689765$ et int(n**0.5)=61
Et pour (n//2)*1, tu penserais donc que n//2 ne donnerait pas le même résultat ?
Je reprends n=3800.99 :
C'est bien le même résultat :
n//2 --> 19.0
(n//2)*1 --> 19.0
sauf que, pour Python, le résultat (dans les 2 cas) n'est pas entier mais décimal (parce que n est décimal) et si ce résultat devait servir à contrôler une boucle, on obtiendrait un beau message d'erreur :
>>> for i in range(19.0):
print (i)
Traceback (most recent call last):
File "<pyshell#50>", line 1, in <module>
for i in range(19.0):
TypeError: 'float' object cannot be interpreted as an integer
En résumé, dans ta multiplication par 1 sur cette ligne
lencrible = (n//2)*1
tu penses que ce 1 permet de remplir le tableau avec des 1 ?...
Non !
Preuve n° 1:
n=15
lencrible = (n//2)*1
crible=["Leg" for _ in range(lencrible)]
print (crible)
te renvoie :
['Leg', 'Leg', 'Leg', 'Leg', 'Leg', 'Leg', 'Leg']
Ils sont où les 1 ?
Preuve n°2 :
n=15
lencrible = (n//2)*3
crible=[1 for _ in range(lencrible)]
print (crible)
te renvoie
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Ils sont où les 3 ?
Alors ?
Convaincu que, au moins en Python, le 1 de : lencrible=(n1//2)*1 ne sert à rien ?
Les 1 dans le tableau nommé crible sont déterminés sur cette ligne :
crible=[1 for _ in range(lencrible)]
Tu as bien vu dans les 2 exemples ci-dessus que
- si je remplace ce 1 rouge par "Leg", le tableau crible contient lencrible fois "Leg",
- si je remplace le 1 du *1 par 3 (en laissant le 1 rouge en place), le tableau nommé crible contient lencrible fois 1, mais s'il y avait
7 fois "Leg", les 1, eux, sont au nombre de 7 * 3 = 21...
Ok ?
Tout ça pour dire qu'il est important dès le départ d'avoir un programme "propre", parce que, une fois ton œuvre achevée, il te faudra la présenter à des sommités qui risquent fort d'arrêter leur lecture devant les points soulevés et la classer en "pas crédible"...
Bon, j'imprime !
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#407 02-11-2024 08:16:04
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Bonjour:
je viens de lire tes réponse, affectivement ta preuve est sans discutions possibles
tu me demandes ou sont passé les 1 ou les 3
... et ben ils sont cachés....LoLL ... Au départ le programme était écrit comme ça.... et cette ligne n'a jamais été modifiée.
- J'ai peut-être refait le programme, mais je ne vois pas en train d'écrire que je multiplie un nombre par 1...
Ne pas confondre avec [1]*10 --> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
bien sûr , d'autant que c'est [1]*30 + la première valeur de $i\in(1,7,11,13,17,19,23,29)$ je modifie la fonction ; donc en progression arithmétique de raison $30$ et de premier terme $i$
Par contre pour le programme en C++
à la fin de cette fonction:
size_t GCrible(const vector<ulonglong> &premiers, ulonglong n, int fam, vector<bool> &crible, size_t lencrible)
{
.
.
ulonglong p = premiers[i];
size_t index;
for (index = indices[i]; index < slicelimit; index += p)
crible[index] = 0;
indices[i] = index;
}
}
size_t total = 0;
for (size_t index = 0; index < lencrible; ++index)
total += int(crible[index]); // le criblage du tableau de 1 modulo 30 jusqu'a n/30 (1.1.1.1...etc) est fini on va retourner le résultat
cout << " Nbr couple p+q criblés Fam " << fam << " : " << total;// " time " << (clock() - cl) * 1e-6 << endl;
return total;
1) : Où est que l'on place la ligne d'instruction , et comment l'écrire, pour imprimer le tableau criblé de Goldbach ; comme dans Python ? : ; [cout << ....?]
2) : comment on défini la taille de cette constante, pour un entier de La taille entre 10 ^18 et 10^23
Actuellement elle est définie comme ceci ,
typedef unsigned long long ulonglong
Donc je peux cribler et rentrer une valeur de début et fin, jusqu’à : 9*10^18 , au-delà j’ai un message d’erreur : constante trops large
est ce que je peux modifier cette constante en C++ , par exemple : typedef unsigned SIZE_MAX UINT_MAX ??
Dernière modification par LEG (02-11-2024 11:41:46)
Hors ligne
#408 02-11-2024 14:16:35
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
B'jour,
est ce que je peux modifier cette constante en C++ , par exemple : typedef unsigned SIZE_MAX UINT_MAX ??
C'est à moi que tu poses la question ? Tu ne doutes de rien ... C'est flatteur mais je ne sais que des choses basiques en C ou C++...
Je te conseille de t'orienter vers un forum dédié au C++, je regarderai pourtant via Google pour voir ce qu'il raconte à ce sujet...
Autre question, à laquelle je vais essayer de répondre :
Où est que l'on place la ligne d'instruction , et comment l'écrire, pour imprimer le tableau criblé de Goldbach ; comme dans Python ? : ; [cout << ....?]
D'une manière générale, supposons que dans une fonction, tu remplisses un tableau T, fonction qui à la fin te retourne le tableau rempli :
return T et dont tu veux afficher le contenu...
--> Où est que l'on place la ligne d'instruction ?
1. Tu peux placer l'affichage dans la fonction, une ligne avant le return T
2. Tu peux aussi repérer la ligne du programme depuis laquelle tu appelles la fonction en lui passant les paramètres
dont elle a besoin.
Il te faut alors repérer sous quel nom cette ligne ou sur une ligne ultérieure ce tableau est récupéré. Cela fait, tu peux placer l'affichage
après la récupération
--> Comment l'écrire, pour imprimer le tableau criblé de Goldbach ?
A priori, je ne sais pas. Si ton tableau criblé par ta fonction est le tableau appelé total, cette ligne devrait pourtant faire l'affaire :
cout << " Nbr couple p+q criblés Fam " << fam << " : " << total;// " time " << (clock() - cl) * 1e-6 << endl;
cout est bien l'ordre d'affichage, l'équivalent du print () de Python .
Cette ligne devrait pourtant afficher la valeur de la variable fam, puis le tableau nommé total, puis le temps écoulé...
C'est bien ce qu'elle fait ?
Si la réponse est oui, alors total est-il bien le nom du tableau criblé ? Si non, où est ce fameux tableau ?
Enfin, plusieurs choses me surprennent dans ta fonction :
- je dénombre 1 seul { mais 2 } ça ne me paraît pas logique (je sais grosso modo à quoi ça sert en C, donc j'en
déduis que ça ne change pas en C++)
- je ne vois pas un nom explicite pour la fonction ou alors, il se présente bizarrement...
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#409 02-11-2024 16:37:04
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
re
pour écrire le résultat du nombre de couples p+q , c'est bien la fonction ok
cout << " Nbr couple p+q criblés Fam " << fam << " : " << total;// " time " << (clock() - cl) * 1e-6 << endl;
çà retourne le totale du nombre de nombre p' de "A <n"
mais pour le tableau ...?,
je pensais que le nom du tableau criblé c'était (size_t lencrible) ou lencrible
mais à priori non
et peut être qu'il faut une fonction , qui retourne le tableau criblé comme: retourne crible ou lencrible...ou simplement la fonction : size_t crible = ???
car je peux imprimer les : size_t slicelimit =; cout << " tableau p' criblés Fam " << fam " : " << slicelimit;// " time " << (clock() - cl) * 1e-6 << endl;
ou size_t nbpremiers =
size_t index ..
donc il me faut le tableau criblé , avec la mention size_t crible =
bon : j'ai réussi à éditer le tableau de 1 avec cout << " ; " << GCcrible << endl;
mais pas le tableau criblé , on peut éditer les restes R , les nombres premiers p'...
donc je vais laisser , et pour ce tableau , mieux vaut utiliser python , qui est beaucoup plus clair , d'autant que c'est pour des limites < $\sqrt {3000000}$
Dernière modification par LEG (02-11-2024 17:33:33)
Hors ligne
#410 02-11-2024 17:52:58
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
Re,
Hmmm...
Le tableau que tu veux afficher devrait bien s'appeler crible apparemment...
Bon, si j'ai compris ce que j'ai lu, avant la ligne existante :
cout << Nbr couple... etc...
ajoute donc les lignes :
for ( int j=0; j < 20; j++ ) {
cout << crible[j] << endl;
}
Je me limite aux 20 premières valeurs.
Si ça fonctionne, même à peu près, selon ce qui s'affiche (ou les messages d'erreurs ^_^), on tâchera d'adapter...
@+
[EDIT]
Voilà l'affichage Python du dernier script en date :
Donnez N: 500
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31]
1
0
6
10
12
14
12
11
14
8
crible: [0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]
Nombres non congrus à 2n [pi] 1 à 500 famille 1 premiers de 500 à 1000: 73 ----- 0.04
--- Temps total: 0.05 sec ---date :
C'est ça que tu voudrais reproduire ?
- Dans ce cas, pour les nombres en vert, il serait bien de dire avant l'affichage, en quelques mots, ce qui va s'afficher.
- La ligne en rouge n'est absolument pas claire (sauf pour toi).
Je personnaliserais le "non congrus à 2n [pi]" en 2*500 [valeur de pi]"
Par "valeur de pi" j'entends remplacer aussi le pi par sa valeur.
- "Nombres congrus à ..."
Pas clair... Quels nombres ? On pourrait comprendre que tous ces 0 et ces 1 sont ces fameux "nombres non congrus à 1000 [pi]"
Faire les modifs en Python ne devrait pas poser de pb, mais en C++...
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#411 03-11-2024 06:17:00
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Re Yoshi
Tout à fait en python aucun souci, c'est bien le tableau que tu représentes en python et que j'ai ... toi tu as utilisé P = 3 et 5 , alors que moi je ne les utilise pas dans
l'algorithme Ératosthène modulo 30...
Nombres non congrus à $2n [P]$ avec $P\leqslant\sqrt{2n}$
les 0 et les 1 sont les entiers congrus ou pas à 2n modulo P.. mais le programme en python que j'ai posté au dessus post# 400, il fonctionne parfaitement bien et j'ai modifié la taille du tableau pour ne prendre en compte que le tableau des entiers premiers $p'$ criblés par ÉRATOSTHÈNE À LA FONCTION :
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int((n)**0.5)
# On génère un tableau de N/30 cases rempli de 1
lencrible = n1//30
Que l'on retourne pour la fonction de Goldbach , afin de ne cribler que les nombres premiers $p'$ non congruents à $2n$ modulo $P$ et inférieur à la racine carrée de $n$ , que j'ai donc modifié pour la circonstance..
n1 = int((n)**0.5)
# On génère un tableau de N/30 cases rempli de 1 < racine carrée de n
lencrible = n1//30
Et tu as raison en C++.. le programme que j'ai posté, il travaille sous dos , donc la petite fenêtre dos , n'est absolument pas pratique..., c'est pour cela que j'ai laissé tomber cette idée de sortir le tableau de 1 ou de 0 en fonction de leur congruence modulo P.
J'ai remplacé le crible en python du post # 400 par Ératosthène modulo 30 car c'est celui que j'utilise..., que je remet ici de façon à utiliser le même crible...si il y a des modification à apporter , et au moins on ne travaille que jusqu'à la racine carrée de $n$ , pour tester la conjecture pour tout $n > 3000000$ , par famille $i$
afin de vérifier le nombre de solutions pour tout 2n , tel que $2n =p'+q$ , c'est à dire , tout $p'\not\equiv{2n}[P]\leqslant\sqrt{n}$
from time import time
from os import system
def candidate_range(n):
cur = 5
incr = 2
while cur < n+1:
yield cur
cur += incr
incr ^= 6 # or incr = 6-incr, or however
def eratostene(n):
n = int((2*n)**0.5) ##(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
prime_E =[2]
sieve_list = [True for _ in range(n+1)] ## c'est plus propre comme ça
for each_number in candidate_range(n):
if sieve_list[each_number]:
prime_E.append(each_number)
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
#print(prime_E[2:])
return prime_E[2:]
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int((n)**0.5)
# On génère un tableau de N/30 cases rempli de 1 < racine carrée de n
lencrible = n1//30
crible=[1 for i in range(lencrible)] ## c'est plus propre comme ça
GM = [7,11,13,17,19,23,29,31]
# On calcule les produits :
for a in premiers:
for b in GM:
j = a * b
if j%30 == fam:
index = j // 30 ## Je calcule l'index et On crible directement à partir de l'index
for idx in range(index, lencrible, a): ## index qui est réutilisé ici...
crible[idx] = 0
total = sum(crible)
print("crible Ératosthène :", crible) ## pour éditer le tableau Ératosthène criblé
print(f"Nombre premiers criblés famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")
return crible,lencrible
def GCrible_2N(premiers, crible, lencrible, n, fam):
start_crible = time()
# On calcule les restes: r = 2*n/P
nbpremiers = len(premiers)
n2 = 2*n
for premier in premiers:
reste = n2 % premier
#print(reste)
if reste % 2 == 0:
reste += premier
p2 = 2*premier
## tant que reste % 30 != fam on fait reste += p2
while reste % 30 != fam:
reste += p2
## Ensuite on divise reste par 30 pour obtenir l'index
reste //= 30
## On crible directement à partir de l'index le tableau d'Ératosthène
for index in range(reste, lencrible, premier):
crible[index] = 0
total = sum(crible)
print("crible É ET G:", crible) ## éditer le tableau criblé É et G
print(f"Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2N, de (1) à sqrt de {n} famille {fam} : {total} ----- {int((time()-start_crible)*100)/100}")
def demander_N():
n = input("Donnez N: ")
n = int(n.strip().replace(" ", ""))
#n = int(30 * round(float(n)/30))
return n
def main():
## On demande N a l'utilisateur
n = demander_N()
## On récupère les premiers de 7 à √2N
premiers = eratostene(n)
start_time = time()
## On crible
fam=19 ## ou 1, 7, 11, 13, 17, 19, 23, 29, au choix en fonction de n
crible,lencrible=E_Crible(premiers, n, fam)
GCrible_2N(premiers, crible, lencrible, n, fam)
main()
system("pause")
la question qui serait intéressante : Existe t'il toujours un nombre premier inférieur à la racine carrée de $n$ fixé , par famille $30k+i$ qui vérifie donc la conjecture pour tout $n > 3000000$ ...? la réponse est oui ! existe t'il une démonstration rigoureuse ??? je n'en suis pas sûr... aux vus des tests effectués ...
@+
Dernière modification par LEG (03-11-2024 07:00:55)
Hors ligne
#412 03-11-2024 22:16:32
- yoshi
- Modo Ferox
- Inscription : 20-11-2005
- Messages : 17 147
Re : crible en python
Bonsoir,
1. As-tu fait l'essai demandé ?
2. J'ai récupéré ton script Python ci-dessus et ai commencé à remplacer les listes purement Python
pour les remplacer par des tableaux numpy (de num pour numérique et py pour Python) : j'ai passé
l'après-midi pour retoucher une... dizaine de lignes seulement.
Mais avec l'entraînement, ça devrait aller plus vite (je n'avais encore jamais touché à numpy jusqu'à
aujourd'hui).
3. Je pense qu'une fois modifié, on devrait avoir repoussé la limite maximum et gagner sensiblement
en vitesse :
Les sites que j'ai vus s'accordent à dire qu'utiliser les array (tableau) de numpy divise par 30 le
temps de traitement par rapport aux listes.
De plus, numpy possède des instructions qui permettent de se passer de certaines boucles...
@+
Arx Tarpeia Capitoli proxima...
Hors ligne
#413 Hier 07:40:27
- LEG
- Membre
- Inscription : 19-09-2012
- Messages : 710
Re : crible en python
Bonsoir,
1. As-tu fait l'essai demandé ?
@+
Bonjour,
pour :
for ( int j=0; j < 20; j++ ) {
cout << crible[j] << endl;
}
Non , je ne sais pas où la placer...(mais , je vais réessayer)... Ça ne crible pas du tout APPUYER SUR ENTRÉE
Et de toutes façons , on est bloqué par la valeur de la limite $n$ en C++, qui est bornée à $2^{64} - 1$ limite que j'ai déjà testée... , qui me donne le nombre de solutions $2n=p'+q$ en ne criblant que jusqu'à la $\sqrt{n}\; divisée\; par\; 30$ et par famille...on peut affirmer au minimum que la conjecture est vraie jusqu'à $n=1,5\times10^{19}$ quelque soit la famille $30k+i$ en fonction de la forme de $2n$ ; voilà pour le C++.
D'autant, que si tu imprimes le crible, sous dos , cela n'a rien à voir avec python qui est nettement plus facile et plus clair à voir .
Pour python , je viens de remplacer le fichier , par celui que tu viens de modifier ; résultat ci joins; comme tu peux le vérifier , la réponse est immédiate pour une limite criblée de $1 \;à\; n = 300000000$ .
Le fait de re-cribler le tableau des nombres premiers criblés [def Ératosthène...] Jusqu'à la racine carrée de n / 30 c'est très rapide et on utilise peut de mémoire , sans perte de généralité ; mais bien entendu pour une limite $n\geqslant{3000000}$ par Famille; où on peut dire que cette conjecture est vraie...
On peut constater de plus , que la répartition du nombre de solutions , qui vérifie la conjecture est oscillatoire par famille , par rapport à l'une des 15 formes de $2n$. C'est une conséquence de la propriété de l'algorithme de Goldbach modulo 30, qui utilise les congruences et donc du décalage d'un rang des congruences, lorsque l'on on augmente la limite n de 15, qui fonctionne selon le même principe d'Ératosthène ....
Mais qui est différent du crible des nombres premiers , car les indexes de départ des nombres $P$ qui criblent est différent...
Python 3.9.5 (default, Nov 23 2021, 15:27:38)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
>>>
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez N: 300000000
crible Ératosthène : [1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1]
Nombre premiers criblés famille 19 : 241 ----- 0.0
crible É ET G: [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1]
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2N, de (1) à sqrt de 300000000 famille 19 : 43 ----- 0.0
>>>
Un Grand Merci , cher ami ...
https://www.cjoint.com/c/NKefZoGq5vV
Dernière modification par LEG (Hier 16:43:44)
Hors ligne