Forum de mathématiques - Bibm@th.net
Vous n'êtes pas identifié(e).
- Contributions : Récentes | Sans réponse
#201 Re : Café mathématique » Configuration possible d'un dé a 100 face opposé » 05-02-2021 15:11:12
re
Merci @Yoshi pour tes recommandations... pour le C++, mon petit fils va voir à l'UQUAM de Montréal....
Mais notre ami de100 n'a pas répondu que fait il avec la Dame en H8, à part se sauver avec son roi ...le mieux en G6...ou autre. ?
ce qui va entraîner le pion blanc F2 en F3 afin d'aller manger le pion noir....et ensuite....il ne restera plus grand chose à faire
#202 Re : Café mathématique » Configuration possible d'un dé a 100 face opposé » 05-02-2021 10:49:12
Bonjour
il ne peut que retarder l'inéluctable...la dame mange la tour , et ensuite sauve qui peux pour les noirs mais la partie est perdue...
#203 Re : Programmation » Programmes sous linux debian » 17-01-2021 10:02:31
Bonjour à tous
Je reviens sur la question de @Yoshi :
Et ton programme en Python sous linux mint a-t-il une limite inférieure à celle qu'il avait sous Windows 10 ?
la limite du programme en Python sous linux mint est la même que sous Windows 10 , pour une simple raison le programme ci dessus en python:
pour une limite n = 60 000 000 000 il a besoin de toute la mémoire physique de la ram dans mon cas des 16 GO et il plante au bout d'un temps très long...
Mons problème pour les deux programmes en C++ , venait d'un défaut de paramétrage de la mémoire sous linux qu'il fallait modifier allouer à la mémoire ram 32000 pour le partage des fichiers Swap au lieu de 2000 fixé par défaut
Pour les deux programmes en C++ il prend facilement " en 1300 secondes, la limite N = 9 000 000 000 000 " et plus rapide que sous Windows 10 en utilisant 90% du fichier d'échange et 99,8 % de la ram.
Alors que le programme en Python ci -dessus pour N = 60 000 000 000, soit plus de cent fois moins, il utilise que 3% du fichier d'échange mais 99.9 % de la rame .
et il rame...
Je suppose que cela vient de Python qui ne compile pas ... ou autre ...
Donc il ne me reste plus qu'à le faire retranscrire en C++ comme les deux premiers... Ou coller les deux programmes C++ au bon endroit , comme cela a été fait avec l'unification des deux prog python:
Crible EG
1) supprimer la fin d'Ératosthène, et rappeler le tableau criblé,
2) supprimer le début de Goldbach en utilisant le tableau criblé d'Ératosthène
puis continuer à partir de ces lignes .... en principe...
ulonglong p=premiers['i'];
ulonglong reste=n2 % p;
et à la fin modifier la ligne de rappel du crible Gcrible qui deviendrait EGcrible .... EGCrible(premiers,N,fam);
En appelant directement au début d'Ératosthène les nombres premiers Inférieur à racine de 2N , que la fonction de Goldbach utilisera , pour cribler le tableau d'Ératosthène , ça ne génère pas de perte de temps dans la partie d'Ératosthène...qui n'a besoin que des nombres premiers inférieur à racine de N pour cribler son tableau ...
#204 Re : Programmation » Programmes sous linux debian » 03-01-2021 10:57:48
re suite:
Goldbach C++: (" qu'il faudrait fusionner à la suite d'Eratosthène, c'est à dire utiliser le tableau d'Eratosthène criblé, puis repris par le crible G, pour le re-cribler comme tu l'as fait sous Python ")
Goldbach crible_EG_2N_modulo30:
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_list =[2,3]
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_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:]
def E_Crible(premiers, n, fam):
# On génère un tableau de N/30 cases rempli de 1
lencrible = ((n//30)+1)
crible=[1 for _ 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
return crible,lencrible
def GCrible_2N(premiers, crible, lencrible, n, fam):
start_crible = time()
# On calcule les restes: ri = 2*n/pi
nbpremiers = len(premiers)
n2 = 2*n
for premier in premiers:
reste = n2 % premier
#print(reste)
if reste % 2 == 0:
reste += premier
pi2 = 2*premier
# tant que reste % 30 != fam on fait reste += pi2
while reste % 30 != fam:
reste += pi2
# Ensuite on divise reste par 30 pour obtenir l'index
reste //= 30
# On crible directement avec l'index
for index in range(reste, lencrible, premier):
crible[index] = 0
total = sum(crible)
# print("crible:", crible)
print(f"Nombres non congru 2n[pi] ou couple p+q = 2N, de {7} à {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 à √N
premiers = eratostene(n)
start_time = time()
# On crible
fam=7 # ou 1, 7, 11, 13, 17, 19, 23, 29, au choix
crible,lencrible=E_Crible(premiers, n, fam)
GCrible_2N(premiers, crible, lencrible, n, fam)
main()
system("pause")
-------------------------------------------------------------------------------------------------------------------
Goldbach_C++
// -*- 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 GCrible(const vector<ulonglong> & premiers,ulonglong n,int fam){
int cl=clock();
size_t lencrible=n/30,nbpremiers=premiers.size();
vector<bool> crible(lencrible,true);
ulonglong n2=2*n;
vector<ulonglong> indices(nbpremiers);
for (size_t i=0;i<nbpremiers;++i){
ulonglong p=premiers[i];
ulonglong reste=n2 % p;
if (reste %2==0)
reste += p;
ulonglong pi2=2*p;
while (reste %30!=fam)
reste += pi2;
reste /= 30;
indices[i]=reste;
}
ulonglong nslices=lencrible/1500000,currentslice=0;
if (nslices==0) nslices=1;
for (;currentslice<nslices;++currentslice){
size_t slicelimit=currentslice+1;
slicelimit=slicelimit==nslices?lencrible:(currentslice+1)*(lencrible/nslices);
for (size_t i=0;i<nbpremiers;++i){
ulonglong p=premiers[i];
size_t index;
for (index=indices[i];index<slicelimit;index+=p)
crible[index]=0;
indices[i]=index;
}
}
size_t total=0;
for (size_t index=0;index<lencrible;++index)
total += int(crible[index]);
cout << "Nombre premiers criblés famille " << fam << " entre "<< n << " et " << n2 <<": " << total << " time " << (clock()-cl)*1e-6<< endl;
return total;
}
int main(int argc,char ** argv){
vector<unsigned> crible;
ulonglong N;
int fam=1;
if (argc>1){
N=atoll(argv[1]);
if (argc>2)
fam=atoi(argv[2]);
}
else {
cout << "Syntaxe " << argv[0] << " N fam. Donnez N puis fam: " ;
cin >> N;
cin >> fam;
}
double sqrt2N=unsigned(std::sqrt(2*double(N)));
fill_crible(crible,sqrt2N);
vector<ulonglong> premiers;
for (ulonglong p=7;p<=sqrt2N;){
premiers.push_back(p);
p=nextprime(crible,p);
if (p==unsigned(-1))
break;
}
GCrible(premiers,N,fam);
cin>>N;
}
j'ai la version code::blocks :
relesase 20.03 rev 1197 (2020-03-28) gcc 9.3.0 linux/unicode - 64 bit
#205 Re : Programmation » Programmes sous linux debian » 03-01-2021 10:46:45
Bonjour
Re@Yoshi
tu m'avais demandé en mars 2020 :
Les deux morceaux de Python que j'ai fusionnés, et qui ont été traduits en C++ sont-ils dispos sous forme compilée ou leur code source en clair est-il disponible ?
Si le code source (les instructions) sont en clair, j'ai quelques notions de C++, je peux peut-être retenter la fusion des deux codes sources C++...
je joins ci dessous les deux codes source en C++ de la retranscription de tes deux programmes Python. Si tu peux les fusionner , ou encore Utiliser le lien que tu m'avais indiquer en Cython : HTTP://cython.org , pour retranscrire le programme python Crible_EG2_modulo30.py .
Note pour info: tu verras à la ligne 75 il utilise les slices tableau de 1500000 , (ce qui permet d'aller plus vite et plus loin...sous Wind 10 limite maxi 8200 000 000 000)
Eratosthène c++
// -*- compile-command: "/usr/bin/g++ -g goldbache.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){
int cl=clock();
size_t lencrible=n/30,nbpremiers=premiers.size();
vector<bool> crible(lencrible,true);
// 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};
for (size_t j=0;j<sizeof(GM)/sizeof(int);j++){
produit = p*GM[j];
if (produit %30==fam){
produit /= 30;
break;
}
}
indices[i]=produit;
}
ulonglong nslices=lencrible/1500000,currentslice=0;
if (nslices==0) nslices=1;
for (;currentslice<nslices;++currentslice){
size_t slicelimit=currentslice+1;
slicelimit=slicelimit==nslices?lencrible:(currentslice+1)*(lencrible/nslices);
for (size_t i=0;i<nbpremiers;++i){
ulonglong p=premiers[i];
size_t index;
for (index=indices[i];index<slicelimit;index+=p)
crible[index]=0;
indices[i]=index;
}
}
size_t total=0;
for (size_t index=0;index<lencrible;++index)
total += int(crible[index]);
cout << "Nombre premiers criblés famille " << fam << " plus petits que "<< n <<": " << total << " time " << (clock()-cl)*1e-6<< endl;
return total;
}
int main(int argc,char ** argv){
vector<unsigned> crible;
ulonglong N;
int fam=1;
if (argc>1){
N=atoll(argv[1]);
if (argc>2)
fam=atoi(argv[2]);
}
else {
cout << "Syntaxe " << argv[0] << " N fam. Donnez N puis fam: ";
cin >> N;
cin >> fam;
}
double sqrtN=unsigned(std::sqrt(double(N)));
fill_crible(crible,sqrtN);
vector<ulonglong> premiers;
for (ulonglong p=7;p<=sqrtN;){
premiers.push_back(p);
p=nextprime(crible,p);
if (p==unsigned(-1))
break;
}
ECrible(premiers,N,fam);
cin>>N;
}
@+ ( je met le deuxième code Goldbach C++ ; dans le post suivant , avec le code python Crible_EG2_modulo30.py)
#206 Re : Programmation » Programmes sous linux debian » 02-01-2021 15:53:42
premier teste :
Python 3.9.0+ (default, Oct 20 2020, 08:43:38)
[GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license()" for more information.
>>> Crible_E
============= RESTART: /home/gilbert/Programmes/Crible_EG2_mod30.py ============
Donnez n: 60000000000
Nombres P' non congruent à [pi] de 1 à 60 000 000 000 famille 7, nombr de couples p+q=2n: 44 070 802 ----- 692.88
>>>
-----------------------------------------------------------------------------------------------
ton programme Python crible_Gty_mod30 retranscrit en C++:
En C++ nombres premiers q Famille 7 de 3600 000 000 000 à 7200 000 000 000 15 359 961 998 en 377,21 secondes
--------------------------------------------------------------------------------------------------
Même programme Crible_Gty_mod30 même Famille mais : limite n = 60 000 000 000
en Python :
========== RESTART: /home/gilbert/Programmes/Crible_G.T.Y_modulo30.py ==========
Donnez N: 60000000000
Nombres non congru 2n[pi] 1 à 60000000000 famille 7 premiers de 60 000 000 000 à 120 000 000 000: 297587841 ----- 336.06
--- Temps total: 339.12 sec ---
>>>
voila .
#207 Re : Programmation » Programmes sous linux debian » 02-01-2021 15:31:15
Bonjour @Yoshi
Tu as raison pour l'exécutable .exe , ils sont dans mon cas avec code::blocks en .cpp ils étaient en .exe sous Win 10 .
Donc il m'a fallut prendre les scripts , copier dans la console Code::block , recompiler avec build, nouveau project ...etc
Puis je lance le programme avec l'icone [Buid /Run] , ma fenêtre dos s'ouvre normalement je rentre ma valeur n et la Famille correspondante par exemple 7.
Tout fonctionne parfaitement mais jusqu'à 4 050 000 000 000 en 691 secondes. Même plus rapide qu'avec Wind 10 .
Le Hic je ne peut pas dépasser la limite n = 4200 Go...???
Alors qu'avec Wind 10 sans problème jusqu'à 8 200 000 000 000 en gros le double...
Il semblerait qu'il faille augmenter la mémoire virtuelle ou les fichier swap ,,?? lorsque la mémoire vive est atteinte aux environs de 90% mais je n'y comprend strictement rien...
En python par exemple il va aussi vite même un peu plus que sous Win pour la même limite n = 60 000 000 000 ensuite sous win il n'allait pas plus loin dans un temps rapide par exemple sous Win pour 60 000 000 000 il mettait environ 691 secondes et des que python saturait 72 000 000 000 il swapper sur le disque et il mettait 10 fois plus de temps et sous linux il bug.
je vais t'afficher le résultat sous linux pour n = 60 000 000 000 et + avec le programme que tu as fait : Crible_EG2_mod 30.py
Voila...
#208 Programmation » Programmes sous linux debian » 02-01-2021 14:42:19
- LEG
- Réponses : 8
Bonjour
Je viens de remplacer l' OS de mon Pc Windows 10 , pour passer sous linux.mint.20
Système : Memore 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 sur ce Forum et retranscrit en C++ par la suite ) fonctionne beaucoup moins loin que sous Windows 10 ?
sous Windows 10 ma limite $n$ était de 8250 000 000 000 en 1400 secondes . Or sous linux mon programme s'arrête pour la limite $n = 4200 000 000 000$
Il 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 ...?
Merci pour tous renseignements.
#209 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » répartition aléatoire des nombres premiers » 02-01-2021 09:35:11
Bonjour et meilleurs voeux à toute l'équipe de ce Site et que 2021 se finisse mieux que 2020 avec une pandémie enrayée...Bonne santé à tous ,
@Yoshi : merci pour ta contribution pour le Forum de programmation
Amitiés LEG
#210 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Une échelle de nombres » 29-11-2020 13:26:06
@48P le Grand : moi aussi au début j'ai pensé à 15 le chiffre manquant; mais quand même 13+7 = 20 et non 21...
#211 Re : Café mathématique » Nouvelle logique pour calculer les nombres premiers » 26-11-2020 18:09:49
Bonsoir à tous
@Yoshi je pense que pour l'optimiser il faut déjà éliminer les multiples de 2,3,et 5 travailler avec les entiers des 8 famille 30k + i , avec appartenant à (1,7,11,13,17,19,23,29) ce qui supprime 73,666....% des entiers naturels
Ce qui donne:
[ 1 , 7 , 11 , 13 , 17 , 19 , 23 , 29 ]
[ 31 ,37, 41 , 43 , 47 , 49 , 53 , 59 ]
etc...
@Omhaf.
peux tu donc essayer avec ta programmation... voire le temps que cela donne ; Sinon en python par Yoshi...
car regarde ce que donne mon algorithme écrit par Yoshi en Python :
pout N 1000 020; avec la Fam 3k + 7
===== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ Era_gty_mod30.py ====
Donnez N: 1000020
Nombre premiers criblés famille 7 : 9812 ----- 0.0
--- Temps total: 0.01 sec ---
Donc tu vois pour les 8 familles cela donne 0,01 seconde * 8 = 0,08 secondes ....
Donnez N: 1000020
Nombre premiers criblés famille 1 : 9807 ----- 0.0
--- Temps total: 0.01 sec ---
>>>
Donnez N: 1000020
Nombre premiers criblés famille 11 : 9810 ----- 0.0
--- Temps total: 0.01 sec ---
Donnez N: 1000020
Nombre premiers criblés famille 13 : 9826 ----- 0.01
--- Temps total: 0.01 sec ---
passons à n = 100 000 020
===== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ Era_gty_mod30.py ====
Donnez N: 100000020
Nombre premiers criblés famille 7 : 720270 ----- 0.4
--- Temps total: 0.4 sec ---
soit pour les 8 familles : 3,2 secondes... en Python .
De plus tu va très vite saturer ta mémoire si tu dois écrire tous les nombres pour les tester au lieu de sauter par pas de P ("un nombres premiers, inferieur à racine de N") à partir de l'index du produit etc...
C'est peut être originale comme le dit Yoshi....(d'utiliser modulo 12) mais cela n'apportera rien de nouveau dans le criblage des nombres premiers.
#212 Enigmes, casse-têtes, curiosités et autres bizarreries » répartition aléatoire des nombres premiers » 10-11-2020 09:13:47
- LEG
- Réponses : 2
Bonjour
Souvent on pense que la répartition des nombres premiers est aléatoire, car on ne peut pas définir exactement leur position dans un ensemble d'entiers naturels ou lorsque l'on tire au hasard un entier naturel sans savoir si il va être premier ou pas...
Je pense que dans ce contexte c'est l'action de choisir qui est aléatoire.
Car curieusement lorsque l'on fixe une limite 2n , par exemple 300 ou plus , afin de visualiser ce qui se passe réellement dans la répartition des nombres premiers, on peut montrer que cette répartition n'a absolument rien d'aléatoire.
La conjecture de Goldbach m'a permis de faire ressortir cette propriété étonnante ... Grâce au programme de l'algorithme ( Yoshi ).
le calcul des indices des restes de $2n$ Par $P$ avec $P\leqslant\sqrt(2n)$ qui vont permettre d'extraire les entiers A de 1 à n tel que $A\not\equiv{2n}[P]$ qui impliquent les nombres premiers $q\in[n ; 2n]$ dans une suite d'entiers positifs $A$ , en progression arithmétique de raison 30, n'ont absolument rien d'aléatoire !
En effet : pour $2n = 600$ la racine de 600 est < 24 ; donc les nombres premiers > 5 sont : $7,11,13,17,19,23,29$ ils ne sont pas pris au hasard , mais dans leur ordre naturels. Si on calcule leurs restes $R$ de $600$ par $P$ on obtient les $R : 5,6,2,5,11,2$.
En augmentant 2n + 30 = 630 : il est évident que les $R$ vont changer , par contre on aura le même nombre de nombres premiers $P\leqslant\sqrt(630)$ ; on pourrait penser au vu des $R$ calculés, que c'est aléatoire, les nouveaux $R = 0,3,6,1,3,9$.
Il n'en est rient ! Pourquoi ...?
Le calcule des $indices$ qui vont permettre de cribler ie: les entiers $A\equiv{2n}[P]$ de 1 à n , afin d'extraire les nombre premiers $q$ de 300 à 600, de raison $P$.
Par exemple, pour la famille 7 modulo 30 ou $30k + 7$ se calcule de la façon suivante ("car on veut connaître les entiers $A\not\equiv{2n}[P]$ afin d'extraire les premiers de 300 à 600 en progression arithmétique de raison 30; et ce : quelque soit l'une des 8 familles 30k + i, avec $i \in(1,7,11,13,17,19,23)$ on va donc cribler les entiers $A =30k +7$ congruent à P, pour obtenir les nombres premiers $q$ de sa Famille complémentaire les $30k + 23\in{[300;600]}$ ")
On part donc de $R=2n / P$ puis on ajoute $P$ jusqu'à ce que $(R + kP) = j$ soit égal à 30k+7, c'est à dire : j %30 == 7 , ensuite on calcule cet index idx : $j // 30 = idx$. Puis suivant le principe d'Ératosthène mais dans les congruences, on marque par pas de $P$ les entiers $A\equiv{2n} [P]$. ("@Yoshi me corrigera si mon explication n'est pas bonne, car il connait parfaitement son programme")
Jusque là , rien d'anormal ou de curieux ...
Si on augmente $n$ de $15$ soit 315 donc $2n = 630$ curieusement les indices se décalent d'un rang , ce qui n'est pas le cas des nouveaux $R$ alors que les nombres premiers $P$ qui vont cribler cette nouvelle limite $n+15$, sont les mêmes et < 25 .
Pourquoi ces indices sont parfaitement ordonnés et ne se décalent que d'un rang lorsque la limite $n$ augmente de $15$, donc $2n$ augmente de $30$ ???
Peut on prouver que quelque soit la limite $n + 15$ cela sera toujours le cas ???
La réponse est oui. Car en effet, lorsque $n$ augmente de 15 pour la limite suivante, $2n$ augmente de 30 ; par conséquent quelque soit l'entier $A$ de 1 à $n$ congru ou pas modulo $P$ la différence avec $2n$ ne peut varier, c'est à dire $2n - A$ est équivalent à $(2n+30) - (A+30)$ d'où on aura obligatoirement un décalage d'un rang des congruences sur leur successeur $A'+30$ ce qui préserve toujours la même égalité pour la limite suivante $n = 15(k+1)$ le contraire serait absurde.
Et ce : quelque soit la Fam(i) fixée par à port à sa limite $n$, c'est à dire pour les 8 Fam(i) qui sont en progression arithmétique de raison 30.
On en déduit avec cette propriété que quelque soit la limite $n$ et la Fam(i) fixée où la conjecture ayant été vérifiée, il est impossible d'affirmer ou même de supposer que pour la limite $n=15(k+1) + i$ elle serait fausse, c'est à dire qu'il n'existerait pas de solution vérifiant la conjecture, car il faudrait pour cela 3 conditions impossibles à réaliser :
(" Il faudrait utiliser pour la limite suivante $15(k+1)+i$ les R précédents de la limite $15(k-1) + i$ et les nouveaux R de la limite en question ce qui est absurde, mais aussi qu'il n'y ait plus de nombres premiers p' de 1 à n consécutifs ou précédés d'un entier A non congru (mod P) tout autant absurde car on supposerait que l'égalité ci -dessous est fausse.")
On en déduit même, un nombre de solutions oscillatoires et non nulles, avec la fonction : $\frac{(Gn)}{Ln\:(Gn)}$ où $G(n)$ est le nombre d'entiers $A\not\equiv{2n}\;[P]$ correspondant aux nombres de nombres premiers $q\in\;[n ; 2n]$.
De façon générale et conséquence du TNP : le nombre de solutions qui décomposent 2n et 2n+2 en somme de deux nombres premiers, équivaut à :
$\frac{n}{(Ln\:n \;*\;Ln\;2n)}$ lorsque $n$ tend vers l'infini.
On peut même utiliser le résultat de la fonction $\pi(n)$ par Fam(i) donc avec la limite $n/30$ sans perte de généralité soit : $\frac{\pi(n)}{Ln\:n}$
Il vient que le nombre de solutions vérifiées pour une limite $n$ et sa Fam(i) fixée, correspond exactement à l'unité près, au nombre de solutions précédentes de la limite $n = 15(k-1) + i$ , c'est à dire le nombre de $A\not\equiv{2n}[P]$ qui précèdent un nombre premier $p'$ congru ou pas modulo $P$ avec $2n$.
On en déduit par conséquent un théorème de Goldbach : Pour une limite $n$ fixée : Tout entier $A$ impair non congru à $2n$ modulo $P$ qui précède un entier $A' = P'$ premier, décomposera $2n+2$ en somme de deux nombres premier $P'+ q$.
Ce qui est une conséquence de l'égalité ci-dessus, conforme au TFA (Théorème Fondamentale de L'Arithmétique) le contraire serait absurde ("un nombre premier ne peut se transformer en produit et inversement lorsque la limite $n$ augmente de 15 , et donc $2n$ augmente de 30 on en déduit d'ailleurs qu'un seul inconnu : le premier élément de la suite arithmétique des entiers A criblés.
#213 Re : Programmation » Dm de maths, programme python » 06-11-2020 16:00:16
Re @Yoshi tu as tout à fait raison , car effectivement je trouvais pour moi plus simple mais surement pas exact le fait d'interpréter les U(n) à toutes les sauce que ce soit pour les indices i , ou pour les j.
Mais si maintenant, tu les remplaces par LEG, là pour le coup ça devient comme moi : nul.... LoLL ; voila pourquoi il faut bien connaître les variables et ne pas confondre , ce qui la plupart du temps est mon cas , j'espère que les jeunes en prendront bonne note et qu'ils se conformeront à tes explications et non pas mes fantaisies non Mathématiques.
Cordialement
Gilbert@+
#214 Re : Programmation » Dm de maths, programme python » 06-11-2020 13:58:43
Bonjour
Je me suis amusé à essayer de compléter la question posée mais sans résultat ... Et pour cause
dans le deuxième return il faut impérativement mettre [3,1]
Afin qu'ensuite la fonction def u(n,L): récupère les résultats pour n == 0; n==1 , afin de calculer le résultat de n+1
puis compléter le programme après la troisième fonction return ...
"Où moi j'ai remplacé de partout les i et j par n qui est l'indice le Suite u(n)" Mais je suppose que ce n'est pas ce qu'il faut faire dans ce genre de question posé...ou en programmation "
def u(n,L):
if n==0:
return [3]
elif n==1:
return [3,1]
return L+[L[n-1]+2*L[n-2]]
S,n=[],20
for n in range(n):
S=u(n,S)
print("U"+str(n)+" =",S[n])
#215 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Un regalo per Al berto : una gara di lentezza ! » 27-10-2020 15:07:26
Et tu as raison, il ne me viendrait pas à l'idée d'aller chercher une vache pour avoir trois quotients entiers... d'autant qu'il faut ensuite la rapporter ...
C'est des comptes d'apothicaires .... autant je suis d'accord avec l'égalité des 3 fractions 1/2 , 1/3 , 1/9 = 9/18 , 6/18 , 2/18 =17/18
mais si on additionne les décimales des trois premières fractions avec la dernière on obtient effectivement 0.94444444444444444444444444
Mais celles du milieux on a 0 en reste , pas de morceaux de vache .... Comme quoi ma méthode non mathématique ... était bonne; en utilisant les trois parties entières du quotient et en donnant une vache à chacun, puisque il en restait trois et on a le même résultat sans découper une vache..
@+
#216 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Un regalo per Al berto : una gara di lentezza ! » 27-10-2020 12:39:21
A part dire que 17 n'est divisible en partie entière par 2, ni par 3 ni par 9 donc avec une vache en plus on a bien une moitié , un tier et un neuvième , puis on rend la vache au boucher ... Lolll
#217 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » Un regalo per Al berto : una gara di lentezza ! » 27-10-2020 10:34:22
Bonjour
la partie entière de 17 par 2,3 et 9 représente 14 vaches sur 17; donc on en donne une à chacun ce qui fait bien 9, 6 et 2 mais on a aussi $18\equiv{1}[17]$...
#218 Re : Enigmes, casse-têtes, curiosités et autres bizarreries » grille 3 par 3 » 22-10-2020 08:28:11
Bonjour
@Pierrelepetit
J'ai traduit en français "les cases sont numérotées de 1 à 9, quels nombres entiers peut-on mettre dans les cases ayant un numéro pair?"
Comment tu peux traduire en Français une phrase qui n'est pas du français selon tes dires...! Mais qui permet toutes les possibilités d'après l'auteur du sujet!
1) Où tu as vus dans l'énoncé que les cases été numérotés...?
2) quelle valeur peut prendre le nombre de cases pairs ? question : les cases numérotés avec un nombre pair, ou les cases contenant un nombre pair...? ou aucune , 0 ; mais zéro est pair alors on fait quoi ...?
3) Aucune indication n'est données , mais comme la question stipule que la somme de chaque colonne ou ligne doit être impaire; alors il peut très bien y avoir que des entiers impairs dans chaque cases ...! Mais lesquels ?
Donc où sont elles tes cases paires ? Celles que tu numérotes comme bon te semble, qu'avec des numéros pairs ?
Supposons que l'on veuille les numéroter ou les nommer avec des lettres etc... , ça ne prouvera rien ! On peut commencer par la case n° 0 ? n° 1 ? n° 10^100001 ?...etc uniquement avec des nombres impairs..., avec des lettres, avec des patates ou des navets...?
Il faut croire que tu donnes des réponses en fonction de tes envies, de tes idées... ou autres; aurais tu oubliés les bases de l'énoncé du sujet ...?
#219 Re : Café mathématique » Une formule pour trouver que des nombre premiers » 06-10-2020 14:05:45
Bonjour
C'est complètement incompréhensible....du début à la fin...
je te cite :[ Par exemple pour n=1721715 pour trouver que n=1721718] Et ben je rajoute 3....Tu plaisantes ou quoi...?
Qu'est-ce que sont tes vn...? car il est inutile de continuer à l'infini tes : Un=Vn=Dn=An=Bn=Cn=....= tartempion impair.
commence par montrer à partir de ta liste d'entiers naturels n : de 1 à 30 et montre clairement, comment tu calcules ou trouve tes 8 nombres premiers > 3.
#220 Re : Café mathématique » Génération des nombres premiers : algorithme » 28-09-2020 15:50:50
@48pierrelePetit
Cela semble donner une proportion moyenne de premiers 1 modulo 30 de 1/8, et aussi 1/8 pour les -1 modulo 30,
Merci à tous et bonne journée
C'est normale il y a 8 familles de nombre premier >5 , de la forme 30k + i
Et comme l'algorithme qui crible ses 8 familles avec le même nombre de nombre premiers P inférieur à racine de n, est le même; tu as par conséquent une densité moyenne de 1/8 par famille .
#221 Re : Café mathématique » Génération des nombres premiers : algorithme » 28-09-2020 14:30:25
Bonjour
===== RESTART: E:\Documents\Conjecture de Goldbach\Crible_ Era_gty_mod30.py ====
Donnez N: 16000000
Nombre premiers criblés famille 13 : 128937 ----- 0.07
--- Temps total: 0.09 sec ---
>>>
Ce programme @Yoshi, à la base il était était archaïque ...toi tu l'as refait entièrement à partir de l'algorithme ....
Tout comme celui que j'ai mis ci-dessus qui donne le nombre de couples P+q = 2n ...c'est quand même toi qui me l'a fait intégralement en python ...
En définitive ce qui est long c'est d'écrire tous les nombres premiers criblé < n fixé et non de calculer leur nombre .
Ensuite il est clair que certain algorithme et programme sont très rapide en fonction du langage, de la complexité de l'algorithme, du calculateur ou Pc utilisé..
ex : le 400 milliardième premier est : The 400,000,000,000th prime is 11,618,595,583,891; en moins de 1,5 secondes et je suppose qu'il y a plus rapide...
Bref disait moi et non Pépin ... @Wiwaxia ou 48PierrelePetit y'en a t'il un, pour retranscrire en C++ le crible en python que j'ai mis ci-dessous... si possible bien entendu...
Actuellement pour n = 16 000 000 000 il me donne :
======= RESTART: E:\Documents\Conjecture de Goldbach\Crible_EG2_mod30.py =======
Donnez n: 16000000060
Nombres P' non congruent à [pi] de 1 à 16000000060 famille 7, nombr de couples p+q=2n: 15 133 152 ----- 227.22 secondes
>>>
Donnez n: 16000000075
Nombres P' non congruent à [pi] de 1 à 16000000075 famille 7, nombr de couples p+q=2n: 14 349 243 ----- 211.01
Donnez n: 16000000090
Nombres P' non congruent à [pi] de 1 à 16000000090 famille 7, nombr de couples p+q=2n: 13 131 524 ----- 213.3
>>>
Avec les nombres premiers Pn et qn : Pn = 30k+7 et qn = 30k +13
En utilisant la fonction modifiée $\pi(n)$ pour le nombre de premiers 30k +7 et la constante des nombres premiers jumeaux $C_2$ :
Nombre de premiers $30k + 7 < 16000000030 = 89 101 240$
l'estimation me donne 6 426 691 couples qui représentent $2n = 32 000 000 060$ en somme de deux nombres premiers p+q .
Pratiquement la moitié du nombre réel de couples p+q ... Ce qui est quand même très curieux, car il suffit de multiplier par 2 le résultat de la fonction d'estimation pour obtenir une moyenne générale ...
La fonction est : pour un nombre de nombre premiers de la forme de $30k + i$ ; $i\in(1,7,11,13,17,19,23,29)$ et une limite fixée : $n = 15k + i$
$\frac{\pi(n)}{ln\:(\pi(n))}$ sachant aussi que cette fonction indiquera le nombre de couples qui représenteront la limite suivante 2n + 30 sans avoir le besoins de cribler car la fonction est réccurente...
Elle représente aussi le nombre d'entiers A pas obligatoirement premiers de la forme 30k +7 en progression arithmétique de raison 30, non congrus modulo P : $(2n+30)\not\equiv{A}[P]$ avec $P\leqslant\sqrt{2n+30}$
Si on prend les trois limites $n$ suivante on aura une moyenne de 14 204 639 couples = 2n ; pour une estimation de 12 853 383 .
======= RESTART: E:\Documents\Conjecture de Goldbach\Crible_EG2_mod30.py =======
Donnez n: 16000000105
Nombres P' non congruent à [pi] de 1 à 16000000105 famille 7, nombr de couples p+q=2n: 13 467 806 ----- 210.81
>>>
======= RESTART: E:\Documents\Conjecture de Goldbach\Crible_EG2_mod30.py =======
Donnez n: 16000000120
Nombres P' non congruent à [pi] de 1 à 16000000120 famille 7, nombr de couples p+q=2n: 14 334 132 ----- 243.58
>>>
======= RESTART: E:\Documents\Conjecture de Goldbach\Crible_EG2_mod30.py =======
Donnez n: 16000000135
Nombres P' non congruent à [pi] de 1 à 16000000135 famille 7, nombr de couples p+q=2n: 16 239 823 ----- 186.15
>>>
Comme quoi ce crible / algorithme de Goldbach par famille $30k + i$, cache bien des choses...
#222 Re : Café mathématique » Génération des nombres premiers : algorithme » 28-09-2020 08:38:02
Bonjour
@48PierrelePetit
Ce que dit @Yoshi concernant mon algorithme qu'il a programmé en python , il a aussi été programmé en C++..
Et effectivement les limites et temps de calcul ne sont pas comparable, pour une limite $n = (4 222 234 441 + 29)$ ou pour $2n$ concernant le deuxième algorithme qui donne le nombre de nombres premiers entre $n\: et\: 2n$,
pour info pour $n$ la limite de ton nombre premier 4 222 234 441 + 29 , il y a 24 999 915 nombres premiers de la forme 30k + 1 en 0,4 secondes... tu vois que le programme de mon algorithme, python de Yoshi, retranscrit en C++, n'est pas comparable.
et pour cette même limite $n$ il nous indique aussi qu'il y a 23 407 452 nombres premiers de la forme 30k + 1 entre 4 222 234 460 et 8 444 468 920 en 0,4 secondes ...
Tu peux vérifier que le programme en question se trouve sur le forum programmation à la page 15 : http://www.bibmath.net/forums/viewtopic … 10154&p=15
Mais ta réponse est intéressante, pourrais tu me retranscrire en C++ et en utilisant les slices comme ce la a été fait dans le programme en question . le programme python que @Yoshi m'a fait :
Si besoins je peux mettre les deux programmes en C++ pour les fusionner en C++ , comme il me l'a fait en Python ci dessous, ce qui ferait gagner du temps pour la fusion en C++ .
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):
n1,n = int(n**0.5), int((2*n)**0.5) #(si on fusionne les deux cribles il faudra rentrer, int((2n)**0.5) pour Goldbach.
prime_E,prime_EG=[2,3],[]
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]:
if each_number>n1:
prime_EG.append(each_number)
else:
prime_E.append(each_number)
for multiple in range(each_number*each_number, n, each_number):
sieve_list[multiple] = False
#print(prime_E,prime_EG)
return prime_E[3:],prime_EG
def Criblage_EG(Premiers,Premiers_suite, n, fam):
start_crible = time()
# On génère un tableau de n//30 cases rempli de 1
lencrible = ((n//30)+1)
crible=[1 for _ 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
Premiers+=Premiers_suite
del Premiers_suite # suppression du tableau devenu inutile
nbpremiers = len(Premiers)
n2 = 2*n
for premier in Premiers:
reste = n2 % premier
if reste % 2 == 0:
reste += premier
pi2 = 2*premier
# tant que reste % 30 != fam on fait reste += pi2
while reste % 30 != fam:
reste += pi2
# Ensuite on divise reste par 30 pour obtenir l'index
reste //= 30
# On crible directement avec l'index
for index in range(reste, lencrible, premier):
crible[index] = 0
total = sum(crible)
#print(nbpremiers)
#print("crible:", crible)
print(f"Nombres non congru 2n[pi] {1} à {n} famille {fam} premiers de {n} à {n2}: {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 à √n et de √n à √2nN
Premiers_E,Suite_E = eratostene(n)
# On crible
fam = 7 # ou 11, 13, 17, 19, 23, 29, 31 au choix
Criblage_EG(Premiers_E,Suite_E, n, fam)
main()
system("pause")
#223 Re : Café mathématique » Génération des nombres premiers : algorithme » 26-09-2020 09:12:23
ok , il t"en rajoute 33 .
Bonjour @Yoshi, je te laisse la main ....
J'attends ton idée de reprogrammation de notre algorithme ....déjà pour Ératosthène ou Goldbach et/ou: pour la fusion des deux ... le crible_EG2_mod30 c'est celui ci qu'il faudrait optimiser, afin de vérifier assez loin le nombre de représentation R(n) de 2n en somme de deux nombres premiers p+q pour une limite n fixée.
avec n= 15k + i , soit : 2n =30k + 2i.
@+
#224 Re : Café mathématique » Génération des nombres premiers : algorithme » 26-09-2020 08:31:30
Bonjour
Ben sur le forum de programmation ce n'est pas les algorithmes (cribles) générant des nombres premiers qui manquent , le crible d'Ératosthène ou une de ses variante...
Si pour une limite n =1000 , ton algorithme te donne 33 nombres premiers c'est qu'il a un sérieux problème...Et en combien de temps ?
Qu'est ce que cela donne pour n = 600 000 000 000 ? En combien de temps ?
par exemple pour le mien , il me donne 2 875 943 853 nombres premiers de la forme 30k + 7 en 59 secondes
Commence par expliquer ton algorithme ...Si tu veux une réponse §
#225 Re : Programmation » modifier un programme Python » 19-08-2020 14:27:45
A ) : Pour la conjecture , personne ne m'a donné de réponse sur la dernière formulation et notamment sur le dernier fichier que j'ai posté dans les posts de ce forum programmation...http://www.bibmath.net/forums/viewtopic.php?id=10154&p=16 #post 389.
1) L'égalité en jaune (propriété récurrente de l'algorithme) qui était élémentaire à démontrer .
(Au départ il pensait que je ne pourrai pas la démontrer ...et que je devais avoir une erreur .... Donc il a fallu que je leur donne la réponse afin qu'il trouve ma soi-disant erreur ....mais nada il n'y en a pas, ....et là....motus; plus aucun commentaire, il est vrai que c'était tellement élémentaire, et n'ayant pas du tout étudié l'algorithme avec ses propriétés qu'ils s'en faisaient une fausse idée !)
2) La fin du document sur la fonction qui estime le nombre de couples p+q = 2n, elle ne peut être nulle, autrement dit il ne peut exister un entier 2n > 290 quelque soit la famille 30k +(i) utilisée, où cette fonction serait = 0...
Car il faudrait utiliser les restes R (de 2n - 30; 2n - 60...etc) précédents ayant vérifiée la conjecture pour ces limites ; ce qui est absurde... D'autant que cette fonction donne toujours 2 résultats : 1) l'estimation du résultat réel pour la limite 2n vérifiée, donc vraie ; 2) mais aussi pour cette même limite 2n vérifiée, l'estimation qui vérifiera la conjecture pour cette limite suivante, le nombres de couples p+q = 2n+30 ...! Par conséquent , la fonction ne peut pas être nulle et non nulle pour une même limite 2n . Fonction qui utilise le nombre de premiers $\pi(2n)$ et comme facteur , la constante $C_2$ des premiers jumeaux : 1,320323... La fonction $c_2*\frac{\pi(2n)}{ln\:\pi(2n)}$ ; fonction que l'on peut utiliser par famille avec le nombres de premiers par famille...
Par exemple limite n = 3 000 000 : nombre de premiers Fam (30k +7) < (2n = 6 000 000) = 51 646 la fonction donne une estimation de couples p+q = 2n de 6283 couples pour un réel de Nombres P' non congruent à [pi] de 1 à 3000000 famille 7, nombre de couples p+q=2n: 6230 ----- 0.01 Estimation légèrement supérieur, mais dès que la limite 2n augmentera on passera sous la valeur réel du nombre de couples.
(Le détail des explications est dans les autres pdf que j'ai posté ).... (on verra...)
https://www.cjoint.com/c/JKviTzczeme
B ) : Pour en revenir à ta question; le modulo , il n'y a plus le modulo 30 c'est pour cela que la suite des entiers fait l'accordéon , ni de congru, sauf pour définir la valeur de j= a*b ; si j%30== fam , par rapport à la famille fixée. Et 121%30 == 1 pour la Fam (1) fixée.
[1,31,61,121,151,181,211,241,271,331,361,391,421,451=0 on le marque 0, car multiple de 11 ("sinon il faudrait écrire $451\equiv {0}[11]$ ce qui n'apporte rien") , puis 481 marqué 0 car multiple de 13
On écrit les entiers B + 210k ce qui supprime les multiples de 7, dans cette famille (1), avec B = [1,31,61,121,151,181] et on crible modulo (P*30) en partant de j = a* b .
Donc j'utilise pour cribler cette famille d'entier le modulo (P*30)k ; pour 11 au carré en partant de j = a*b = 11*11, que l'on marque 0; ensuite on marque 0 les multiples de 11, modulo (11*30) et non plus par pas de P, comme dans l'ancien programme; on utilise directement les valeurs ... Mais ça risque d'être long, même sans les multiples de 7 pour preuve voir ci-dessous....
Déjà rient que pour N = 3000 000 000 ça fait 40 minute qu'il traîne pour éditer les 1 = premiers dans la famille (1).
D'où les multiples de 7 ne sont pas un problème dans la fonction du crible avec notre programme
.
C'est l'édition qui est longue et en plus ce ne sont que des 1 ou des 0.