Programme sous linux
Bonjour à tous avec mes meilleurs vœux pour 2021.
Voila mon souci.
1)
Je viens de remplacer l'OS de mon Pc windows 10, pour passer sous linux.mint.20
Système : mémoire vive [15,5Go, processeur intel core i7-4790 cpu @ 3,60 GHz X 4.
Aucun souci de fonctionnement ni de rapidité. Mais il semblerait que la limite de mon programme en C++ (crible Eratosthène ou Goldbach fait en python et retranscrit en C++ sur ce forum par la suite) fonctionne beaucoup moins loin que sous windows 10 ?
sous windows 10 ma limite était :
n=8250 000 000 000 en 1400 secondes . Or sous linux mon programme s'arrête pour la limite
n = 4200 000 000 000
Y a-t-il une raison ? mémoire virtuelle qui est la moitié de win 10 ? Ou faut-il re-paramétrer la mémoire virtuelle pour l'augmenter...etc ...?
2)
Je joins ci-dessous le fichier qui comprend les deux programmes python qui ont été retranscrit en C++ grâce à l'aimable concourt de B Parisse il y a 1 an 1/2 environ. Avec le programme Python qui unifie les deux programmes (Eratosthéne et Goldbach).
Il y aurait-il une personne qui pourrait unifier les deux programmes C++, ou encore retranscrire le programme Python en C++.
Ce qui me permet de vérifier assez rapidement pour une limite n d'environ 6000 000 000 000 indiquant le nombre de couples p+q = 2n.
Merci pour tous renseignements.
Voila mon souci.
1)
Je viens de remplacer l'OS de mon Pc windows 10, pour passer sous linux.mint.20
Système : mémoire vive [15,5Go, processeur intel core i7-4790 cpu @ 3,60 GHz X 4.
Aucun souci de fonctionnement ni de rapidité. Mais il semblerait que la limite de mon programme en C++ (crible Eratosthène ou Goldbach fait en python et retranscrit en C++ sur ce forum par la suite) fonctionne beaucoup moins loin que sous windows 10 ?
sous windows 10 ma limite était :
n=8250 000 000 000 en 1400 secondes . Or sous linux mon programme s'arrête pour la limite
n = 4200 000 000 000
Y a-t-il une raison ? mémoire virtuelle qui est la moitié de win 10 ? Ou faut-il re-paramétrer la mémoire virtuelle pour l'augmenter...etc ...?
2)
Je joins ci-dessous le fichier qui comprend les deux programmes python qui ont été retranscrit en C++ grâce à l'aimable concourt de B Parisse il y a 1 an 1/2 environ. Avec le programme Python qui unifie les deux programmes (Eratosthéne et Goldbach).
Il y aurait-il une personne qui pourrait unifier les deux programmes C++, ou encore retranscrire le programme Python en C++.
Ce qui me permet de vérifier assez rapidement pour une limite n d'environ 6000 000 000 000 indiquant le nombre de couples p+q = 2n.
Merci pour tous renseignements.
Connectez-vous ou Inscrivez-vous pour répondre.
Réponses
Il est tout-à-fait possible que les erreurs d'overflow n'arrivent pas au même endroit... mais ce n'est même pas un problème de Linux contre Windows, simplement d'interprétation effectuée par le compilateur choisi ! Certains compilateurs auront décrété que tel type d'entiers se code sur 32 bits dont 1 réservé, alors que d'autres utiliseront les 32 bits, par exemple.
Que dit le programme au moment du plantage sous Windows ?
Idem sous Linux ?
Tout ça pour explorer la piste suggérée par Bisam, c'est la plus plausible.
sous Windows une fois la limite du crible en C++ atteinte il était impossible de mettre une valeur n > 8200 000 000 000 la (fenêtre dos) se fermait .
sous linux à partir de la valeur 4200 000 000 000 : j'ai un message d'erreur au bout de 30 secondes + ou - ; avec erreur : killed process returneds 137 (0 X 89) après 28 secondes..???
( je suppose que le swapping est impossible donc le processeur est tué...si je comprend bien)
le même programme python : sous windows 10 ou linux ; 64 bit ; ne dépasse pas la limite n = 69 000 000 000 en gros
la retranscription des 2 programmes Python en C++ à été faite en 2019 , par B Parisse sur ce forum et ils fonctionnaient parfaitement jusqu'à la limite possible de ma ram.(16go)
si vous avez code::Blocks sous Windows avec mingw amd64 que j'avais aussi télécharger sur code::blocks.org pour exécuter les exécutable en 64 bit. vous pouvez vérifier.
Voici la version code::block que j'ai installé sous linux ,
release 20.03 rev 11997 (2020-03-28) gcc 9.3.0 Linux/unicode - 64 bit.
Mais sur le site officiel pour Windows 10 j'avais : codeblocks-20.03-32bit-mingw-64bit-setup.exe
pour linux Debian il propose :
Logo Debian
codeblocks_20.03_amd64_oldstable.tar.xz
codeblocks_20.03_amd64_stable.tar.xz
peut être que je n'ai pas la bonne version ...? et qu'il me faut une des deux ci-dessus ???
Je ne comprends pas pourquoi autant de code et autant de temps pour un simple crible d'Erathostène.
J'ajoute que 64 bits non signés vont jusqu'à 1,844674407x1019. Et 64 bits signés, la moitié. Largement plus que ton 69 000 000 000 = 6,9x1010.
Il est habituel de faire du mauvais code et d'incriminer la machine.
je pense que tu n'as pas tout compris ...
que tu as oublié de regarder les programmes que j'ai mis dans le premier post.1 en python et 2 en C++. (Ne te gène pas pour tester l'un des deux programmes en C++ sous Windows 10_64 bit.)
Mais je suppose que tu sais faire du bon code ...:-D
Alors ne te gène pas pour retranscrire le code Python EG2_modulo 30.py, en C++ et ensuite je pourrais dire que ton programme est excellent et que cela ne venait pas de machine...:)o
Si maintenant tu penses que la personne qui a retranscrit les deux programmes python en C++ a fait un mauvaise du mauvais code ...:-S;
Tu ferais bien de te renseigner sur la personne en question et nous montrer ce dont tu es capable...
à part commencer par critiquer l'auteur des codes en C++ sans savoir, ou de dire je ne comprends pas... blabla... tu appelles ça donner des explications pour comprendre que tu n'as pas compris ce que j'ai demandé...
Bisam et Lourrran m'ont posé des questions... pour essayer de me dire où il peut y avoir problème...
Peut-être que le compilateur de Code::block avec mingw 64 pour windows 10 64 bit fonctionne tres bien sous Win, alors que la version de code bloc pour Linux debian 64bit va beaucoup moins loin en limite, exactement la moitié.. ce que je trouve quand même curieux ...:-S
le compilateur qui est paramétré sur linux est : GNU GCC
Vous pouvez essayer la commande top sous linux, puis U puis votre nom d'utilisateur, cela affichera alors la liste de vos processus, avec en particulier la mémoire physique et virtuelle disponible et la mémoire utilisée par le processus. Vous pourrez alors voir la quantité utilisée un peu avant que le process ne soit tué.
Juste après vous pouvez aussi faire dmesg | less ou dmesg | grep -i kill
Je ne sais pas comment ça fonctionne sous windows.
vos deux codes fonctionnaient à merveille sous Windows 7 64bit 8 Go de ram depuis mars 2019 lorsque vous me les avez retranscrit en C++
la limite n de calcul était 7250 000 000 000 sans souci...
puis en aout de cette année je suis passé sous Windows 10 avec 16 Go de ram sans aucun problème beaucoup plus rapide et gain de limite n maximum : 8250 000 000 000
Mais avec windows 10 et leur mise à jours j'ai commencé a planté écran bleu, stop code etc etc ...
Donc je suis passé sous linux débian 64 bit. la personne qui m'a remplacé l'OS , m'a donc réinstallé Code::bloc pour linux débian 64.
En python le programme que j'ai mis Crible_EG2_modulo30.py ne va pas très loin que ce soit sous linux ou sous windows et en rapidité c'est pareille peut être un peu plus rapide sous linux.
Mais curieusement vos deux codes C++ qui saturaient aux environ de 8200 000 000 000 , il ne dépasse pas la limite 4200 000 000 000 , pratiquement la moitié, que sous Windows 7 ou Windows 10 ; alors qu'en rapidité il n'y a pas de problème.
Donc effectivement c'est un problème de mémoire . je vais donc demander demain à l'informaticien qu'il regarde vos instructions afin éventuellement d'améliorer ce problème si possible...C'est très gentil à vous de me renseigner à ce sujet.
Ceci dit mon souci majeur c'est de faire retranscrire en C++ ce code python Crible_EG2_modulo30.py que j'ai mis sur le premier post, car si il doit rester en python alors ... que ce soit wind ou linux il sature à 69 000 000 000 et très lent sous python en comparaison du C++...donc...voila.
ou encore d'unifier les deux C++ : en rappelant le tableau d'Eratosthène criblé , que Goldbach va utiliser à partir du return ("c'est très mal expliqué car moi et l'informatique....ça ne va pas très loin.") mais le programme python explique assez bien le principe..à partir de la ligne de code : lorsque Eratosthène à fini de cribler:
cette partie:
Premiers+=Premiers_suite del Premiers_suite # suppression du tableau devenu inutile nbpremiers = len(Premiers) n2 = 2*nVoila ... Bonne soirée Mr Parisse, merci encore et que 2021 réalise tous vos voeux.
Ps : Mon petit Fils qui est à l'UQAM de Montréal devrait finir sa Maitrise d'IA la saison prochaine à l'Univ de Grenoble, là ou il était il y a deux ans pour son stage...
script du crible EG2_modulo 30 complet ci joint
@Mr Parisse :
Est ce que dans l'hypothèse du manque de mémoire, pour éviter que le processus tué en premier soit celui qui est utilisé par Code::block ; peut il être prioritaire par une instruction de commande Linux ou autre ?
Afin que l'exécutable C++ soit prioritaire pendant sa période de calcul...? (" bien entendu jusqu'à la capacité de la mémoire ram , dans mon cas un peu comme sous Windows limite de calcul : n = 8 100 000 000 000 , $8*10^{12}$.")
Je viens de regarder le Processus , c'est au chargement de l'exécutable qui monte directement à 100 pour 100 de la mémoire et il s'arrête..
Ce qui ne se faisait pas sous Windows ...
Peut être qu'il y a une configuration à faire sous linux pour que l'exécutable ne sature pas 100% de la mémoire au démarrage mais par palier..:-S
Peut on sous linux créer un espace Windows qui contiendrait Code::block et ses deux exécutable, pour utiliser l'exécutable code::block sous Wind ..???
Tout à fait . C'est ce que j'ai fait ce matin suivant vos conseilles en ouvrant le moniteur Système puis en lançant l'exécutable.
La personne qui m'a installé linux, a oublié de me modifier le paramétrage du fichier d'échanges qui est celui par défaut, puis compresser la mémoire ram pour augmenter la mémoire virtuelle , afin de garder la rapidité du processus...
lorsque je lançe l'exécutable l'utilisation de la mémoire physique est 1GB 6,7% mais l'utilisation de l'espace d'échange est de 99% sur 2,0 GiB.
l'utilisation des CPU est 2 à 7% sur l'historique d'utilisation des 8 CPU.
il m'a aussi confirmer que l'on pouvait faire une partition de swap mais il attend de voire les processus...
Concernant ma question 1) le problème est résolu , la partition du fichier d'échange swap à été modifiée et ça fonctionne aussi vite voire un peu plus que sous Windows 10 pour une limite 2n = 1,6 * 1013
Reste plus qu'à trouver une âme charitable qui veuille bien me transcrire le fichier crible EG2.pdf en C++ :)o
ou unifier les deux programme C++ mis sur le premier post ce qui peut-être sera plus simple... avec une bonne bouteille à la clef... X:-(
J'imagine que c'est pour des raisons de rapidité que le c++ est choisi, non ? Tous les cœurs sont-ils utilisés ?
Cela demande du temps et de l'énergie d'entrer dans un code pour le comprendre, mais il pourrait être intéressant de le réécrire sous Python (voire de le porter sous julia, je sais qu'il y a au moins 1 spécialiste ici) pour exploiter le multiprocessing et la librarie Numba. A voir comme un exercice si ça intéresse certains ;-)
A plusieurs reprises j'ai donné cette étude intéressante de la Nasa
Exemple: LEG lance son programme pour traiter le nombre N.
Le programme va chercher tous les nombres premiers entre 7 et \sqrt(N)
Puis le lendemain, LEG va lancer son programme pour traiter le nombre N+10.
Le programme va chercher tous les nombres premiers entre 7 et \sqrt(N+10).
Il y a un concept qui existe, le concept de fichier.
Si on mémorisait dans un fichier tous les nombres premiers trouvés, on n'aurait pas besoin de les recalculer à chaque lancement.
On pourrait même modifier le programme pour dire : traiter tous les nombres entre N et N+10000 en une seule passe, plutôt que relancer le programme pour chaque nouvelle valeur de N.
En jouant sur la puissance de la machine, on parle de facteur 1.5 ou facteur 2.
Avec les propositions ci-dessus, on parle de facteur 100 ou mieux encore.
Mais comme la route suivie par LEG est une route qui mène dans le mur, faut-il vraiment essayer d'aller plus vite ?
@Lourrran et Paul 18.
En effet le C++ a été choisis pour les deux premiers algorithmes écrits en python puis retranscrit en C++ par B Parisse pour une question de rapidité en effet , je lance le programme pour N = 9*1012 que ce soit pour Eratosthène ou Goldbach le temps mis est de 1363 secondes
Or pour chaque valeur de N de la forme de 30k + i et de raison 15 ; les index de départ ne sont pas les mêmes pour cribler les entiers A de 1 à N en progression arithmétique de raison 30 pour chaque limite N +15 Pour Eratosthène comme pour Goldbach, si ce n'est que pour ce derniers on crible les entiers A de 1 à N non congrus à 2n modulo P, premier; avec $P\leqslant\sqrt{2N}$ indiquant par conséquent le nombre de nombres premiers $q\in[N ; 2N]$.
Alors qu'en python ces deux mêmes programmes rament à mort et la limite N sature aux environ de N = 60 000 000 000 plus de cent fois moins, ainsi qu'en rapidité .
Mais ce qui m'importe c'est le programme Python qui réunifie les deux programme à retranscrire en C++ . Indiquant directement le nombre de nombres premiers P" de 1 à N ; non congrus modulo P avec 2N; restituant par conséquent le nombre de couples P" + q = 2N
le principe de la réunification des deux algorithme en C++ à pour but d'utiliser le tableau des entiers A de 1 à (N/30) criblé par Eratosthène, ensuite le programme G, rappelle ce tableau criblé pour le recribler à nouveau par le crible G .
voici un petit exemple : pour N = 1500
1) Eratosthène crible de 1 à N on fixe la famille 30k + i avec i =7
illustration du résultat :
RESTART: /home/gilbert/Programmes/Crible_ Era_gty_mod30.py ==========
Donnez N: 1500
crible: b]1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0[/b
Nombre premiers criblés famille 7 : 30 nombre premiers P" représenté par les 1 ; de 7 à N
--- Temps total: 0.01 sec ---
2) Goldbach crible en utilisant les congruences de 1 à N on fixe la famille 30k + i avec i =7, qui va restituer les nombres les nombres premiers q de N à 2N de la famille 30k + i ; avec i = 23 ; car 30 -7 = 23 d'où pour 2N = 3000 ; 3000 - 7 = 2993 famille 30k +23. ("attention on utilise les nombres premiers P < racine de 2N et non de N ")
illustration du résultat , pour voir ce que fait le crible G :
RESTART: /home/gilbert/Programmes/Crible_G.T.Y_modulo30.py ==========
Donnez N: 1500
crible: b][color=#FF0000]0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1[/color][/b
Nombres A non congru 2n[P] de 1 à 1500 famille 7 , premiers q de 1500 à 3000: 25 les entiers A non congru mod P sont représentés par les 1; en progression arithmétique de raison 30.
3) Maintenant le crible EG2_modulo 30.py va tout simplement re-cribler le tableau d'Eratosthène en 1) même limite N et même Famille 7
(" avec les même nombre premier P, utilisé en 2) donc < racine de 2N ")
illustration :
RESTART: /home/gilbert/Programmes/Crible_EG2_mod30.py ============
Donnez n: 1500
crible: 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0
Nombres P' non congru [P] de 1 à 1500 famille 7 représentés par les 1 ou nombre de couples p+q=2n: 16 soit : nombres premiers P" non congrus modulo P avec 2N ; d'ou nombre de couples P"+q = 2N
Et ta solution @Lourrran au regard de l'algorithme est pratiquement infaisable...mais surtout moins rapide ...etc
Donc reste la solution de @Paul 18 : le programme est en python relativement simple à comprendre , sans donner d'explications pour les deux premiers retranscrit en C++ a été fait très rapidement par Mr B Parisse. (si je me rappelle, le lendemain de sa proposition de me les retranscrire en C++)...
Mais peut être @Paul18 qu'un bon resto à ta guise... pourrait t'aider ....;-):)o ...?
Au départ, tu posais une question qui semblait technique, mais plus on te pose des questions et plus on se rend compte que l'algorithme que tu utilises n'est pas forcément le meilleur adapté à ce que tu souhaites faire (et ce n'est pas forcément ta faute : ça arrive très souvent, même dans des grandes entreprises spécialisées dans l'informatique !).
Je ne pense pas que quelqu'un soit suffisamment motivé pour récrire ton programme, non pas parce qu'il serait difficile à récrire, mais surtout parce qu'il faudrait rentrer dans ta tête pour comprendre ce que tu as voulu faire... et c'est souvent ce qui prend du temps quand on collabore sur un projet informatique, en particulier quand celui-ci est peu ou mal commenté.
Je vais devenir célèbre, je vais obtenir la médaille Fields ?
En toutes simplicité , sans même me demander ce que faisait les deux premiers algorithmes en Python...
Quand à supposer que les deux algorithmes ne sont pas les meilleurs adaptés... Tu les a sur le premier post en C++ testent les ....:-D
si tu les testes : à la question donner N, choisi N = 15k par exemple 300 G0 et pour Fam tu choisis une des 8 familles i (1,7,11,13,17,19,23,29) ensuite entrée . exemple : 300000000000 7 ---> et tu clic sur enter.
Est ce que tu as mieux et plus rapide de façon élémentaire que le crible G. ce que je viens d'expliquer : il crible les entiers A de 1 à N congru à 2N modulo P ; d'ou tu obtiens les entiers A non congrus à 2N modulo P , qui par conséquent te restitue les nombres premiers q de N à 2N
Tout comme Eratotsthène crible les entiers A de 1 A N, multiple de P < racine de N, qui restitue les nombres premiers P" de 1 à N.
Si ce n'est ; que l'on travaille "crible" dans les suites arithmétiques de raison 30...
Par conséquent il faut utiliser (calculer) des index ; pour le départ des nombres premiers P qui vont cribler ensuite, selon le principe d'Eratosthène; c'est à dire par pas de P, de l'index à N // 30.
Je ne pense pas que cela soit si difficile à comprendre...
Mais je suis tout à fait à ta disposition pour te répondre ce que fait le programme EG2_modulo 30.py dans les différentes partie du programme...
Ces 2 algorithmes G et EG2 qui utilisent les congruences étaient inconnu avant que je les construise...
Il a déjà été prouvé par des vérifications systématiques que tous les entiers pairs de 6 à $4\times 10^{18}$ peuvent s'écrire comme la somme de deux nombres premiers, cela a été fait il y a 6 ans. Il y a sûrement eu plus de vérifications depuis, mais personne n'a jugé bon de le publier... car cela n'apporte pas grand chose !
Il est même inutile de tester tous les entiers 2n en utilisant tous les nombres premiers, il suffit de les tester avec une seule famille en fonction de la forme de n... où on dépassera allègrement les 4*1018...
Je regarde la variation du nombre de couples p+q = 2n en progression arithmétique par augmentation de la limite N de 15 et dans les suites arithmétiques...bref...
J'ai besoin de ce programme en C++ pour des raison de rapidité sans avoir à "poireauter".
En python le programme met 600 secondes pour une limite 60 000 000 000 ce qui est très très lent par rapport au c++ où il ne mettrait que 5 secondes.
-- Schnoebelen, Philippe
0@nicolas.patrois
Et pourriez vous faire en sorte que le programme Python ci dessous soit en C ou C++ mais plus rapide qu'en Python...:-S:)o
Merci d'avance...
Je me garderais bien de te donner des leçons dans ces deux langages.
-- Schnoebelen, Philippe
Quelque soit la leçon, ça ne peut pas aller loin car je n'y connais "pineuts" en langage de programmation :-S
merci
-- Schnoebelen, Philippe
@nicolas.patrois
heureusement qu'il ne faut pas se contenter de ce que l'on peut faire... Car je pense que ces forums n'auraient plus aucune utilité :-S
Je ne suis pas un débutant en programmation Je n'ai jamais fait de programmation ... Le programme python ci dessus n'a pas été fait par moi, et la personne ne fait pas de C++, ou pas assez pour réunir les deux programmes C++ en début de sujet.
À partir de la fin du programme d'Eratosthène afin d'utiliser le tableau des entiers criblés, jusqu'à la limite N entrée, puis rappeler ce tableau par le deuxième programme de Goldbach, afin de le cribler, puis la partie finale ne change pas, le programme édite le résultat.
Donc c'est la partie centrale à modifier pour unifier les deux programme en C++.
Je pense que pour un programmeur en c++, cela ne pose aucun problème, tout comme pour le programme python où il a fallu quelques minutes pour modifier la partie des lignes de code entre la fin d'Eratosthène, le rappel du tableau du tableau criblé, Puis le crible G va utiliser ce tableau par la fonction Cribler le tableau, et le reste ne change pas...
C'est peut être plus simple à comprendre avec ce premier programme python du crible EG_2N_mod30.py
Comment fait on pour l'éditer car il m'indique Error database ?
Et c'est pour ça que tu dis que traiter en une seule fois plein de nombres, c'est impossible.
Pour la méthode que tu as préconisée je te répond oui.pas impossible mais inutile perte de temps et on ne peut pas relancer et utiliser les fichiers criblés pour N=6000 , pour cribler N=6015 ! tu ne comprends toujours pas pourquoi ? Tu ne vois pas que les restes R de 2n par P changent pour chaque valeur de N ...
Au lieu de trouver des explications ... au pif , car il semblerait que tu n'ais toujours pas compris ce que fait le programme EG2_mod30
Tu as les programmes en python qu'est ce que tu attends pour tester ta méthode à chaque changement de la Valeur de N = 60000000000 Fam 7
puis N =60000000015 Fam 7
enregistre tes fichiers, puis relance à partir de N = 60000000000 X:-(
Est ce que tu te vois entrain de relancer pour N = 6000 000 000 000 pour tester 6000 000 000 015 avec des million de fichiers
Si tu avais pris la peine de regarder les deux programmes C++ tu verrais que Mr Parisse a utilisé des slices de 1500000 ce qui doit faire en gros 6 000 000 de tableaux ...pour N = 6000 000 000 000 et tu crois que tu vas utiliser ces million de tableaux pour relancer à partir de N =6000 000 000 000 pour cribler 6000 000 000 015 :)o
Essaye seulement de cribler N=600, utilise ton résultat et ton fichier de 20 nombres recrible à partir de ces 20 nombres pour N=615 et montre nous le résultat criblé des nombres A de 7 à 600//30 congru mod p avec 1200...
sur excel tu peux voir le résultat
sur python sans re cribler tu peux voir le résultat en décalant d'un rang le résultat précédent , sais tu au moins pourquoi ?
Je n'aurai même pas besoins de cribler pour avoir une estimation minimum de nombres premiers $p" \not\equiv{2N}[P]$ avec la fonction
$\frac{G(N)} {Ln\;G(N)}$ où $G(N)$ est le nombre de nombres $A\not\equiv{2N}[P]$ ou encore le nombre de nombres premiers q de la Fam 7 entre N et 2N...
nb=100000+1 crible=[True]*nb crible[0:2]=False,False n=2 while n<=sqrt(nb): # Le crible crible[2*n::n]=[False for _ in range(2*n,nb,n)] n+=1 while not crible[n]: n+=1P.S. : Mon pseudonyme ne comporte pas d’arobase. ;-)
-- Schnoebelen, Philippe
nicolas.patrois
Merci, mais le crible d'Ératosthène en Python, ne me sert plus à grand chose ... Il est utilisé au début du programme uniquement pour avoir les nombres premiers $P\leqslant\sqrt{2N}$ "pour Goldbach" qui vont cribler la famille en progression arithmétique de raison 30, qui sera fixée avec la limite N.
Ou encore $P\leqslant\sqrt{N}$ "pour Ératosthène même famille même limite". Ce que j'ai illustré un peu plus haut, il y 3 jours.
Si ce n'était que pour Ératosthène... je ne m'embêterai pas il y a environ 20 ans que j'en ai fait faire un en C ... mais bien en dessous de ce que l'on trouve actuellement, comme sur le site : https://primes.utm.edu/nthprime/ par exemple.
Désolé.
le nombre de nombres premiers pour une limite N = 300 000 000 000 fixée, avec sa famille ne change pas.
Mais pour une autre limite > N par exemple , ça change obligatoirement de N à N+300 000 000 000.
Ce qui implique que tu ne peux pas repartir directement de ton crible à partir de N =300 000 000 000 pour cribler jusqu'à 600 000 000 000 sans repasser par la case départ:)o
en utilisant le crible G oui je peux, car je criblerai différemment jusqu'à N= 300 000 000 000 ce qui me donnera les nombre premier de N à 2N dans l'hypothèse ou la mémoire du Pc ne te permet pas de cribler jusqu'à 600 000 000 000 en une seule traite.
D'ailleurs les deux programmes C++ sont limité à la limite N = 9 000 000 000 000 pour Ératosthène comme pour Goldbach , ce qui me donne bien le nombre de nombres premiers jusqu'à 18 000 000 000 000 pour une Famille fixée .
Mais le résultat en lui même n'a aucune importance . Le crible de Harald Helfgott il te donne le résultat pour plusieurs billions de milliards, c'est pour le fun...:-D
Alors que le Crible_EG2_mod30.py en question c'est différent.. Par exemple pour chaque limite N +15 , tu peux voir la variation du nombre de couples P + q = 2N ; regarder la courbe de variation ..etc etc par Famille .
Il est même certain que quelque soit la Famille sur les 8, que tu auras choisie; tu n'auras jamais pour une limite N=15(K+1) aucun résultat = 0 ;-)
voila ce que j'ai essayé de faire en prenant l'exemple des deux programmes python unifiés que j'ai posté au dessus ; mais sans succès : plusieurs erreurs....bref...:-S
j'ai :
Soit la partie Ecrible , qui fonctionne et me donne le bon résultat, comme dans le programme C++, d'Ératosthène , soit la partie Gcrible C++ avec le bon résultat ;
mais Gcrible ne prend pas la main sur le programme Ecrible , lorsque celui ci à fini de cribler le tableau, pour le repasser à Gcrible, afin de re cribler le tableau ...
Je viens juste de voir les fichiers sources du programme...
Entre les commentaires succincts, les ajouts en couleur, l'usage de formats fixes en dur et d'autres techniques certainement très indiquées pour augmenter les performances, avec comme corollaire une moins bonne aisance pour la relecture, d'autant plus si on est extérieur au domaine, je dois dire que la tâche que tu demandes me semble ardue, LEG.
Alors, c'est vrai que tu indiques à quels endroits les procédures Python bloquent, mais il faut bien voir la procédure en entier pour pouvoir la corriger comme il se doit.
Sans vouloir rerentrer dans de nombreuses digressions et débats, je pense sincèrement qu'il serait vraiment plus simple, pour tous ceux qui veulent t'aider, de suivre ce que fait ton programme sur un exemple-bébé (on va dire allant jusqu'à N = 100) mais expliqué en détails, ce qui signifie tous les détails, même les moindres, même ceux qui te semblent évidents, en repartant du début, comme si tu découvrais à nouveau ta procédure et surtout, en expliquant le but des choix que tu poses dans les différents calculs de ta procédure.
C'est, à mon sens, la façon la plus simple de faire le partage, ainsi que le portage, de ta procédure.
Je suis bien conscient que c'est te demander de sans doute refaire une Xième fois cette explication (je ne sais pas ce que vaut X), mais il me semble que ce serait salutaire, d'autant plus que, et je crois ne pas être le seul à penser cela, tout ce que j'ai lu sur ta procédure me semble être un plasma de propriétés assez étendu et il n'y a pas un message unique de ta part qui explique la globalité de ta procédure.
J'espère que tu ne prendras pas mal ce message, c'est uniquement dans le but de t'aider à formaliser au mieux ta procédure.
Au plaisir de te lire.
Cherche livres et objets du domaine mathématique :
Intégraphes, règles log et calculateurs électromécaniques.
rassure toi je ne prend pas mal tous les conseils justifiés que tu indiques, même si il me faut réexpliquer: mais Python EG2 ,fonctionne parfaitement , c'est en c++ qu'il faut le retranscrire ...
Au début de ce sujet j'ai posté les programmes des deux algorithmes en C++, et le programme réuni des deux algorithmes en python
chaque programme C++ : va extraire les nombres premiers selon deux méthodes différentes.
1) en page 4 du fichier posté tu as C++ Eratosthène ; EC crible j'utilise code:blocks pour les lancer.
la première partie du programme de la ligne 1 à la ligne 52 , va extraire les nombres premiers de 7 à racine de N qui est demandé, afin d'être utilisé par la deuxième partie du programme en question, ou , pour le c++ Goldbach Gcrible cette première partie est commune aux deux algorithmes ; il suffit de les ouvrir ou de regarder le fichier posté, en les mettant cote à cote pour visualiser les parties communes des deux algorithmes
de la ligne 54 à la ligne 90. ce sont les partie qui cribles le tableau fixé de 1 à N modulo 30 donc en progression arithmétique de raison 30. Cidessous.
size_t ECrible(const vector<ulonglong> & premiers,ulonglong n,int fam){ int cl=clock(); size_t lencrible=n/30,nbpremiers=premiers.size();on demande au programme de la ligne 62 à 70 ci-dessous, de rappeler les nbpremiers et de calculer les produit = p*Gm jusqu'a ce que le produit %30==fam , la famille qui a été fixé à la demande lors du lancement...
for (size_t i=0;i<nbpremiers;++i){ ulonglong p=premiers[i]; ulonglong produit; int GM[]={7,11,13,17,19,23,29,31}; for (size_t j=0;j<sizeof(GM)/sizeof(int);j++){ produit = p*GM[j]; if (produit %30==fam){ produit /= 30; break;exemple : je fixe N = 300, et Fam = 7 ce qui me donne un tableau de 10 cellules marqué par des [1,1,1,1,1,1,1,1,1,1] ce qui se traduit [7,37,6,7,97,127,.....etc 277 < 300 ok ?P= 7 va donc calculer 7*7;7*11,7*13,7*17,7*19,....7*31 == 7%30 ce qui correspond bien à la famille Fam = 7.
puis on calcul l'index if (produit %30==fam){ ; produit /= 30;
on va donc fixé l'index : 317 / 30 = 10,57 > 300 , ce qui veut dire que 7 ne parquera aucun multiple 1 de 7 à 277 on réitère avec p = 11.
P = 11 va donc calculer 7*11,11*11,11*13,11*17,== 7%30 = 187 ce qui correspond bien à la famille Fam = 7.
puis on calcul l'index if (produit %30==fam){ ; produit /= 30;
on va donc fixé l'index : 187 / 30 = 6.23 l'index 6 : 0,1,2,3,4,5,6 ou on remplace 1 par 0 , car multiple de P = 11: [1,1,1,1,1,1,0,1,1,1]
etc ..etc 11 sort du tableau et on réitère avec 13, puis 17 < racine de N.
ensuite le programme calcule le nombre de 1 restant = premiers et le temps puis il édite le résultat...
Mais cette partie là , la fin du programme C++ Eratosthène ; EC crible on en a pas besoins pour relier la deux programmes , car elle se trouve aussi dans le programme c++ Goldbach Gcrible
Donc il faut relier le programme de Goldbach , là où Eratosthène à fini de cribler son tableau pour : rappeler le tableau criblé; size_t lencrible=n/30,nbpremiers=premiers.size(); et surement le crible ce que je n'ai pas réussi à faire ....
Ensuite on colle ou on relie le programme c++ Goldbach Gcrible à partir de cette instruction ligne 54 dans Goldbach, car le début on l'a dans Ératosthène:
typedef unsigned long long ulonglong; size_t GCrible(const vector<ulonglong> & premiers,ulonglong n,int fam){ int cl=clock();on supprime la ligne de code devenue inutile dans Gcrible : size_t lencrible=n/30,nbpremiers=premiers.size();et bien sûr à la fin il faut rajouter une ligne d'instruction 115 : et modifier la ligne 116 : GCrible(premiers,N,fam); comme dans Python pour être utiliser par les deux fonctions qui criblent ,
mais surtout en modifiant la ligne 56 : size_t GCrible(const vector<ulonglong> & premiers,ulonglong n,int fam){
int cl=clock();
pour réunir les deux programme Python selon deux méthodes; il n'a fallu modifier que 4 lignes et en rajouter en rajouter deux ...mais Python ce n'est peut être pas pareil...je joins python les parties modifiée que l'on peut visualiser sur le programme Python que j'ai posté en première page
Au post 17, il y a l'explication complète détaillé du fonctionnement des algorithmes en python , et retranscrit en C++. à par, EG_2Ncrible en python qui n'est pas retranscrit en C++