Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#76 Re : Programmation » crible en python » 08-11-2024 20:09:10
Je pense , que de demander sur un forum , si quelqu'un veut bien me programmer un crible ...c'est de profiter de la gentillesse des gens ... tu ne me connais pas !
lorsque j'ai demandé en 2018 si quelqu'un voulait bien me retranscrire le programme Python ... sur les Mathématiques.net que tu fréquentes suffisamment , il est évident que tu ne t'y ais pas proposé...,
je proposai à l'époque de payer le restaurant de son choix , y compris au palais de saveurs à Montpellier (Rescassol)
... La seule personne qui l'a retranscrit , sans rien demander, ni vouloir que je lui paye le restaurant ou autre , C'est Mr B Parisse , directeur de recherche institut Fourrier Univ Grenoble ... son domaine de recherche est la physique Mathématique ... 24 h après il m'a posté le programme en c++ , que j'ai posté ICI en page 15 , en 2019..! (c'est peut être du goulbi goulba , du bousin ou en bon Gaulois de la M..., pour toi , Or moi, cela me suffisait pour faire avec) .
Mais à l'époque tu étais absent des propositions ..! Pourtant tu naviguais , il me semble sur le site mais , tu avais sûrement d'autres chats à fouetter ...
Ensuite j'ai demandé à un ami informaticien à Sophia Antipolis, qui m'avais déjà en 2003, programmer un crible (nbpremier, en c+) , en le payant..! si il pouvait unifier les deux programme de B Parisse , Ératosthène et Goldbach , comme l'a fait Yoshi en python ...
Il a demandé à son collègue , qui me l'a fait et il ne voulait pas que je le paye car cela lui était facile, d'unifier ces deux programmes même si c'est du Bousin ...48 H APRÈS ! J'ai quand même offert un cadeau à sa fille car je connais très bien la famille .... En 2003 il était étudiant à l'essi de Sophia
Alors respecte le travail d'autrui cela te sera profitable et avant de juger , réfléchis un peu mieux.. ou demande ...
Si tu avais pris la peine de lire tout le déroulement de ce sujet depuis 2018 , tu verrais qu'effectivement Yoshi c'est donné beaucoup de mal , car j'étais novice en la matière y compris en math,,. mais il a su me faire sortir les explications dont il avait besoin, pour me refaire le programme en python
la personne qui s'est proposée en Haskell ! On ne lui a rien demandé...! Mais peut être il n'était pas capable de re transcrire un programme python, en Haskell ; dans ce cas, mieux vaut ne pas venir se vanter ou de faire le beau en ventant les mérites du haskell...
Pour te répondre , tu es venu sur ce forum ...je te cite :
En lisant en diagonale le programme en "C++" de notre ami LEG, j'ai… bon. Ce n'est clairement pas du C++. On est plus sur du C+vector. Et encore, c'est gentil de ma part. C'est plus un gloubi-boulga dont on se demande comment ça peut tourner !
.....IL TOURNE ... TRÈS BIEN ET TRÈS VITE ...!
Pourtant tu t'es abstenu à l'époque, de faire une remarque à Mr Parisse ...Peut être que tu ne l'as pas vu , ou voulu intervenir...
Donc si il te prend la fantaisie , de vouloir essayer de ré écrire le programme pour le moderniser... tu es libre de ton choix. , si tu n'as pas envie de lui ajouter la fonction afin d'éditer le tableau criblé , c'est aussi ton choix , qu'est ce que je ferai , et bien je le testerai et je te dirais si il fonctionne mieux ou pas jusqu'à :
9 000 000 000 000 . Pour le reste, je ne t'ai pas attendu , car il ne serait sûrement pas écris depuis 2018 en c++ , c+ ou autre... Non ?
j'utilise python pour imprimer mes tableaux , car c'est plus conviviale ... c'est juste pour la forme, afin que le programme soit complet et que quelqu'un puisse imprimer le tableau criblé..si besoins est !
#77 Re : Programmation » crible en python » 08-11-2024 18:11:38
Rer DRStone ,
Rassure toi je ne me sent pas vieux du tout, même avec 1 an de plus que toi.... la question n'est pas là , mais apprendre l'anglais "que je rejette..." puis la programmation de A à Z pour modifier deux lignes de programme... pour moi, cela n'a vraiment aucun intérêt ...
Mon petit fils m'a dit : je n'ai pas besoins d'apprendre comment fonctionne tes algorithmes pour te faire un programme en Python...! Mais si il avait voulu regarder comment il fonctionne exactement , je doute fort que Yoshi se serrait autant emer.... pour ré écrire son programme Python...
Il y a même une personne qui nous a demandé pourquoi ne pas faire se programme en Asquel....soit disant plus efficace ..ok , il devait le faire... plus de nouvelles...
Tu me donnes des instructions ou des conseils , pour placer cette lignes
à la place des , push_back : . je comprend bien que cette ligne remplacera avec la même efficacité cette fonction :
plus rapidement sur une valeur limite fixée à n =9*10¹⁸ je n'en suis pas sûr , mais peut être un gain de quelques millisecondes ...
OR , tu sais très bien que si je fais ça , ça ne marche pas ...!
Car il y a sûrement autre chose que je dois faire dans cette fonction du programme ... non ? Tu vas me dire , ben oui , si tu avais appris l'informatique et l'anglais, tu connaîtrais la réponse ...
int main(int argc, char **argv)
{
vector<unsigned> temp; //on entre le début de la limite n à cribler et la fin augmenté de 15 ,pour cribler jusqu'à la limite n ou sa SQRT ligne 186
ulonglong debut = 3000000000001;
ulonglong fin = 3000000000016;
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;
}
[" Si tu dis à un ingénieur automobile, : tu sais ton moteur 4 temps avec une chaîne de distribution des soupapes .. etc ..etc , il fonctionnerait mieux et plus rapidement en régime, sans soupapes et sans chaîne de distribution, pour éviter le sur régime ou la rupture de la courroie de distribution d'où il résulte une casse moteur etc etc ..., Du fait que les soupapes et les pistons se percutent... Tu lui donnes même le fonctionnement et comment faire cette modification au niveau de la distribution...
Est ce que tu crois que ce serra suffisant ...? Qui est ce qui va recalculer les angles de distribution , etc etc ... car il faudra tout reprendre de A à Z y compris sur l'admission d'air afin de créer une turbulence pour un mélange gazeux optimum , ainsi que la sortie des gaz d'échappement...! " ]
On peut effectivement lui dire d'apprendre la mécanique de A à Z , depuis le temps qu'il tripatouille son moteur pour le rendre plus performant , mais sûrement pas quelque rudiments de mécanique ... Sinon tout le monde serait informaticien , Matheux , Metteur au point , Alpiniste ...et j'en passe ...etc etc
Je comprend ta proposition ... Mais apprendre des bouts de rudiment d'informatique pour un programme qui est plus que fonctionnel , très rapide etc etc ... il n'y a que l'esthétique , qui ne convient pas à un spécialiste en la matière. Ce n'est pas ma tasse de thé.
Je suis quand même curieux , de voir quelqu'un qui le modifie de A à Z , avec la possibilité d'imprimer le tableau criblé , comme on le fait en python , afin de vérifier le résultat pour la limite N que je lui assigne et sa rapidité.
Ce qui ne veut pas dire , que je doute que tu n'en soit pas capable... loin de moi cette idée ...
Mais personne ne l'a fait ! Y compris à l'UQAM de Montréal au Québec ... ou alors je ne suis pas au courant...
Même sans utiliser les congruences ... de 1 à N , mais de cribler jusqu'à la limite 2N ...etc etc ; en pensant que cela serrait plus rapide , plus simple, plus efficace ; Ce que certains ont essayés sur de petites valeur d'entrée n...!
#78 Re : Programmation » crible en python » 08-11-2024 08:48:51
Bonjour
@ DRStone ;
Pour moi, je ne vais pas à mon âge, apprendre à programmer ... je n'utilise que ces deux programmes python et C++ et rien d'autre .
comme tu l'as dit ils sont très fonctionnels ...
tu dis que .. c'est mieux if(p == UINT_MAX)
ok, mais il me faut tout remplacer , car remplacer uniquement cette ligne , rien ne fonctionne...
De même pour , cette fonction :
#include <climits>
#include <print>
int main() {
std::println("unsigned(-1)={}", unsigned(-1));
std::println("UINT_MAX={}", UINT_MAX);
}
Où est ce que je la place dans le programme ....? pour éditer le tableau du crible les [0,1,1,0,0,0,1,1,1,0,....etc limite], ...> n criblée par la fonction : size_T GCrible... Comme on le fait avec le programme python.
Pour cette remarque :
c'est pourquoi s'embêter à push_back chaque élément un à un alors même que la classe std::vector dispose d'un constructeur permettant d'automatiquement le peupler depuis un tableau passé en argument :
Je ne suis pas sûr de bien te comprendre , ou que tu ais bien compris le fonctionnement du programme, du criblage des différentes familles car :
Si tu ne rentre que cette fonction : std::vecteur<int> familles = { 7, 11, 13, 17, 19, 23, 29 }; ; à la place de push_back ;
comment tu choisis 3 familles ou 4 , à cribler les une après les autres, car tu n'as pas le choix ... en fonction de la forme de 2n qui est l'entier pair dont on "calcule" "crible" le nombre de décompositions remplacé par des [,1,] par rapport à la limite $n$ entrée ... qui conditionne par famille l'index unique de départ des nombres P qui vont cribler ,... Criblée par la fonction size-T GCrible
Dans le programme Python on a bien cette ligne en fin de programme :
## On crible
fam=19 ## ou 1, 7, 11, 13, 17, 19, 23, 29, au choix en fonction de n
Mais il ne crible qu'une famille , si je veux cribler les 3 familles $1,13,19$ par rapport à la limite $n = 15k +1$ par exemple $n = 301$ ;
donc $2n = 602 = 30k+2$ ;
Je les crible les unes après les autres , pour éviter de saturer la mémoire avec les trois tableaux du crible de Goldbach , alors que l'on utilise pour ces trois famille, uniquement le même tableau des nombres p' criblés par Ératosthène...
Ou alors comme en C++ on stock le résultat criblé par famille, puis on crible la deuxième , puis la troisième ...grâce à la fonction.. push_back..
Autrement dit , la fonction size-T GCrible, va utiliser pour les trois familles, le même tableau criblé par Ératosthène , et remplacer simplement les indexs de départ des mêmes nombres P qui vont cribler chacune de ces trois famille (1 ,13 , 19 ); le tableau criblé de départ , reste le même...
L'index de chaque famille est différent ..., Tu ne peux pas cribler avec [size-T GCrible..] , trois familles en même temps, pour une question, d'indexs , de limite et de mémoire... Et de toutes façon , je n'en vois pas du tout l'intérêt , car chaque famille a ses propres index uniques par famille $30k+i$
Le fait d'utiliser les congruences pour le crible de Goldbach [size-T GCrible..], cela évite pour une même limite $n$ de chercher le complémentaire $q\in[n;2n]$ premiers par rapport à l'entier pair $2n$ ...etc.
Je te laisse la main et je te remercie pour ton dévouement...
#79 Re : Programmation » crible en python » 07-11-2024 09:03:25
Bonjour mon cher ami DrStone:
1) comme tu t'en doutes je ne suis, absolument pas programmeur ni informaticien...
2) À l'origine c'est le programme Python ci dessus au post #411 , qui a été retranscrit rapidement en C++ , Par Mr B Parisse , chercheur à l'université de Grenoble... personne ne voulait le retranscrire ... Donc je suppose que pour toi, qui est de bons conseils qu'il te serait plus facile, de partir de ce programme python ...? au lieu de chercher à le comprendre ...non ?
Ensuite ce programme C++ , a été repris et légèrement modifié par un informaticien qui travaille à sophia antipolis 06 . ("il ne m'a rien signalé, si ce n'est qu'il a supprimé et modifié des lignes qui ne servaient à rien ou inutiles... je suis sous linux mint et j'utilise Code::Block)
information système :
Linux mint 20 Cinnamon version 4,6,7
noyau linux 5,4,0-200-generic
intel © CoreTM I7-4790CPU @3,60GHz*4
Mémoire vive 15,5 GO
Je suppose que tu as dû l'essayer , et tu peux te rendre compte qu'il fonctionne parfaitement bien et très rapidement en utilisant les deux programmes Python et C++ pour Vérifier les résultats ...
Donc suivant tes compétences et tes remarques que je ne met pas en doutes , peux tu le modifier ..., le tester afin ... d'être sûr qu'il n'y a pas d'erreur, et qu'il atteint les mêmes limites $n$ fixées, et tu pourras comparer la vitesse d'exécution ...
pourquoi // famille .push_back(1)
Cela veut dire que l'on va cribler la famille des entiers de la forme $30k +i$ où $i =1$ dans ce cas précis , $(1,31,61,91,...etc < n )$ sinon 7 ou 11 modulo 30...etc.
il y a 8 familles d'entiers $30k+i$ , représenté par des $[1,1,1.....]$ que l'on va cribler :
pour Ératosthène
1 = p' ; sinon: 0 = produit .
Pour Goldbach :
$1 = p'\not\equiv{2n}[p]$ ... avec P les premiers d'Érastothène qui ont été criblés et rappelés dans la première partie...
sinon
$0 = 1\equiv{2n}[p]$ ....
vector<int> familles;
//familles.push_back(1);
familles.push_back(7);
familles.push_back(11);
Au cas où il te faut des explications pour le fonctionnement de certains passages , ce que fait le programme , je pourrai te l'expliquer avec l'aide de notre Ami Yoshi ... si il peut se dévouer encore un peu... je lui en ai tellement demandé sur ce sujet depuis des années, comme tu peux t'en rendre compte...
Actuellement le programme est paramétré pour ne cribler que jusqu'à la racine carrée, le tableau des nombres premiers d'Ératosthène sinon on crible entièrement en modifiant en fin de programme la ligne :
size_t lencrible = sqrt(limite)/30; // attention on crible les p'non congrus 2N[P] < ou = à racine de la limite n fixée
size_t lencrible = limite/30; // attention on crible les p'non congrus 2N[P] jusqu'à la limite fixée. Maximum n = 9000 000 000 000.
Dans la première partie du Programme, on a besoin d'extraire les nombres premiers P > 5 et $\leqslant\sqrt{2n}$ ; afin de les utiliser pour cribler jusquà la limite $n$ fixée :
Aussi bien pour LE TABLEAU D' ÉRATOTHÈNE, ici dans cette fonction : [ size_t ECrible ....] ; QUE L'ON VA RÉUTILISER UNE FOIS CRIBLÉ :
Dans GOLDBACH ici dans cette fonction [size_t GCrible ....]
À moins que tu préfères, que l'on ouvre un autre sujet intitulé : programme en "C++" de notre ami LEG, où on mettra les deux programmes Python et C++ , si tu es intéressé pour refaire le programme C++....
Afin d'éviter de ne critiquer que le travail effectué par d'autres , il y a quelque temps et qui ne peuvent intervenir sur ce fil... ...non ?
Alors cordialement ..Leg .
#80 Re : Programmation » crible en python » 04-11-2024 06:40:27
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 ...
#81 Re : Programmation » crible en python » 03-11-2024 05:17:00
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
import math
def candidats(n):
start_crible = time()
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
print(f"Nombre premiers[3:] : {int((time()-start_crible)*100)/100}")
return premiers[3:]
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 = candidats(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 ...
@+
#82 Re : Programmation » crible en python » 02-11-2024 15:37:04
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}$
#83 Re : Programmation » crible en python » 02-11-2024 07:16:04
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 ??
#84 Re : Programmation » crible en python » 01-11-2024 14:34:05
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$
@
#85 Re : Programmation » crible en python » 01-11-2024 05:35:55
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 / 6000000, 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 / 6000000, 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 = 10000000000000000024; // 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 = 10000000000000000039;
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...
@+
#86 Re : Programmation » crible en python » 31-10-2024 10:57:27
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 @+
#87 Re : Programmation » crible en python » 31-10-2024 09:33:44
Bonjour
je voudrais modifier uniquement la taille du tableau à cribler $(n//30)$...sans modifier le reste uniquement le nombre de cellules marquées $1$ , inférieur à $n$ diviser par 30, réduire cette taille du tableau à la racine carrée de $n$ : exemple $n = 3000 // 30$ donne 100 cellules à cribler , et racine de $3000 // 30 = 54$ cellules à cribler., de sorte que pour une valeur $n = 10^{10} = 10 000 000 000$ je n'aurait que $\sqrt{10^{10}} = 100 000$ cellules à cribler.
je n'ai pas trouver quel paramètre modifier dans la ligne ou les lignes du programme posté ci-dessous # (ok , j'ai trouvé)
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
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
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")
En exemple pour la valeur limite de $n = 3000$ , soit 100 + 1 cellules à cribler :
résultat : crible Ératosthène : [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1]
Nombre premiers criblés famille 1 : 8 ----- 0.0
crible É ET G: [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1]
Nombres P' non congru 2n[pi] ou couple P'+q = 2N, de (i) à 3000 famille 1 : 20 ----- 0.0
et pour (racine de 3000) //30 = 1,8... cellule à criblée pour de petites valeurs , c'est inutile bien sûr...
je pense que c'est dans cette partie qu'il faut rentrer la racine de (n //30 +1) ,
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)
j'ai modifié .... ça marche , ...
c'est pour cribler de grande valeur $> 10^{10}$ afin de réduire le temps et la mémoire prise par le tableau . Il est clair que le resta du programme ne changera pas , car il nous faut toujours les nombre premiers $P\leqslant\sqrt{n}\;ou\;2n$ pour cribler...
#88 Café mathématique » Nombre de Mersenne » 24-10-2024 12:25:45
- LEG
- Réponses : 0
Bonjour
jmessage supprimé
#89 Re : Programmation » Cadran et fonctions trigonométriques » 23-09-2024 06:45:06
Re,
J'ai fait l'essai en éloignant les 2 cercles intérieurs afin qu'ils ne soient plus tangents, mais je les ai maintenus tous deux tangents au grand cercle avec leurs centres sur le grand cercle intérieur, avec des rayons de même valeur: ça marche !
Oui tu as raison,, le fait qu'ils ne soient tangents qu'au grand cercle et un même rayon , ils peuvent orbiter et garder leur positions relative l'un par rapport à l'autre.
""On peut même voir en exemple, si le grand cercle tourne , il entraîne les deux cercles intérieur qui peuvent tourner sur eux même et orbiter...""
Ensuite, il manque effectivement des précisions ....
#90 Re : Programmation » Cadran et fonctions trigonométriques » 21-09-2024 08:28:26
Bonjour YOSHI
Je viens de regarder tes deux cercles de centre 01 et 02 , ils ne peuvent " orbiter " tourner... car ils sont tangents bord à bord entre eux et avec le cercle .
Je suppose que c'est pour cela que Fred , ne les a pas mis bord à bord... Chaque cercle qui tourne dans un sens entraîne l'autre dans l'autre sens et comme ils sont bord à bord tous les trois, ils se bloquent ...
En gardant l'image de Fred, et la position relative qu'ils ont entre eux et par rapport au cercle 1 de la montre , il faut créer un cercle de centre 04 tangent aux trois cercles , de sorte que lorsque tu fais " orbiter " tourner un cercle, tu entraînes tous les autres en gardant leur position relative ...
Ex : tu fais tourner le cercle 02 dans le sens des aiguilles d'une montre, cela va entraîner le cercle de centre 04 et donc le grand cercle 1 dans le sens contraire et entraînera aussi le cercle 03 dans le même sens que le 02 , en gardant leur position relative ...
C'est pour cela que j'ai pensé à un engrenage... (plutôt qu'à une force gravitationnelle qui entraînerait l'ensemble (1, 02 et 03)
Si ..... c'est ce que veut Fred. ""en parlant de faire orbiter"" ?
#91 Re : Programmation » Cadran et fonctions trigonométriques » 20-09-2024 08:30:45
Bonjour
Cela fait penser à un engrenage , donc je suppose qu'il faudrait créer un quatrième qui prend le cercle 2 et 3 , en s'appuyant sur le cercle 1 de la montre ...
je laisse le soins à notre ami Yoshi , pour définir la formule mathématique....
Bonne journée à tous
#92 Re : Café mathématique » Quel est la formule mathématique pour un calcul simple » 14-06-2024 08:24:56
Et si on n'est pas fumeur ?? On a pas de mégots ..non ?
#93 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Conjecture de Goldbach vraie ou indécidable ? » 25-05-2024 07:46:29
Bonjour ,
En définitive comme cela vient d'être dit, tu ne fais que reprendre la conjecture de Goldbach sans rien prouver.
Le but de cette conjecture pour tout entier naturel $n$ est de montrer que tout entiers positif 2n , tel que $2n\geqslant {6}$ peut s'écrire comme la somme de deux nombres premiers, quelque soit $2n$.
Or tu dis , que tout $2n$ peut s'écrire ...etc... ben oui, mais il faut le prouver ; et non pas dire simplement il existe deux nombre premiers ,... Pour Tout $2n$ ???
J'ai un peu modifié mes fichiers depuis le temps, car ceux qui étaient joints au dessus, étaient mal expliqués ... Çela te donnera une idée ...
En définitive , quelque soit un entier positif $2n>4$ dont tu vérifies le nombre de décompositions tel que $2n=P+q$ deux nombres premiers impairs $>5$ , ("on écarte ces trois nombres premiers $P<7$ sans perte de généralité") il est impossible alors, de dire que $2n+2$ ne serait pas la somme de deux nombres premiers $(P+q)$.
Car pour chaque limite $n$ que tu as criblé , afin de déterminer le nombre de décomposition de $2n$ en somme de deux premiers; tu as en même temps le nombre de décompositions pour la limite suivante $n+1$ donc pour $2n+2=P+q$ .
C'est à dire, environ le nombre minimum de décompositions de $2n+2$ , par le décalage d'un rang des congruences pour cette limite suivante, donc le nombre de décomposition de $2n+2$ $ ("propriété de l'algorithme de Goldbach"), sans avoir besoins de cribler .
On peut d'ailleurs "cribler " jusqu'à la $\sqrt{n}$ avec $n\geqslant{3000000}$ afin de vérifier la conjecture , par famille $30k+i$.
Et on pourra constater que le nombre de solutions pour un entier $2n$ est oscillatoire par famille $30k+i$ lorsque la limite $n$ tend vers l'infinie par pas de$15$ propriété de l'algorithme de Goldbach qui utilise les congruences, d'où le décalage d'un rang lorsque $n$ augment te 1 ou de 15 , en fonction de la méthode de criblage...etc...etc
C'est ce qui est expliqué est montré dans ces deux fichiers ..., notamment le dernier ci-dessous avec le programme en c++
#94 Re : Café mathématique » Combien de temps puis-je voir un détail au sol du hublot d'un avion ? » 23-05-2024 08:29:32
Et si il pleut et qu'il y a des nuages ...?
#95 Re : Entraide (collège-lycée) » devoir maison sur dérivation et exponentielle » 23-05-2024 08:24:53
Il n'y a pas que dans cette matière que tu as du retard... ! Déjà en faisant toi même tes DM tu rattraperas ce retard en Math ou autre !
#96 Re : Programmation » Demande de démonstration sur une formule de recherche fonctionnelle » 01-04-2024 09:03:56
Bonjour
@Grifix :Tu as dit avoir introduit une limite à 4 Milliards....... tres dur question mémoire non?
Pas du tout avec un PC et le programme en C++ , j'ai poussé jusqu'à la limite $n$ = 18000 000 000 000 , mais par famille $30k+ i$ avec $i\in(1,7,11,13,17,19,23,29)$, bien entendu on donne uniquement par famille, le nombre de $NP$ inférieur à $n$
Effectivement , dans l'absolu on est obligé d'utiliser Ératosthène pour être sûr à 100% . Il n'existe aucune solution pour obtenir la réponse ultra rapide afin de déterminer la primalité d"un très grand entier naturel $n$ positif, lorsque $n$ tend vers l'infini.
Le fait de rechercher une amélioration des algorithmes de recherche de grand $NP$ , c'est pour entre autre, trouver des méthodes , pour la cryptographie...etc etc , d"ailleurs même la conjecture de Riemann , n'apporterai rien sur la répartition des nombres premiers, juste une meilleur estimation ... mais les moyens utilisés pour la démontrer pourrait être "" intéressants "".... etc
Ce n'est que l'avis d'un amateur, n'étant absolument pas "Matheux" , je m'arrête à l'arithmétique élémentaire tout simplement ...
Bonne journée.
#97 Re : Programmation » Demande de démonstration sur une formule de recherche fonctionnelle » 31-03-2024 17:17:36
j'ai utilisé ton premier programme en début du sujet jusqu'à n = 15 000 000 ... Car le lien du serveur ci-dessus , lorsque je rentre 200 il m'indique arrêt ...etc , mais ce n'est pas grave ... Bonne continuation ...
PS , Si cela t'intéresses : Tu peux regarder sur la page 2 de ce forum , (Crible en Python LEG) ,les algorithmes que j'ai fait et que Yoshi à eut la gentillesse de me faire les programmes... Je ne suis absolument pas programmeur ... (tu vas directement sur la page 16)... il y en a aussi en C++.
#98 Re : Programmation » Demande de démonstration sur une formule de recherche fonctionnelle » 31-03-2024 15:36:09
Re @Grifix
j
je viens d'essayer de copier /coller ton programme dans Code::bloc , que j'utilise pour mon programme ÉRATOSTHÈNE en C++ ,
pour comparer le temps d'exécution, avec celui que j'utilise...
il ne me sort aucun résultat , sauf
oui = 1 non = 0:
"" c'est peut être pas le bon répertoire ""
j'ai rentré la limite n = 4000000000 ...
#99 Re : Programmation » Demande de démonstration sur une formule de recherche fonctionnelle » 31-03-2024 09:34:29
Bonjour
Si le début du sujet avait pour but, d'extraire les nombres premiers $NP$ inférieur à une limite $n$ fixée à partir de tes multiples impairs , je ne pense pas qu'il y est une part de rêve ...
Tous les cribles élémentaires, sont basés sur le principe du crible d'Ératosthène...
Il y en a de très simples et moins lourd que ce que tu proposes ...
C'est pour cela que pour un grand $NP$ probable , il y a des algorithmes Probabilistes et ensuite pour être rigoureusement sûr à cent pour cent , il n'y a pas d'autres choix que de tester ce $NP$ avec tous les $NP\leqslant\sqrt{NP}$ . (Par exemple: les nombre de Mersenne ou Wagstaff...etc)
#100 Re : Café mathématique » Problème d'heure sur Bibm@th » 01-12-2023 07:25:25
Bonjour
Salut@Fred ; je vois que l'on est pas repassé à l'heure d'hiver je viens de poster à 7h25 et ça indique 1h de plus