Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#51 Re : Programmation » crible en python » 10-12-2024 08:41:55
Bonjour @DrStone
Ok , d'autant que pour un tableau de 600 000 000 nombres à cribler je ne pense , qu ça ne changerait grand chose... Je me suis amusé à modifier la valeur des slices , sans que cela change grand chose ...
C'était intéressant lorsque je criblai jusqu'à la limite n = 9 500 000 000 000 cela me permettait d'atteindre cette limite ... avec un peu de temps et beaucoup de mémoire utilisée...
En définitive seul le résultat compte, le fait de ne cribler qu'une partie des nombres premiers $p'$ inférieur à la limite $\sqrt{2^{64}}$ permet de se faire une très bonne idée sur la répartition par famille , du nombre de couples $p' + q = 2n$ afin de calculer ou de vérifier , des fonctions qui donnent un minimum de solutions...
Même en utilisant le programme Python tel quel , cité en référence ; mais avec un peu plus de temps ...
On peut d'ailleurs vérifier avec cette méthode par Famille , que si la conjecture avait été fausse , elle le serait à partir d'une petite limite $n$ et non lorsque $n$ tend vers l'infini...!
@+
#52 Re : Programmation » crible en python » 09-12-2024 07:20:57
Bonjour
@DrStone
Si cela peut faciliter le programme , je viens de voir qu'il n'est pas utile d'utiliser [ les Slices]
car en effet:
Étant donné que j'utilise comme limite $n$ :
On n'est donc pas obligé de slicer...non ?
Car la taille maximum du tableau à cribler ne ferait que $\sqrt\frac{9\times{10^{18}}}{30}$ = $547722557$
@+
#53 Re : Programmation » crible en python » 26-11-2024 18:23:58
Re Yoshi
, Je sais que tu ne m'oublies pas... C'est simplement une histoire de temps..
Donc moi ça me va , mais dommage que personne ne puisse t'aider concrètement avec Numpy... heureusement , tu es autant acharné que moi pour trouver la solution... Donc je ne me fais aucun souci , tu en viendras à bout.
Pour en revenir à cette instruction :
dans le tableau, si la condition est vérifiée alors tu remplaces True par False ... et on peut même ajouter : sinon tu remplaces par "autre chose" (ou laisse tel quel)...
Il me semblait que tu n'avais plus besoin d'utiliser True et False...
dans les deux autres parties de l'algorithme ECrible et GCrible ... car on utilise simplement le principe d'ÉRATOSTHÈNE EN PARTANT DE L'INDEX...
Donc je suppose que c'est toujours pour la première partie avec la fonction def candidats (n) que tu veux modifier...
Est ce que dans ce cas il ne faudrait pas revenir, à retourner deux liste de premiers , comme tu l'avais fait :
1) les premiers $P\leqslant\sqrt{n}$ pour la fonction def E_Crible(premiers, n, fam): si on gagne du temps dans cette fonction ,(ce qui n'est pas sûr...)
2) les premiers $P\leqslant\sqrt{2n}$ pour la fonction def GCrible_2n(premiers, crible, lencrible, n, fam):
Une fois modifiée cette première partie def candidats (n). Tu penses que cela va modifier considérablement le temps mis pour cette fonction ...?
Il est vrai que pour une grande valeur de n , cela prend pas mal de temps , pour cribler cette partie inférieur à racine carrée de n pour ECrible ou racine carrée de 2n pour la fonction GCrible .
Ce que tu avais déjà fait en retournant deux listes : les premiers inférieur à racine de n utiliser par ("ECrible) et les premiers inférieur à racine de 2n. utilisés par ("GCrible)..
Ce que je ne comprends "pas" : comment cette fonction def candidats (n) crible les nombres impairs < à racine de 2n (c'est un crible d'Ératosthène , classique)
Donc : j'ai fait un test en modifiant la partie (def candidats(n)) avec ce que tu avais fait en 2018 cette partie :
def candidats(n):
start_crible = time()
n = int((2*n)**0.5)
m = (n-1) // 2
limite=1+n
b = [True]*m
premiers = [2]
for i,p in enumerate(range(3,limite,2)):
if b[i]:
premiers.append(p)
j = 2*i*i + 6*i + 3
debut,pas=j,2*i+3
for j in range(debut,m,pas):
b[j] = False
debut=i
for i in range(debut,m):
if b[i]:
premiers.append(p)
p += 2
#print(premiers[3:])
print(f"Nombre premiers[3:] : {int((time()-start_crible)*100)/100}")
return premiers[3:]
Résultat on gagne 100 s (on passe de 230 S à 149 S pour la limite n=10¹⁸ +20
========= RESTART: /home/gilbert/Programmes/Python/Crible_EG2_mod30.py =========
Donnez n: 1000000000000000020
Nombre premiers[3:] : 149.12
Nombre premiers criblés famille 7 : 6356475 ----- 72.94
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 1000000000000000020 famille 7 : 646600 ----- 74.98
>>>
Mais avec cette modification de [def Candidats(n)] dans le programme il n'y a pas photo..
def candidats(n):
#n = int(input("Entrez le nombre n "))
begin = perf_counter()
n1 = 2*n
length = int((n1)**0.5) // 3
if n%3 == 0 or n%3 == 1 and n%6 != 1: length -= 1
flags = [True] * length
number = 1
addition = 4
toggle = 6
for indexe in range(length):
number += addition
addition = toggle - addition
if not flags[indexe]: continue
start = (number * number *2 - 5) // 6
if start >= length: break
step = 2 * number
flags[start::step] = [False] * ((length - start + step - 1) // step)
advance = (indexe + 2) // 2
start += number - 2*advance + (indexe%2)*4*advance
flags[start::step] = [False] * ((length - start + step - 1) // step)
print(round(perf_counter()-begin, 3), "secondes")
print(f"{sum(flags)+2} nombres premiers dans l'intervalle [1, sqrt{2*n}")
premiers = [2, 3] + [i//2*6+5+i%2*2 for i in range(length) if flags[i]]
#print(premiers[3:])
return premiers[3:]
résultat :
============= RESTART: /home/gilbert/Programmes/Crible_EG2_mod30.py ============
Donnez n: 1000000000000000020
17.332 secondes
70659843 nombres premiers dans l'intervalle [1, sqrt2000000000000000040
Nombre premiers p' criblés de 1 à sqrt de n famille 7 : 6356475 ----- 57.13
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 1000000000000000020 famille 7 : 646600 ----- 58.58
--------
Donnez n: 10000000000000000020
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 10000000000000000020 famille 7 : 1618201 ----- 190.78
on avait bien des nombres premiers parasites , mais surtout la def candidats(n) avait une grosse erreur comme tu l'as souligné.
Tout à fait d'accord avec ta citation favorite ... en plus c'est valable de partout...
programme C++ et python légèrement modifié , pour ne cribler que les nombres premiers p' < (sqrt (sqrt N)) / 30
https://www.dropbox.com/scl/fi/rmxz9bod … u797o&dl=0
https://www.dropbox.com/scl/fi/vrvgkov1 … dd27e&dl=0
@+
#54 Re : Programmation » crible en python » 26-11-2024 09:00:16
Bonjour :
@DrStone
1)
Cette fonction , à donc pour but , d'extraire tous les nombres premiers $P\leqslant\sqrt{2n}$ par rapport à la limite début n = fixée , que l'on va utiliser , pour ECrible et GCrible , "que l'on ne peut pas scinder" , il s'agit d'un petit crible d'Ératosthène.
2)
for (ulonglong limite = debut; limite < fin; limite += 15){
cout << "--> limite : " << limite << endl;
double sqrt2N = unsigned(std::sqrt(2 * double(limite)));
fill_crible(temp, sqrt2N); // [b]on rappelle les nombres premiers P < sqrt 2n , qui ont été extraits en début de programme[/b]
vector<ulonglong> premiers;
for (ulonglong p = 7; p <= sqrt2N;)
{
premiers.push_back(p);
p = nextprime(temp, p);
if (p == unsigned(-1))
break;
La totalité de cette fonction, a pour but d'utiliser les nombres premiers $P\leqslant\sqrt{2n}$ en indiquant le début et la fin de la limite n criblée ,
je suppose donc, que fill crible et de prendre tous ces nombres premiers P pour cribler la famille en question , du début à la fin de la limite n fixée , "avec le temps mis..."
Une fois la limite criblée finie : on augmente la valeur n = début , de 15 et on réitère avec ces même nombre premiers P , on crible la limite n+15 , suivante ...
Une fois que l'on a fini de cribler une "famille push_back" fixée, jusqu'à la limite (n modulo 15) fixée , ,
On réitère éventuellement avec une deuxième famille push_back ,fixée : idem du début à la fin de ""cette ou de ces limites n fixées""" avec:
toujours ces mêmes nombres premiers $P\leqslant\sqrt{2n}$ , qui ont été criblés , en début de programme par la fonction fill_crible :
Attention de ne pas confondre cette limite : début n = qui fixe la limite n des nombres premiers $P\leqslant\sqrt{2n}$ à extraire en début de programme ;
Avec la limite
qui elle, fixe la limite ou la taille du tableau à cribler par ces deux fonctions :
size_t ECrible et GCrible : et bien entendu, en utilisant tous les nombres premiers P de la fonction fill_crible...
soit on crible jusqu'à la limite n/30 , soit on crible uniquement , jusqu'à la racine carrée de n, puis divisée par 30.. pour les grandes valeurs de début n , fixé
En définitive, fill_crible : (c'est la même fonction utilisée par le programme python en question, référencé ci dessus , dans def eratosthene) que @yoshi vient de modifier ...en s'emm....à comprendre l'erreur qu'il y avait...
Programme python , que tu peux utiliser pour vérifier que les résultats sont identiques au C++.. en rentrant la même valeur n et la même famille : Fam i, et que la fonction Fill crible extrait bien les nombres premiers $P\leqslant\sqrt{2n}$ , dont on doit se servir pour les deux fonctions ECrible et GCrible ...
#55 Re : Programmation » crible en python » 21-11-2024 14:00:42
Re :
La première apparition de "candidate_range" remonte au post #293, elle coïncide avec la même forme d'une def eratostene corrigeant les âneries de candidate_range....
Je viens de regarder la date , c'est bien lorsque j'étais au Québec, donc mon petit fils avait chargé ce programme, sur internet, pour extraire les premiers dans cette première partie , mais je sais qu'il n' a pas regarder en profondeur... il a simplement dû regarder la partie finale , qu'il y avait bien les nombre premiers P inférieur à racine de n, qui étaient extrait , sans plus... d'ailleurs mon commentaire (voici la dernière mouture...etc) en dit long...
à cette époque on ne s'intéressait uniquement à la partie GCrible : Goldbach et en rentrant du Québec j'ai posté cette partie En C++ faite Par Mr B Parisse ...
Donc ensuite on ne sait pas occupé de cette partie (def eratosthene[n])... du moment que le crible fonctionnait et qu'au final on avait bien les nombres premiers P pour la fonction suivante GCrible... et criblait bien les entiers A de 1 à n , qui étaient non congrus à 2n modulo P... Mais : Probablement aussi pour cela , que j'étais limité en python...
Tout comme hier , il était impossible de dépasser 10¹⁷ ... avec cette version et cette def eratosthene, que je viens de modifier dans les autres programmes python...
je viens de faire l'essais aujourd'hui avec la limite maximum possible : n = 1.75 * 10¹⁹ et ça passe soit , 2⁶⁴...
Avant :
========= RESTART: /home/gilbert/Programmes/Python/Crible_EG2_mod30.py =========
Donnez n: 17499999999999999990
Nombre premiers[3:] : 24846.0
Nombre premiers criblés famille 7 : 24780403 ----- 366.02
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 17499999999999999990 famille 7 : 1952935 ----- 318.06
>>>
Après changement de la def Candidat : pour la limite $n=(2.10^{19})+2$
Donnez n: 20000000000000000002
3688.793 secondes
293944258-4 nombres premiers dans l'intervalle [1, sqrt40000000000000000004]
Nombre premiers p' < sqrt n criblés, famille 30k+7 : 26407786 ----- 326.3
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+ q = 2n, de (1) à sqrt de 20000000000000000002 famille 7 : 2287931 ----- 309.04
Je te dois le restau....! ou du chocolat ...
programme C++ et python légèrement modifié , pour ne cribler que les nombres premiers p' < (sqrt (sqrt N)) / 30
https://www.dropbox.com/scl/fi/rmxz9bod … u797o&dl=0
https://www.dropbox.com/scl/fi/vrvgkov1 … dd27e&dl=0
Dans l'attente : Merci mon ami
@+
#56 Re : Programmation » crible en python » 21-11-2024 09:40:25
Je viens de lancer à tout hasard 10¹⁸ + 20 et voici le résultat ( parfait , donc il y avait bien un bug avec la version précédente où il m'était impossible de cribler cette valeur n...)
1)
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 1000000000000000020
Nombre premiers[3:] : 230.07
Nombre premiers criblés famille 7 : 6356475 ----- 74.65
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 1000000000000000020 famille 7 : 646600 ----- 75.59
Pour info : avec le programme C++ il met 11 secondes pour cette même valeur inférieur à racine de n pour le même résultat ...
2)
Voila la limite $n = 9\times10^{18}$ supérieur à la limite actuelle , qui était de 4*10¹⁸
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 9000000000000000000
Nombre premiers[3:] : 3970.0
Nombre premiers criblés famille 7 : 18056145 ----- 226.37
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 9000000000000000000 famille 7 : 1433577 ----- 229.86
nouveau programme C++ , modifié et aussi Python
https://www.dropbox.com/scl/fi/rmxz9bod … u797o&dl=0
https://www.dropbox.com/scl/fi/vrvgkov1 … dd27e&dl=0
---------------------------------
Donc : je met la nouvelle version complète, avec la première fonction def candidats(n) modifiée en ayant remplacé la première partie de python en référence
Résultat pour la même valeur n que le test ci-dessus , on gagne plus d'une heure sur la première fonction def candidats:
============= RESTART: /home/gilbert/Programmes/Crible_EG2_mod30.py ============
Donnez n: 9000000000000000000
62.565 secondes
200920348 nombres premiers dans l'intervalle [1, sqrt18000000000000000000
Nombre premiers p' criblés de 1 à sqrt de n famille 7 : 18056145 ----- 179.49
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 9000000000000000000 famille 7 : 1433577 ----- 179.86
from time import time
from time import perf_counter
from os import system
import math
def candidats(n):
#n = int(input("Entrez le nombre n "))
begin = perf_counter()
n1 = 2*n
length = int((n1)**0.5) // 3
if n%3 == 0 or n%3 == 1 and n%6 != 1: length -= 1
flags = [True] * length
number = 1
addition = 4
toggle = 6
for indexe in range(length):
number += addition
addition = toggle - addition
if not flags[indexe]: continue
start = (number * number *2 - 5) // 6
if start >= length: break
step = 2 * number
flags[start::step] = [False] * ((length - start + step - 1) // step)
advance = (indexe + 2) // 2
start += number - 2*advance + (indexe%2)*4*advance
flags[start::step] = [False] * ((length - start + step - 1) // step)
print(round(perf_counter()-begin, 3), "secondes")
print(f"{sum(flags)+2} nombres premiers dans l'intervalle [1, sqrt{2*n}")
premiers = [2, 3] + [i//2*6+5+i%2*2 for i in range(length) if flags[i]]
#print(premiers[3:])
return premiers[3:]
def E_Crible(premiers, n, fam):
start_crible = time()
nbpremiers = len(premiers)
n1 = int(n**0.5) ## ou #n1 pour ne pas limiter à la racine carrée de n
## pour générer un tableau de n/30 cases rempli de 1 ou n1 = racine carrée de n, puis n1/30
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(nbpremiers)
#print("crible Ératosthène :", crible) ## pour éditer le tableau Ératosthène criblé
print(f"Nombre premiers p' criblés de 1 à sqrt de n 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
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 = candidats(n)
start_time = time()
## On crible
fam=7 ## 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")
#57 Re : Programmation » crible en python » 21-11-2024 08:37:40
Re @Yoshi:
c'est pratiquement la version python que j'avais au début qui était programmée de la sorte :
def eratostene(n):
n = int(n**0.5)
m = (n-1) // 2
limite=1+n
b = [True]*m
premiers = [2]
for i,p in enumerate(range(3,limite,2)):
if b[i]:
premiers.append(p)
j = 2*i*i + 6*i + 3
debut,pas=j,2*i+3
for j in range(debut,m,pas):
b[j] = False
debut=i
for i in range(debut,m):
if b[i]:
premiers.append(p)
p += 2
print(premiers[3:])
return premiers[3:]
Qui est un peu plus lente que la version def eratosthène actuelle , pour une limite n=6*10¹⁷
Je vais donc faire ta modification et j'affiche le résultat , que l'on pourra comparer avec les deux résultats déjà affichés ...
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 60000
crible Ératosthène : [1, 1, 1, 1, 1, 1, 0, 0]
Nombre premiers criblés famille 7 : 6 ----- 0.0
crible É ET G: [1, 1, 0, 0, 0, 0, 0, 0]
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 60000 famille 7 : 2 ----- 0.0
1) Ça fonctionne parfaitement , [1=7] et [1=37] , comme tu peux le vérifier , 7 et 37 représente bien avec leur complémentaire par rapport à 2n = 120 000
deux couples de premiers qui vérifient la conjecture...
je vais indiquer le temps pour cette fonction (def eratosthène(n) afin de vérifier la perte ou le gain de temps...
2ème) teste n= 120 000 000 000 000
====================== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py =====================
Donnez n: 120000000000000
Nombre premiers[3:] : 2.1
Nombre premiers criblés famille 7 : 90531 ----- 0.68
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 120000000000000 famille 7 : 9459 ----- 0.71
>>>
temps mis par la def eratosthene : 2,1 secondes
3ème) teste : "" il est plus rapide "" Tu peux le vérifier au post ## 470 page précédente 19 on gagne 20 secondes par rapport à la version actuelle ... et 40 secondes avec l'autre version , que l'on peut abandonner...
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 600000000000000000
Nombre premiers[3:] : 112.8
Nombre premiers criblés famille 7 : 4988801 ----- 55.44
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 600000000000000000 famille 7 : 422407 ----- 56.33
#58 Re : Programmation » crible en python » 20-11-2024 15:20:15
Re
Quel intérêt a-t-on de savoir où sont les premiers entre 1 et n ?
Absolument aucun ...du moment que l'on a la liste des nombres premiers $P\leqslant\sqrt{2n}$ .
Sauf ..., si cette fonction permet justement d'éliminer les multiples de $P$
#59 Re : Programmation » crible en python » 20-11-2024 13:01:18
Pour finir : non, non, l'écriture de cette fonction sous cette forme n'est pas de moi :100 % de certitude...
ok .. Donc c'est le programme python que mon petit fils avait charger , pour extraire les nombres premiers $P\leqslant\sqrt{2n}$ dont on a besoins pour les deux fonctions suivantes de l'algorithme ...def Ecrible et def GCrible
Ton procédé de mise en évidence de l'exactitude de la conjecture de Goldbach ne porte que sur les nombres premiers et uniquement eux, s'pas ?
Tout à fait
Et pourtant (rassurant), voilà la liste E :
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139]
Pas d'erreurs...
Exactement
D'où ma 2e question (sûrement naïve) pourquoi traîner cette liste sieve_list, puisque disposant d'une liste de nombres premiers ?
j'en ai : Absolument aucune idée ...
Je suppose que je peux supprimer if sieve_list[each_number]: et voir ce que cela donne....
Ce que je viens de faire ... désastre : il y a les multiple de P qui apparaissent donc on ne peut pas la supprimer ou faire autrement !
Donc je ne sais pas ce qu'il faut enlever, pour ne pas traîner cette liste sieve_list ??? Sans altérer cette partie de programme...
Mais pourquoi ; return prime_E[2:], sieve_list ...à quoi cela sert de retourner sieve_list , puisque cela fonctionne sans ça ?
@+
#60 Re : Programmation » crible en python » 20-11-2024 08:13:52
Re :
Effectivement cette instruction ne sert à rien
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
Mais à l'origine lorsque tu essayais de modifier le programme , pour gagner du temps , il "" me semble "" que c'est toi qui avait modifié la première partie du programme , ou à moins que tu es repris le programme python d'origine de mon petit fils... en 2019 ...
car effectivement il suffit simplement d'utiliser cette partie ci dessous , mais cela n'explique pas pourquoi ton programme fait apparaître la ligne verticale avec des multiple de 5 etc etc .?
Car même en supprimant ces deux lignes de programme , ces multiples apparaissent toujours ligne verticale du résultat ... Or il faut justement les supprimer , ce que fait ensuite la fonction :
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
-----------------------------------------------------------------------------------------------
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):
start_crible = time()
n = int((2*n)**0.5)
prime_list = [2, 3]
sieve_list = [True] * (n+1)
for each_number in candidate_range(n):
if sieve_list[each_number]:
prime_list.append(each_number)
# #for multiple in range(each_number*each_number, n+1, each_number):
# #sieve_list[multiple] = False
print(prime_list[3:])
print(f"Nombre premiers prime_list[3:] : {int((time()-start_crible)*100)/100}")
return prime_list[3:]
qui a le même résultat que ton post ci-dessus , en ne regardant le résultat de la ligne du bas horizontal du bas :
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)] # (que des True (n+1 fois)
for each_number in candidate_range(n):
print (each_number)
if sieve_list[each_number]:
print("-",each_number)
prime_E.append(each_number)
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
return prime_E[2:]
on ne peut pas supprimer cette fonction, qui supprime les multiples de 5 et autres, ce que je viens de tester
# for multiple in range(each_number*each_number, n+1, each_number):
#sieve_list[multiple] = False
je vais donc tester avec ta partie de programme , jusqu'à 6*10¹⁷ et voir le résultat... que je t'afficherai...
teste effectué :, il met 3 fois plus de temps , si on supprime la fonction :
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
voila le résultat du teste avec la fonction actuelle :
Donnez n: 600000000000000000
Nombre premiers prime_list[3:] : 199.25
Nombre premiers criblés famille 7 : 4988801 ----- 55.75
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 600000000000000000 famille 7 : 422407 ----- 55.96
>>>
voici le résultat avec ta fonction def eratosthène n , ci-dessus, il met 20 seconde de plus
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 600000000000000000
Nombre premiers prime_E[2:] : 220.81
Nombre premiers criblés famille 7 : 4988801 ----- 55.28
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 600000000000000000 famille 7 : 422407 ----- 56.33
>>>
conclusion , il s'agit bien d'un petit crible d'Ératosthène : on utilise bien et uniquement dans les deux cas, les nombres premiers $P\leqslant\sqrt{2n}$ , pour cribler ensuite, par fam modulo 30, aussi bien pour :
def E_Crible(premiers, n, fam):
ainsi que pour:
def GCrible_2n(premiers, crible, lencrible, n, fam):
Jusqu'à la racine carrée des deux tableaux criblés...
Pour te donner une idée, en criblant les nombres $p'$ de la def Ératosthène inférieur à racine de $n=300 000$ puis ensuite,
tableau qui est re-criblé par la def GCrible 2n
voici le résultat :
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 300000
Nombre premiers prime_list[3:] : 0.0
crible Ératosthène : [1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0]
Nombre premiers criblés famille 7 : 13 ----- 0.0
crible É ET G: [1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0]
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 300000 famille 7 : 7 ----- 0.0
Où tu peux vérifier que les premiers $p'\not\equiv{2n}[P]$ repésenté par [1] modulo 30, vérifient bien la conjecture de Goldbach . avec les p' = 7, 67, 157, 307 , 337, 397, et 487. ; qui ont pour complémentaire les nombres premiers $q$ appartenant à la famille 23 modulo 30
Contrairement à ce qui est dit...les nombres premiers $q$ dépendent bien de la congruence des nombres premiers $p'$ de 1 à n et on ne peut dire, qu'ils sont indépendants ...!
Tout comme il est impossible de supposer que pour n +15 = 300015 , ou encore 300030 etc .. la conjecture pourrait être fausse avec cette famille 30k+7.
car il suffit simplement de déplacer le vecteur du cible É ET G, d'un rang sur le vecteur du crible Ératosthène , pour voir jusqu'où elle est vérifiée...etc
Donc imagine avec un vecteur É ET G vérifié, jusqu'à la limite n=6*10¹⁷ ...Tu as une conjecture vraie sur plusieurs millier d'entiers pairs 2n consécutifs etc etc.
Tu va donc repousser la limite n du double à chaque vérification ... Jusqu'à ce que tu arrives à une grande limite, où la conjecture est vraie ... (^.i.^)
Actuellement il est efficace jusqu'à racine carrée de n=6*10¹⁷ , ce qui est pas mal du tout pour ton programme python que tu avais modifié et unifié, tu vas pouvoir vérifier ce que cela donne en numpy...
@+
#61 Re : Programmation » crible en python » 19-11-2024 19:07:44
Re tu en es sûr
Car je viens de regarder : avec la def candidate_range , il n'y a pas d'erreur , qu'il y a dans le programme en référence...
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):
start_crible = time()
n = int((2*n)**0.5)
prime_list = [2, 3]
sieve_list = [True] * (n+1)
for each_number in candidate_range(n):
if sieve_list[each_number]:
prime_list.append(each_number)
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
#print(prime_list[3:])
pour n = 300000
[7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773]
Nombre premiers prime_list[3:] : 0.0
Il n'y a bien que les nombres premiers > 5...
Il suffit même d'éditer le total des nombres premiers ,afin de voir qu'il correspond bien ...à la réalité , (inférieur à racine carrée de 2n.= 774)
sinon il ne patine que pour la limite n = 6*10¹⁸ mais pas en dessous
#62 Re : Programmation » crible en python » 19-11-2024 10:58:43
RE
C'est vrai que tel qu'il est le programme python , jusqu'à la racine carrée de 6* 10¹⁷ , ça va relativement vite ... Mais par contre 6*10¹⁸ ...là il galère un peu
pour la première partie def eratosthene je n'ai pas pu aller jusqu'au bout ...8 heures après il moulinait encore...
Alors qu'il y a 98 222 287 nombre premiers P à extraire ...Au lieu de 39 905 625...
il est vrai que l'on passe du simple au double ..
Mais en C++ actuellement il ne met que quelques secondes pour les extraire et exécuter les deux autres parties du programme...
....Patience et longueur de temps font plus que force ni que rage ....
@+
#63 Re : Programmation » crible en python » 18-11-2024 12:06:00
Oui effectivement , .. donc je te laisse , car moi je ne peux en aucun cas , émettre une idée..
@+
#64 Re : Programmation » crible en python » 18-11-2024 09:43:08
Bonjour @Yoshi :
Là ou le programme python cité en référence , perd le plus de temps , c'est bien dans la première partie, def eratosthene(n):
Je pense qu'il n'y a rien à y faire car c'est logique , si ce n'est que ta modification en numpy
Pour info : voila le résultat et le temps mis pour n = 6*10¹⁶
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 60000000000000000
Nombre premiers prime_list : 57.2
Nombre premiers criblés famille 19 : 1676915 ----- 17.38
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 60000000000000000 famille 19 : 150259 ----- 16.8
------------------------------------------------------------- n = 6*10^¹⁷
===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====
Donnez n: 600000000000000000
Nombre premiers prime_list : 201.22
Nombre premiers criblés famille 19 : 4987802 ----- 55.9
Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2n, de (1) à sqrt de 600000000000000000 famille 19 : 420564 ----- 56.95
@+
#65 Re : Programmation » crible en python » 15-11-2024 08:35:58
Bonjour @Yoshi
Le souci,pour ce morceau :
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)
prime_list = [2, 3]
sieve_list = [True] * (n+1)
for each_number in candidate_range(n):
if sieve_list[each_number]:
prime_list.append(each_number)
for multiple in range(each_number*each_number, n+1, each_number):
sieve_list[multiple] = False
#print(prime_list[3:])
return prime_list[3:]
C'est toi qui l'a introduit lors des modification , C'était plus rapide que les deux autres ci-dessous ; car si tu regardes , à la base je ne pense pas qu'il était écrit comme ça... dans le crible d'Ératosthène , pour cribler et extraire uniquement les nombres premiers de 7 à racine carrée de 2n , par rapport à la limite n fixée . Nombres premiers, qui ensuite vont servir pour le crible d'ÉRATOSTHÈNE MODULO 30 avec cette fonction :
def E_Crible(premiers, n, fam):
start_crible = time()
n1 = int(n**0.5)
Puis ensuite, que pour le crible de Goldbach modulo 30 avec cette fonction :
def GCrible_2n(premiers, crible, lencrible, n, fam):
start_crible = time()
# On calcule les restes: r = 2*n/P
nbpremiers = len(premiers)
c'est un petit crible d'Ératosthène dont on a besoin...afin d'extraire les nbr premiers qui vont être utilisés...
Voilà ci dessous comment cette première partie était écrit en 2018 : Tu dois avoir au début page 1 ta modification...
V. 6.1 ## du 16.06.2018
def eratostene(n):
n = int((2*n)**0.5)
m = (n-1) // 2
limite=1+n
b = [True]*m
premiers = [2]
for i,p in enumerate(range(3,limite,2)):
if b[i]:
premiers.append(p)
j = 2*i*i + 6*i + 3
debut,pas=j,2*i+3
for j in range(debut,m,pas):
b[j] = False
debut=i
for i in range(debut,m):
if b[i]:
premiers.append(p)
p += 2
return premiers[3:]
cette première version date de mars 2018 il n'y a pas la limite =1+n : à été supprimée...
import os
import math
import time
def eratostene(n):
n = int((2*n)**0.5)
m = (n-1) // 2
b = [True]*m
i = 0
p = 3
premiers = [2]
while p*p < n:
if b[i]:
premiers.append(p)
j = 2*i*i + 6*i + 3
while j < m:
b[j] = False
j = j + 2*i + 3
i += 1
p += 2
while i < m:
if b[i]:
premiers.append(p)
i += 1
p += 2
return premiers[3:]
Donc je suppose que tu sais pourquoi ... mais il s'est passé du temps...
quelque soit l'une de ces trois fonctions, pour la première partie du crible Ératosthène , elle fonctionne... je viens de les tester avec le programme en référence ci dessus ...
je viens de regarder le début ,de nos échanges qui ont été modifiés mais voici le post# 19 et 23
Post # 19 : je t’avais répondu :
La fonction Eratosthène doit extraire les nombres premiers Pi⩽√2n donc Pi⩽√2000=44
c'est tout ce qu'elle doit faire, pour utiliser ces Pi⩽44 dans la fonction du crible _G...ci dessous
post #23 une autre réponse suite à ta modification sur la première partie Ératosthène,,,:
j'ai copié ceci à la place de la mienne jusqu'à return premier :
def eratosthene(n):
nombres, premiers = [],[]
# n=int((2*n)**0.5)
for i in range(2,n+1):
nombres.append(True)
for i in range(2,n+1):
if nombres[i-2]:
premiers.append(i)
for j in range(2*i,n+1,i):
nombres[j-2] = False
return premiers
celle modification, par contre je ne l'ai pas testée , sur notre programme actuel en référence...
En espérant que cela t'aide à y voir plus clair... Dommage que Jeanne d'arc , n'est pas fait le ménage car les programmes serait en langue Française... ("loll")
#66 Re : Programmation » crible en python » 12-11-2024 09:21:49
Bonjour @Yoshi
^..^ ,En général , on dit seulement Senseï , on ne cite pas le nom... Du moins , c'est comme cela que je l'ai appris pendant des années , même dans le Bushido ^.^
Pour ce qui est de ton test, sur la rapidité d'exécution entre Python pur : 0,5 s et Python numpy : 25 s !!!
Ben, c'est comme pour le programme C++ , dont je t'ai mis les résultat en temps, entre les deux limite n = 9*10¹⁸ et 2⁶⁴ , pour cette deuxième valeur , le programme indique une valeur trop grande pour être signée ... Mais il met 1,02 seconde pour cribler les trois familles ...???
Alors que pour la première valeur il met 124 secondes ???
La seul chose que je sais , en essayant de changer la valeur du slice : de 1 500 000 , en l'augmentant , 3 000 000 , puis 4 500 000 , et 6 000 000 , il va de plus en plus vite.. pour cribler jusqu'à la racine carrée de $n$ ... car je suppose qu'il n'a pas besoin de créer autant de tableaux de slices ...
Ce qui n'est pas le cas pour cribler jusqu'à la valeur n = 9000 000 000 000, si on ne descend pas la valeur du slice , il bug ... résultat : appuyer sur entrée pour continuer et Nada ^..^
Ce que je ferai des que possible, j'éditerai le résultat du tableau criblé pour n = 2⁶⁴ et je vérifierai les premiers $p'\not\equiv{2n}[P]$ représenté par 1, ou encore, plus simple si cela est possible , le résultat des deux programmes pour cette valeur $n$ , criblée jusqu'à racine de $n$, ce que j'ai déjà essayé jusqu'à 10¹⁷
à nouveau avec c++ et n = 10¹⁹ +24 temps 0,332 s , Fam 7 , nbr p' criblés < sqrt de 10 000 000 000 000 000 024 = 90 350 791 ;
nbr couples (p'+q) = 75 292 326 , j'ai paramétré le programme c++ en conséquence , tu pourras comme ça, faire une comparaison de teste avec cette valeur n et la fam 7 une fois ta modification faîte...
j'ai lancé python , pour la même valeur , cela fait trois plus de 2 heure qu'il mouline, je verrai le résultat..
je l'ai stoppé hier soir, car il moulinait toujours .
@+
#67 Re : Programmation » crible en python » 11-11-2024 18:29:46
Il n' a aucune raison de te bannir , et il ne le fera pas , mais je pense que tu n'as vraiment pas besoins de ça , pour passer eeeeeenfin à autre chose ... Tu oublies que tu as le programme en C++ à refaire ... non ? La programmation je te la laisse... si cela avait été ma tasse de thé depuis des années ... peut être , que je n'aurai pas payé pour faire modifier ce programme ... Je ne suis pas: Sensei (先生) Yoshi...
#68 Re : Programmation » crible en python » 11-11-2024 16:52:05
LEG a écrit :toi qui je cite dans une de tes interventions :
les gens sans informatique et mathématique il en serait encore entrain de cultiver , faire de l'élevage .!
.. mon pauvre crétin , c'est pourtant grâce à eux si tu peux te nourrir , te loger , etc etc , car le travail manuel pour toi , tu es bien trop fainéant , pour t'y résoudre
On entre dans la diffamation.
Non , ce n'est pas de la diffamation, contrairement à toi qui traites les gens de paresseux sans rien connaître de leur vie
je reprend donc ta phrase au complet
Le commun des mortels ne semblent pas se rendre compte que leurs vies gravitent entièrement autour des mathématiques et que sans elles, ils seraient encore, pour 90% d'entre eux, à biner à la main des champs, planter des fruits et légumes, etc… dans l'espoir d'avoir en retour de bonnes récoltes afin de ne pas, littéralement, mourir de faim durant l'hiver.
Ah oui ? 90% des gens sont des manuels , pour te permette de te nourrir , de t'habiller , de te loger , de conduire , te permettre de voyager , de faire tes course etc etc.. de construire un PC , pour y faire fonctionner un programme...
Avant de faire de l'informatique ou des >Maths pour transformer les objets ou en construire , il faut te nourrir , te loger , t'habiller ...etc etc ,
et 90 % de ces gens, n'ont nul eut besoin de ton informatique pour vivre ni des maths ... Quand bien même elles sont utiles pour transformer la sté dont on voit le résultat ... Pour gagner ma vie et monter ma sté, je n'en ai eut nul besoin . Contrairement à toi , pour gagner ta vie ... c'est ça le résultat ???
Ta phrase : c'est uniquement pour te faire mousser et te croire important vis à vis de 90% de ces gens .. et rien d'autre ..!
Il me semble qu'il serait bon de s'arrêter là.
bien sûr quand on allume le feu , il faut savoir l'éteindre ...
D'ailleurs Yoshi pourrait te dire comment je m'appel ... Loll...
Eh oui, initialement, tout part de ces deux mots.
Entièrement faux , et tu le sais ... relis un peu tes post après le post #415 , ou je me suis présenté , indiquai le matériel que j'avais ... ("afin qu'il n'y ai pas une mauvaise interprétation de mes possibilités") , ou sans me connaître , ni même connaitre ma vie, tu te permets de dire que je profite de la gentillesse des gens..que je suis trop fainéant ... etc ..
si tu avais pris la peine de lire le sujet , au lieu de ta paresse en invoquent le prétexte que tu as une vie et de refiler des conseils inutiles , alors qu'il t'était simple de les installer dans le programme ... mais non ! Et les autres , ils n'en ont pas de vie , c'est quoi cette excuse bidon...??
Tu as appris à réparer ton véhicule ou tes appareils ménagers dont tu te sers .
Arrête de te vanter s'il te plait, car je doute que tu sois en mesure de remplacer ta charpente même à ton âge actuel ... Avant de construire une fusée , apprends déjà à réparer un moulin à café électrique ou un aspirateur ...!
Qu'est ce que tu crois que j'ai fais dans ma vie et pas avec la g..., si ce n'est apprendre pour évoluer...
Non mais ...pour qui te prends ? tu es Alzheimer ?? Tu plantes la bouse et ensuite tu t'étonnes ... au lieu de sortir gentiment et de retourner à tes études ... ou à ta vie!
Qu'elle te soit profitable . bonne soirée et j'en reste là .
#69 Re : Programmation » crible en python » 11-11-2024 15:12:41
Bien sûr… donc encore une fois, critiquer les programmes du grand LEG
Non je ne suis pas autant imbu de ma personne que toi .
Ce sont les programmes de MR B Parisse et Yoshi.
Ce qui t'intéresse uniquement sur ce fil, ce sont les critiques dont tu te nourris ...
alors même que je te propose depuis le début ! d’y remédier
("les conseilleurs sont des menteurs ou des manipulateurs...la plupart du temps,")
Car Si effectivement cela avait été le cas , après mon post #415 tu l'aurais fait , mais comme cela n'avait aucun intérêt pour toi , d'autant que c'est un bousins et qu'il te fallait des jours pour le comprendre d'après tes affirmations , voir ton incapacité à le comprendre, c'est mieux de te chercher des excuses pour pourrir le sujet , car tes compétences on les attends toujours , tu n'est en définitive , qu'un manipulateur ... pour en rester là...
De plus, s’il fallait tant que ça avoir un fil de discussion par langage de programmation, pourquoi tu n’en as pas créer un toi-même à propos de la version C++ bien avant que j’arrive ?
tu prends tes désirs pour des réalité . C'est toi qui est venu pourrir ce sujet , avec tes critiques et tes conseils inutiles sur ce programme c++ , pas l'inverse ! C'est ça, Je vais ouvrir un sujet dont je n'y connais rien ... désolé de te priver de cette joie , dont tu aurais pu te délecter, surtout avec tes conseils ...!
(déjà qui utilise encore Code::Blocks, avec un « s »,
"preuve à nouveau de tes critiques stupides" ... Tout simplement ceux qui n'ont rien à faire de tes conseils !
encore une marque d’irrespect envers le travail d’autrui ?
Non au contraire , celui qui m'a demandé de télécharger [Code::Block] sans s ^ ; ^ T , afin d'ouvrir le programme avec ce logiciel ...
>Encore une fois , avant de juger balaie devant ta porte ...
ton côté paresseux
tu t'es regardé ? toi qui je cite dans une de tes interventions :
les gens sans informatique et mathématique il en serait encore entrain de cultiver , faire de l'élevage .!
.. mon pauvre crétin , c'est pourtant grâce à eux si tu peux te nourrir , te loger , etc etc , car le travail manuel pour toi , tu es bien trop fainéant , pour t'y résoudre
Qu'est ce que tu ferais avec tes programmes , si il n'y avait pas des travailleurs manuels pour construire des PC et autres ... ça t'arrive de réfléchir ?
Qu'est ce que tu connais ma vie ? Commence par faire le ménage chez toi ...
Alors ouvre toi un sujet sur la programmation , montre ce dont tu es capable dans ton domaine , sert toi du sujet : le programme C++ de leg , met y le programme C++ , et on te verra à l'oeuvre , avec la modernisation de ce crible , tu pourras même y dépasser la limite n = 10⁶⁴ et non pas la racine carrée de n, si tu en es capable ... Je suis même sûr, que cela plaira , à ceux qui regardent ce sujet au lieu de ton bagou et tes conseils ....
À moins que Yoshi veuille déplacer notre discussion , qui est vraiment HS...Afin que l'on en reste au programme python en court ...
#70 Re : Programmation » crible en python » 11-11-2024 13:08:04
HS [Celui qui est rancunier ici , il te suffit de te regarder dans une glace, vue tes réaction depuis le post #416 , qui n'ont été que lamentables ...
D''ailleurs tes interventions, depuis le post #416 n'ont eut qu'un but .. pourrir la discussion, ce que je dois reconnaître : tu l'as admis ...! Même cette dernière est HS , je répondai à Yoshi !
C'est bien pour cela que tu ne veux pas ouvrir un autre sujet , et discuter de ce cribles c++ ailleurs que sur ce fil... Car tu peux continuer à t"acharner à pourrir le fil... au lieu de te bouger à t'ouvrir un sujet ...!
Ton c++ , tu peux effectivement te le garder et on verra ta limite n > 2 ^ 64 ... contrairement à ce qui est dit sur les math .net que tu atteints , pour moi, tes conseils tu te les gardes , de plus je ne pourrai pas l'utiliser en ce qui me concerne, tu n'as même pas l'intelligence de t'en apercevoir ... et que ce n'est pas pour moi...! ] HS
#71 Re : Programmation » crible en python » 11-11-2024 12:02:29
Bonjour
@Yoshi
Le programme n'est pas de moi, j'avais juste mis le programme Python sur les math.net , qui est posté au dessus , pour le faire transcrire en C++ , ne voulant pas t'en demander plus et inutilement.
Il a donc été retranscrit en c++ en deux partie (la partie ÉRATOSTHÈNE et la partie GOLDBACH) , que j'ai fais unifié en payant !... comme il s'ouvre sous dos , je ne me suis pas cassé la tête pou pouvoir éditer les tableaux criblés, car non pratique... le but était :
Uniquement pour aller plus vite et surtout plus loin que je ne le faisait en python, je t'en avais parlé ... " car python était limité en mémoire.." et ensuite je les avais mis sur ce sujet ...en 2019 ou avant.....
Mais Je n'ai jamais réussi à éditer le tableau criblé par la fonction size_t GCrible ou même size_t ECrible, ce qui veut dire ""en principe"" que le crible "n'est probablement pas déclaré" pour pouvoir l'éditer , comme on le fait en python , avec la fonction:
total = sum(crible)
print("crible:", crible)
Alors que là fonction , return total permet seulement d'éditer le résultat final , pourtant je peux éditer: les indices , les nombres premiers P , les restes de 2n par P... Donc il y a un hic...
Ce n'est pas faute d'avoir essayé ... et chercher à comprendre ...
Or si effectivement il manque une fonction pour déclarer le tableau criblé .. , alors même qu'il est retourné à la fin du criblage d'Ératosthène , afin de le re-cribler par la fonction GCrible et ben Nada, ...
Mon petit fils vient à noël , je lui demanderait le pourquoi du comment...
Mais : Si le fait de mettre ce programme de mon algorithme en C++ , sur ce sujet pour des auditeurs que cela intéressent, sans qu'ils se cassent le trognon, puis demander une instruction , pour le finaliser , c'est ouvrir la porte à des polémiques , 7 ans après... ou des conseils inutiles , j'aurais mieux fait de ne pas le poster puis trouver la solution ailleurs ... et me garder ce programme pour ma gueule ... Ce qui est absurde , vu le mal et le temps passé que tu t'es donné en python pour cet algorithme .
Comme tu as pu le voir , personne n'est jamais intervenu au cour de ses années, malgré le nombre de vues, et les dossiers que j'ai modifiés , re-modifiés moult fois, pour rendre mes explications plus clairs dans la mesure du possible..
D'autant , que tu ne te serais sûrement pas autant investi en python sur ce sujet , si j'étais ce genre de mec ... en voulant garder mes idées .
Comme tu l'as si bien dit les conseilleurs ..... sans solution sur ce sujet ...ils ne sont pas utiles , ni me prendre la tête pour finaliser ce programme...
C'est pour cela que la solution python est bien plus préférable , si on veut éditer les tableaux criblés , afin de vérifier le déroulement pour certaines limites n ...sans plus.
Par exemple pour ce programme en C++:
avec cette limite n :
ulonglong debut = 18446744073709551319;
ulonglong fin = 18446744073709551334;
il crible les trois familles 30k +1, 7 ,et 19 en 1,016 s , malgré le warning : la constante entière est si grande qu'elle n'est pas signée..
Cela pose un problème...
Car pour une limite bien inférieur, n = 9*10¹⁸ pour ces trois familles il met beaucoup plus de temps 44 secondes par famille , 120 secondes au total ..??? est ce que cela vient des slices ? que 'j'utilise pour repousser des limites plus importantes , car sinon il bug..., qu'il ne prendrait pas en compte dans ce cas précis de constantes entières trop grandes et non signées ... voila pour cette info amusante...et curieuse.
Pour la famille 30k+1 , il crible 88 063 057 p' , au lieu de 18 054 607 pour n inférieur ; et pour un résultat de 73 385 881 couples p+q =2n au lieu de 1 43 462 (p+q) pour cette limite n = 9*10¹⁸
autrement dit, il en crible plus en allant 100 fois plus vite ..., ça c'est un mystère ???
#72 Re : Programmation » crible en python » 10-11-2024 14:43:46
Bonjour
Sûrement... Mais ce n'était pas le but
Car pour autant , j'avais besoin d'un programme qui fonctionne parfaitement et très rapide .. c'est ce qui m'importait avant tout.
Le reste qu'il soit bleu ou arc en ciel , ne change rien à sa fonction...
Ce n'est pas comme si on demandait un programme écrit parfaitement en c++... il faut savoir nuancer en fonction du besoin ... Ce qui n'est pas le cas du pâtissier... avec son bousin , qu'il se garderait sur les bras.
Maintenant si , en le ""modernisant"" sans être obligé de remplacer Code::Block ou autre importation sur mon PC , pour le faire fonctionner afin de gagner 1 seconde voir un peut plus ...Il n'en est pas moins vrai que je ne dépasserai pas pour autant la limite $n = 2^{64} -1$ pour un PC 64 bits ce que j'ai actuellement, en ayant modifié la limite $n$ à cribler sans perte de généralité ...
il met pour cribler jusqu'à la racine carrée de $n = 18446744073709551319$ trois familles : 30k +1,+7,+ 19 ; temps mis : 1,08 seconde , d'ou l'intérêt de ne pas avoir besoin de cribler le nombre total de solutions pour cet entier $2n$ ...et donc on peut aller très loin...
Donc quel intérêt ...? À PART : le présenter sur ce sujet... pour les amateurs ou pas de C++ bien écrit... mais aussi , qu'il édite pour une petite limite $n$, le tableau criblé par la fonction de size GCrible...
Je préfère attendre la modification de Yoshi , Python sous numpy, c'est certain...
Car c'est très pratique et pas sous dos..., de plus cela permet de comparer les deux programmes , comme il le fait remarquer...
Soit on crapahute, pour atteindre le sommet de l'Everest , soit on choisi l'hélico ... c'est bien une question de choix.
#73 Re : Programmation » crible en python » 10-11-2024 07:26:48
Bonjour..avec le sourire
@Ernst ,[" tout à fait , tu as raisons... et j'aime bien : « il est parfois nécessaire de… » , car cela évite de se tromper sur la personne impliquée dans le programme ...
, l'apprentissage de C++ , de plusieurs jours , ne m'intéresse pas du tout , juste pour finaliser en trois lignes et en 1 minute , une fonction du programme , afin d'éditer le tableau criblé .. pour ceux qui préfère utiliser C++. Car :
Comme je l'ai dit , c'est plus conviviale pour moi ou d'autre en python, du fait, que l'on peut imprimer , copier/coller, les ligne du tableau criblées, alors que sous dos en ce qui me concerne ...Nada...
De plus, J'ai Code::Block , je ne vais pas du tout , tout changer ou importer d'autres choses pour utiliser mon programme tel quel ; qui me convient parfaitement ...
@ Yoshi ..; Encore merci pour ton travaille sur le programme du crible...Tu as entièrement raison même si on teste avec un programme la conjecture jusqu'à une certaine limite $n$ , cela n'en serra pas pour autant une démonstration rigoureuse. Sauf si on atteint la limite ou il a été dit, que la conjecture est vrai à partir d'un entier N assez grand... Néanmoins, cela permet de se faire une idée très précise, sur les formules d'estimation du nombre de solution qui décomposent $2n$ en somme de deux nombres premiers... C'est tout.
Pour le programme ; je vais donc attendre ta modification de la phase terminale du programme ..., qui à priori serait très rapide , y compris pour plusieurs limites $n \;modulo\; 15$ , par famille... je suppose que tu vas aussi la tester, en ne criblant que les $p'\leqslant\sqrt{n}$ ...pour repousser cette limite $n$
Pour l'instant, la conjecture est vérifiée jusqu'à $4*10 ^{18}$
H Elfgott :
Avec son crible qui utilise la méthode du cercle, il est allé beaucoup plus loin pour tester la conjecture faible $2N +1$ est somme de trois nombres premiers.. Mais il ne dit rien sur la conjecture forte ; si avec son crible, il a pu la tester aussi loin... à priori il ne semble pas...
Voila pourquoi cela m'intéresse et sûrement d'autre aussi , pour repousser cette limite $n$ de la conjecture de Goldbach..
C'est d'ailleurs pour cela , qu'après réflexion , j'en suis venu à cette solution : pourquoi ne pas la vérifier à partir d'un minimum n = 3 000 000 , en ne criblant que les nombres $p'\leqslant\sqrt{n}$ sans perte de généralité, puisque l'on sait qu'elle est vraie jusqu'à $4*10 ^{18}$.. Ce que personne n'a fait...
Cela permet surtout de se faire une idée sur le nombre de solutions par Famille $30k+i$ en progressant modulo 15... et que l'on peut éditer...
Tout comme escalader l'Everest , alors que l'on peut s'y faire déposer en hélico ...Chacun trouve sa voie... y compris dans le code du Bushidô...
@+ leg
#74 Re : Programmation » crible en python » 09-11-2024 07:12:24
Bonjour
Enfin un conseil judicieux , j'espère qu'effectivement Yoshi va supprimer tous tes message et mes réponses depuis le post # 414, qui n'on eut en définitive, qu'un résultat, comme tu le dis , "pourrir" ce sujet , sans rien apporter de concret ... À part tout ton cirque et tes nuances ..! à la rigueur le post #414 peut rester ... même si il ne sert a rien, en ce qui me concerne , ou mieux, simplement ouvrir un autre sujet , le crible en C++ de leg, afin de déplacer le tout, depuis le post #414 ...
Tu sais, moi je peux le faire dès que l'envie m'en prends et que j'ai un week-end devant moi. J'ai les compétences pour. Je n'ai donc pas besoin de toi. L'inverse est sûrement moins vrai.
Non l'inverse est faux : car je n'ai vraiment pas besoin d'un donneur de conseils dans ton genre ; mais de quelqu'un qui ne se vante pas et qui agit en fonction de ses moyens , surtout pas avec tes mots , ou, qui ne fait que brasser du vent .
Tes compétences... on en a rien vues en fin de compte , mais beaucoup de bagou ça oui...!
Le programme C++, c'est moi qui l'ai posté pour information et éventuellement utilisation , ainsi que les deux algorithmes... toi Nada ! Pourtant il y a eut plus de 287000 vues et tu es le seul à être intervenue en 7 ans , avec une entrée en matière stupide ... Dès fois il vaut mieux s'abstenir que de vouloir croire que l'on peut P... plus haut qu'on le peut...inutilement.
Je t'ai demandé d'ouvrir un sujet ,[crible en c++ de leg] , avec si tu veux, comme entrée en matière , que pensez vous de ce "Gloubi Goulba" peu importe... Au lieu de brasser du vent .. ou en interprétant à ta façon mes réponses , que je trouvent stupides et inappropriées ....
HS : J'espère que tu n'es pas trop vieux pour apprendre l'électricité , la mécanique ou l'électromécanique pour savoir comment fonctionne ton véhicule,et tes appareils ménager depuis des décennies , pour te dépanner au lieu de faire appel bêtement à un dépanneur , car tu es incapable de le faire toi même ... Commence donc, par t'appliquer tes propres conseils si tu n'es pas trop vieux , au lieu de vouloir les faire appliquer aux autres... Car tu as l'air d'être coutumier du fait et surtout d'interpréter à ta guise mes réponses ou celles des autres . Est ce pour te convaincre que tu es intéressant ?? Au lieu de mettre un peu ton mouchoir dans ta poche, si tu n'es pas trop vieux pour changer ta façon d'intervenir ...Non ?? ... : HS.
#75 Re : Programmation » crible en python » 09-11-2024 00:09:06
Bonsoir à tous les deux.
Décidément ...,: Ne pas être intéressé par quelque chose ne veut pas dire que l'on se sente vieux. c'est peut être ta façon de voir... ou que j'aurai dû m'exprimer autrement... Je me suis occupé de la construction du crible en apprenant et en lisant des maths , alors que je n'avais aucune base de Mathématique ni même d'algèbre ... à 60 ans ., j'étais motivé pour ça , avec de la passion... pour le entiers naturels et les nombres premiers... Pas du tout pour la programmation , ni pour la langue anglaise...
Mais j'ai un principe il ne sert à rien de courir dans tous les sens pour vouloir tout apprendre afin de tout résoudre... lorsque ce n'est pas utile ou du moins très peu...
Chacun à ses propres intérêts et motivations , dans le domaine qui l'intéresse... la programmation n'en fait pas partie, même si en python , je me suis quand même débrouiller pour lire le minimum afin de comprendre les différentes instructions et de ce que faisait le programme ... pour modifier certaines lignes.
Je n'aime pas qu'une personne , vienne d'emblée pour dire que ce travail est tout et n'importe quoi , pire , du bousin ou du boulgi boulga etc ..
Ce travail , ce programme en c++ ou autre, a le mérite d'avoir été fait , en fonctionnant parfaitement à mes attentes ... puis je l'ai publié sur le forum , afin que chacun puisse en prendre connaissance ou pas. Donc oui, je défend , celui qui m'a rendu ce service rapidement et qui n'est pas là pour te répondre... On n'est pas dans un court d'informatique , ni pour savoir qui est le plus compétent ... chacun y va en fonction de ses compétences et de son temps libre , volontairement, en faisant des essais , pour faire avancer le Schmilblick... Si j'avais écrit le programme je t'aurai répondu autrement, car j'aurai probablement su comment te répondre ...
À chacun ses motivations ,...
Tu te retires , c'est un choix que tu fais et c'est ton droit , mais personne ne t'as mis dehors... Je remarque simplement que ton intervention n'aura donc , servie à rien ...
Alors que le programme en c++ était à ta disposition , qu'en mettant les lignes de programme au bon endroit, ""pour le dépoussiérer ou le modernisé"" avec ensuite la raison évidente de tes explications, aurait été beaucoup plus efficace et en perdant moins de temps en discussions inutiles ...
Plutôt que de vouloir me convaincre à apprendre les rudiments de la programmation en c++... pour que je puisse le dépoussiérer ce qui m'étonnerait fortement... si cela était possible , puisque toi même tu dis le contraire ... c'est du bousin, ... alors que c'était ton métier !
Comme le dit notre cher ami Yoshi la nuit porte conseil... sans rancune ...
Mais j'espère pour toi , que tu te ferras un point d'honneur à le ré-écrire,("" éventuellement en te basant sur le programme Python"") afin de le comparer à celui qui est posté... même si on en voit jamais la couleur , sur ce forum ; ce qui serra quand même dommage pour toutes les personnes qui regardent ce sujet ... depuis 2018... C'est quand même mieux les actes que les discours ... Yoshi en connait un rayon dans ce domaine , pour être aussi tenace ...