crible en python

yoshi · 31-10-2024 11:10:14

Bonjour LEG,

Je vais regarder ça, mais il va falloir que je me replonge dedans pour me remettre en mémoire l'architecture développée avec ton cahier des charges...
Quand j'aurai trouvé, je réfléchirai à la façon d'utiliser le module mathématique numpy qui gère de vrais tableaux et non pas des Listes : ce qui améliorerait encore sensiblement la vitesse d'exécution...

@+

LEG · 31-10-2024 11: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 @+

Dernière modification par LEG (01-11-2024 08:15:49)

LEG · 01-11-2024 06: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...

@+

Dernière modification par LEG (12-11-2024 12:11:23)

yoshi · 01-11-2024 13:43:13

Bonjour,

Si je veux tester, il va falloir que je retraduise en Python.
Et ensuite que je passe un coup de numpy dessus...
Mais, depuis hier, je m'interroge sur une apparente subtilité.

On génère un tableau de N/30 cases rempli de 1
lencrible = ((n1//30)+1)

Ci-dessous : à quoi sert de multiplier par 1 ? (subtilité propre à C++ ?

# Attention , On génère un tableau de N/2 cases rempli de 1 car on travaille dans l'ensemble des entiers naturel impairs
lencrible = ((n1//2)*1)

D'autant que lencrible n'est pas un tableau rempli de 1 mais le nombre d'éléments du tableau qui est construit après :

crible=[1 for _ in range(lencrible)] ## c'est plus propre comme ça

En outre, le 1er lencrible calculé est supérieur de 1 au 2e...

c'est plus propre comme ça

Ah bon ? Et en quoi ce serait plus propre que par exemple : crible=[1 for i in range(lencrible)] ?
Je vais faire plus de 600 tests de 10 en 10 où je vais tester l'égalité des résultats sans multiplier par 1 et en effectuant la multiplication

>>> vrais, nb_tests=0,0

>>> for i in range(357, 1008):

      nb_tests+=1

      l, l1=(i//2),(i//2)*1

      if l==l1:

                vrais+=1

>>> print (nb_tests, vrais)

651 651

>>>

L'égalité des 2 résultats est vraie 651 fois sur 651.
Je pourrais recommencer avec 2000 nombres entiers i tirés au hasard entre 6500 et 56000 (par exemple), j'arriverais au même constat
Conclusion : la multiplication par 1 est, en Python donc et en maths en général, une opération "blanche" :.
En effet, le nombre 1 est élément neutre pour la multiplication dans $\mathbb C$ (l'ensemble des nombres complexes dans lequel sont inclus tous les autres ensembles de nombres :
$\mathbb N \subset \mathbb Z \subset \mathbb D \subset \mathbb Q \subset \mathbb R \subset \mathbb C$
Cela signifie que : $\forall z \in \mathbb C, z * 1 = 1* z = z$ ($\forall$= Pour tout, Quel que soit)
Alors ici :
si ne note $l=(n1//2)$, alors $\forall\; l \in \mathbb N, l*1 = 1*l= l$
D'où ma question : pourquoi cette multiplication ?

Autres remarques
1. Lu dans la dernière version Python :

def demander_N():

    n = input("Donnez N: ")

    n = int(n.strip().replace(" ", ""))

    #n = int(30 * round(float(n)/30))

    #print(f"On prend N = {n}  (30 * {int(n/30)})")

    return n

et plus particulièrement cette ligne :
n = int(n.strip().replace(" ", ""))
(J'ai vérifié avant de la signaler)
En Python, la méthode strip() retire tous les espaces en début et fin de chaîne :

>>> S="   12345   "

>>> S.strip()

'12345'

>>>

Mais, sur les espaces intérieurs, strip() est inopérant !

>>> S="   1  2 3   4  5   "

>>> S.strip()

'1  2 3   4  5'

>>>

Et donc, vous avez rajouté la méthode replace et maintenant, c'est bon :

>>> S="   1  2 3   4  5   "

>>> S.strip().replace" ","")

'12345'

>>>

Bin, alors, diras-tu, où est le souci ?
Il n'y a pas de souci, juste que dans ce cas, strip() ne sert à rien, replace() se charge de tout le boulot toute seule :

>>> S="   1  2 3   4  5   "

>>> S.replace(" ","")

'12345'

>>>

2. n=input("Donner N :")
Là, par contre, il y a constamment des alternances joyeuses entre minuscules et capitales...
Moi, ça me gêne beaucoup et d'autres probablement pas du tout. Je n'y peux rien, je suis comme ça, je trouve ça malsain....
J'aurais préféré lire : n=input("Donner n :") même si ça ne change rien au fonctionnement.
J'ai pris cette habitude, de désigner les variables numériques par des minuscules, les ensembles, les listes, les dictionnaires, les chaînes par des capitales...

3. Lire pi = ..., me chiffonne aussi...
Que ce soit Pi ou pi, chaque fois je dois obliger mon cerveau à ne pas lire $\Pi$ ou $\pi$.
Là encore, je (pour insister que c'est totalement subjectif), j'aurais préféré P_i ou p_i, soit : $P_i$ ou $p_i$

Bon, je vais aller casser la croute, puis j'imprimerai tes deux codes Python (le dernier dispo) et C++ et commencer à faire ma traduction.

@+

LEG · 01-11-2024 15: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

crible=[1 for i in range(lencrible)]

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 .

size_t lencrible = sqrt(limite)/30; 

 

et la limite du criblage est jusquà la racine carrée de : $n=9\times10^{18}$ , il prend au delà mais il indique une erreur :

warning : integer constant is too large for its type ...

et je pense qu'il ne crible pas correctement , alors que pour $n = 9*10^{18} +1$ aucun souci et en 68 secondes ... pour la fam 30k+1

 ulonglong debut = 9000000000000000001;

  ulonglong fin = 9000000000000000016;

résultat nombre $p' \leqslant\sqrt{9*10^{19}}+1 = 18054607 $ et un nombre de $p'\not\equiv{2n}[P] =1537856$ , soit un : $1537856$ , $p'+q =2n$
@

Dernière modification par LEG (01-11-2024 17:14:49)

yoshi · 01-11-2024 18:31:10

Re,

attention c'est bien toi qui m'a refait les programmes ...

Oh, mais quelqu'un est passé derrière :
- Les commentaires : # c'est plus propre comme ça, ne font pas avancer la compréhension du programme --> à supprimer !
- le _ de "for _ in range...) n'est pas (à tort) dans mes habitudes,
- L'emploi de yield, par contre, c'est bien vu, je n'y avais pas pensé. yield fige le calcul et, à chaque rappel, permet de reprendre le calcul
là où il s'était arrêté d'où le eachnumber : ainsi on n'utilise pas de place mémoire en construisant une liste complète, mais on construit
et utilise un nombre après l'autre, à la demande,
- J'ai peut-être refait le programme, mais je ne vois pas en train d'écrire que je multiplie un nombre par 1...
Ne pas confondre avec [1]*10 --> [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

Tout ce que tu m'expliques me sera utile un peu plus tard, là je n'ai fait que relever que :
- lencrible = ((n1//2)*1) ou lencrible = n1//2 c'était "kif kif bourricot"...
- lencrible = ((n1//2)+1) oui, ça a du sens...
Fixer en Python l'arrêt d'une une boucle à n, c'est en réalité s'arrêter à n-1, d'où le +1 si on veut vraiment aller jusqu'à n.
J'avais pensé hier à une faute de frappe, revoyant le *1 aujourd'hui, je me suis dit que ce n'était pas anodin, d'où mon interrogation...

Si on veut chipoter davantage, dans tous les cas il y a des parenthèses inutiles :
lencrible = ((n1//2)*1) n'importe quel logiciel de programmation respecte la bases du calcul algébrique : la priorité des opérations...
Et donc :
lencrible = n1//2+1 fait parfaitement l'affaire et c'est... "plus propre" ^_^
De même que :
int(n**0.5) à la place de int((n)**0.5) fait aussi parfaitement le job, même si n était décimal, parce que (n)**0.5 ou n**0.5 te donnera le même résultat...
Par contre int(n)**0.5 $\neq$ int(n**0.5) avec n décimal, par exemple avec n=3800.99 on obtiendrait :
int(n)**0.5 $\approx$ 61.644140029689765$ et int(n**0.5)=61

Et pour (n//2)*1, tu penserais donc que n//2 ne donnerait pas le même résultat ?
Je reprends n=3800.99 :
C'est bien le même résultat :
n//2 --> 19.0
(n//2)*1 --> 19.0
sauf que, pour Python, le résultat (dans les 2 cas) n'est pas entier mais décimal (parce que n est décimal) et si ce résultat devait servir à contrôler une boucle, on obtiendrait un beau message d'erreur :

>>> for i in range(19.0):

      print (i)

Traceback (most recent call last):
File "<pyshell#50>", line 1, in <module>
for i in range(19.0):
TypeError: 'float' object cannot be interpreted as an integer

En résumé, dans ta multiplication par 1 sur cette ligne
lencrible = (n//2)*1
tu penses que ce 1 permet de remplir le tableau avec des 1 ?...
Non !

Preuve n° 1:

n=15

lencrible = (n//2)*1 

crible=["Leg" for _ in range(lencrible)]

print (crible)

te renvoie :

['Leg', 'Leg', 'Leg', 'Leg', 'Leg', 'Leg', 'Leg']

 

Ils sont où les 1 ?

Preuve n°2 :

n=15

lencrible = (n//2)*3 

crible=[1 for _ in range(lencrible)]

print (crible)

te renvoie

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

 

Ils sont où les 3 ?
Alors ?
Convaincu que, au moins en Python, le 1 de : lencrible=(n1//2)*1 ne sert à rien ?
Les 1 dans le tableau nommé crible sont déterminés sur cette ligne :
crible=[1 for _ in range(lencrible)]
Tu as bien vu dans les 2 exemples ci-dessus que
- si je remplace ce 1 rouge par "Leg", le tableau crible contient lencrible fois "Leg",
- si je remplace le 1 du *1 par 3 (en laissant le 1 rouge en place), le tableau nommé crible contient lencrible fois 1, mais s'il y avait
7 fois "Leg", les 1, eux, sont au nombre de 7 * 3 = 21...
Ok ?

Tout ça pour dire qu'il est important dès le départ d'avoir un programme "propre", parce que, une fois ton œuvre achevée, il te faudra la présenter à des sommités qui risquent fort d'arrêter leur lecture devant les points soulevés et la classer en "pas crédible"...

Bon, j'imprime !

@+

LEG · 02-11-2024 08: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 ??

Dernière modification par LEG (02-11-2024 11:41:46)

yoshi · 02-11-2024 14:16:35

B'jour,

Leg a écrit :

est ce que je peux modifier cette constante en C++ , par exemple : typedef unsigned SIZE_MAX UINT_MAX ??

C'est à moi que tu poses la question ? Tu ne doutes de rien ... C'est flatteur mais je ne sais que des choses basiques en C ou C++...
Je te conseille de t'orienter vers un forum dédié au C++, je regarderai pourtant via Google pour voir ce qu'il raconte à ce sujet...

Autre question, à laquelle je vais essayer de répondre :

Leg a écrit :

Où est que l'on place la ligne d'instruction , et comment l'écrire, pour imprimer le tableau criblé de Goldbach ; comme dans Python ? : ; [cout << ....?]

D'une manière générale, supposons que dans une fonction, tu remplisses un tableau T, fonction qui à la fin te retourne le tableau rempli :
return T et dont tu veux afficher le contenu...

--> Où est que l'on place la ligne d'instruction ?
1. Tu peux placer l'affichage dans la fonction, une ligne avant le return T
2. Tu peux aussi repérer la ligne du programme depuis laquelle tu appelles la fonction en lui passant les paramètres
dont elle a besoin.
Il te faut alors repérer sous quel nom cette ligne ou sur une ligne ultérieure ce tableau est récupéré. Cela fait, tu peux placer l'affichage
après la récupération

--> Comment l'écrire, pour imprimer le tableau criblé de Goldbach ?
A priori, je ne sais pas. Si ton tableau criblé par ta fonction est le tableau appelé total, cette ligne devrait pourtant faire l'affaire :
cout << " Nbr couple p+q criblés Fam " << fam << " : " << total;// " time " << (clock() - cl) * 1e-6 << endl;
cout est bien l'ordre d'affichage, l'équivalent du print () de Python .
Cette ligne devrait pourtant afficher la valeur de la variable fam, puis le tableau nommé total, puis le temps écoulé...
C'est bien ce qu'elle fait ?
Si la réponse est oui, alors total est-il bien le nom du tableau criblé ? Si non, où est ce fameux tableau ?
Enfin, plusieurs choses me surprennent dans ta fonction :
- je dénombre 1 seul { mais 2 } ça ne me paraît pas logique (je sais grosso modo à quoi ça sert en C, donc j'en
déduis que ça ne change pas en C++)
- je ne vois pas un nom explicite pour la fonction ou alors, il se présente bizarrement...

@+

LEG · 02-11-2024 16: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}$

Dernière modification par LEG (02-11-2024 17:33:33)

yoshi · 02-11-2024 17:52:58

Re,

Hmmm...
Le tableau que tu veux afficher devrait bien s'appeler crible apparemment...
Bon, si j'ai compris ce que j'ai lu, avant la ligne existante :
cout << Nbr couple... etc...
ajoute donc les lignes :

for ( int j=0; j < 20; j++ ) {
cout << crible[j] << endl;
}

Je me limite aux 20 premières valeurs.
Si ça fonctionne, même à peu près, selon ce qui s'affiche (ou les messages d'erreurs ^_^), on tâchera d'adapter...

@+

[EDIT]
Voilà l'affichage Python du dernier script en date :

Donnez N: 500
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31]

1
0
6
10
12
14
12
11
14
8

crible: [0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0]
Nombres non congrus à 2n [pi] 1 à 500 famille 1 premiers de 500 à 1000: 73 ----- 0.04
--- Temps total: 0.05 sec ---date :

C'est ça que tu voudrais reproduire ?
- Dans ce cas, pour les nombres en vert, il serait bien de dire avant l'affichage, en quelques mots, ce qui va s'afficher.
- La ligne en rouge n'est absolument pas claire (sauf pour toi).
Je personnaliserais le "non congrus à 2n [pi]" en 2*500 [valeur de pi]"
Par "valeur de pi" j'entends remplacer aussi le pi par sa valeur.
- "Nombres congrus à ..."
Pas clair... Quels nombres ? On pourrait comprendre que tous ces 0 et ces 1 sont ces fameux "nombres non congrus à 1000 [pi]"

Faire les modifs en Python ne devrait pas poser de pb, mais en C++...

@+

LEG · 03-11-2024 06: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}$

fromtimeimporttime
fromosimport system
importmath

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 ...
@+

Dernière modification par LEG (26-11-2024 13:35:56)

yoshi · 03-11-2024 22:16:32

Bonsoir,

1. As-tu fait l'essai demandé ?
2. J'ai récupéré ton script Python ci-dessus et ai commencé à remplacer les listes purement Python
pour les remplacer par des tableaux numpy (de num pour numérique et py pour Python) : j'ai passé
l'après-midi pour retoucher une... dizaine de lignes seulement.
Mais avec l'entraînement, ça devrait aller plus vite (je n'avais encore jamais touché à numpy jusqu'à
aujourd'hui).
3. Je pense qu'une fois modifié, on devrait avoir repoussé la limite maximum et gagner sensiblement
en vitesse :
Les sites que j'ai vus s'accordent à dire qu'utiliser les array (tableau) de numpy divise par 30 le
temps de traitement par rapport aux listes.
De plus, numpy possède des instructions qui permettent de se passer de certaines boucles...

@+

LEG · 04-11-2024 07:40:27

yoshi a écrit :

Bonsoir,
1. As-tu fait l'essai demandé ?
@+

Bonjour,
pour :
for ( int j=0; j < 20; j++ ) {
cout << crible[j] << endl;
}

Non , je ne sais pas où la placer...(mais , je vais réessayer)... Ça ne crible pas du tout APPUYER SUR ENTRÉE

Et de toutes façons , on est bloqué par la valeur de la limite $n$ en C++, qui est bornée à $2^{64} - 1$ limite que j'ai déjà testée... , qui me donne le nombre de solutions $2n=p'+q$ en ne criblant que jusqu'à la $\sqrt{n}\; divisée\; par\; 30$ et par famille...on peut affirmer au minimum que la conjecture est vraie jusqu'à $n=1,5\times10^{19}$ quelque soit la famille $30k+i$ en fonction de la forme de $2n$ ; voilà pour le C++.
D'autant, que si tu imprimes le crible, sous dos , cela n'a rien à voir avec python qui est nettement plus facile et plus clair à voir .

Pour python , je viens de remplacer le fichier , par celui que tu viens de modifier ; résultat ci joins; comme tu peux le vérifier , la réponse est immédiate pour une limite criblée de $1 \;à\; n = 300000000$ .
Le fait de re-cribler le tableau des nombres premiers criblés [def Ératosthène...] Jusqu'à la racine carrée de n / 30 c'est très rapide et on utilise peut de mémoire , sans perte de généralité ; mais bien entendu pour une limite $n\geqslant{3000000}$ par Famille; où on peut dire que cette conjecture est vraie...

On peut constater de plus , que la répartition du nombre de solutions , qui vérifie la conjecture est oscillatoire par famille , par rapport à l'une des 15 formes de $2n$. C'est une conséquence de la propriété de l'algorithme de Goldbach modulo 30, qui utilise les congruences et donc du décalage d'un rang des congruences, lorsque l'on on augmente la limite n de 15, qui fonctionne selon le même principe d'Ératosthène ....
Mais qui est différent du crible des nombres premiers , car les indexes de départ des nombres $P$ qui criblent est différent...

Python 3.9.5 (default, Nov 23 2021, 15:27:38) 

[GCC 9.3.0] on linux

Type "help", "copyright", "credits" or "license()" for more information.

>>> 

===== RESTART: /home/gilbert/Programmes/Crible _ sqrt de n _ EG_2N_mod30.py ====

Donnez N: 300000000

crible Ératosthène : [1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1]

Nombre premiers criblés famille 19 : 241 ----- 0.0

crible É ET G: [0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1]

Nombres p' non congru 2n[P] < sqrt n , ou couple p'+q = 2N, de (1) à sqrt de 300000000 famille 19 : 43 ----- 0.0

>>>

Un Grand Merci , cher ami ...

https://www.cjoint.com/c/NKvlJug4f7A

Dernière modification par LEG (21-11-2024 13:37:39)

DrStone · 06-11-2024 21:02:02

Bonsoir.

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 !

Quelques remarques :

Tu mélanges des types dans tous les sens : int, double, unsigned, unsigned long long… on ne s'y retrouve plus.
Pourquoi typedef unsigned long long ulonglong; ainsi que unsigned ? Il existe un type standard qui fait la même chose : std::uintmax_t si tu es sur une machine x86-64 ou bien sinon tu peux partir sur std::uint64_t
C'est une très mauvaise habitude d'utiliser using namespace std. Il a été choisi que l'espace de nom standard serait std car c'est court et rapide à taper. Ça évite les confusions qui seront présentent dès que tu utiliseras une bibliothèque externe (du type BigInt).
Pourquoi "push_back" les éléments de familles ? std::vector<std::uintmax_t> famille = { 7, 11, … } fait la même chose en une seule ligne.
debut et fin sont des constantes : tu peux les déclarer comme étant des const ; et même des constexpr, ici (bien que ça ne serve pas encore dans l'état actuel de ton programme). Comme cela : constexpr std::uintmax_t start = 900'000'000'000'000; parce que oui, tu peux aussi utiliser des "ticks" pour rendre les grands nombres plus lisibles.
Ce genre de ligne

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];
c'est typiquement du C. Pourquoi compiler en C++ si c'est pour ne pas l'utiliser ?
Voici donc comment ça s'écrit en C++ (11 et plus) :
std::vector<std::uintmax_t> GM = {7, 11, 13, 17, 19, 23, 29, 31};
for(const auto& gm : GM) {
produit = p*gm;
la notation for(const auto& gm : GM) est une notation par range ; comme en python.
if (p == unsigned(-1))
Oui, donc
if (p == UINT_MAX)
pourquoi s'embêter à cast un entier vers un entier ici ?

Il reste encore beaucoup de problèmes mais le programme étant globalement illisible, je ne saurais même pas par où continuer. J'ai commencé à le réécrire en C++ moderne et propre ; mais quand je vois le temps qu'il m'a fallu juste pour essayer de comprendre grossièrement ce que font les fonctions et refaire main en à peu près propre… j'imagine que j'aurais besoin d'un bon paquet de jours pour y arriver !

Dernière modification par DrStone (08-11-2024 05:23:18)

LEG · 07-11-2024 10: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 .

Dernière modification par LEG (07-11-2024 12:28:01)

DrStone · 07-11-2024 19:49:38

Bonsoir cher LEG.

Il me paraît bien dommage de ne pas ne serait-ce qu'apprendre les rudiments des langages de programmations que tu utilises. Surtout que de nos jours, beaucoup de travail a été effectué pour rendre le C++ bien plus userfriendly (tant est si bien qu'on n'essaie pas de s'approcher des arcanes… là ça devient un champ de bataille et je ne conseillerais à personne de s'en approcher sans y être préparé). Si cela t’intéresse je peux te conseiller au besoin myriade de ressources pour démarrer.

Ensuite, attention, je ne dénigre le travail de personne : le programme tourne et c'est le principal. Non, j’émets juste des critiques — certes rapidement formulées car il commençait à faire tard, néanmoins je peux tout à fait les justifier aussi longuement que nécessaire. En effet ce programme, en l'état, est, pardonnez-moi l'expression, imbitable pour le profane. Ce n'est pas un problème lorsque le dit programme utilise des notions avancées. Ça l'est bien quand, comme ici, le programme n'utilise que structures et instructions extrêmement simples mais totalement obfusquées. C'est le cas par exemple de

if(p == unsigned(-1))

 

qui est bien grossier lorsqu'on sait que ce n'est finalement que

if(p == UINT_MAX)

 

ça éloigne très clairement le profane qui doit déchiffrer tout ce fatras.
Je te laisse l'essayer par toi même avec le bout de code suivant, nécessitant un compilateur C++23 compatible (g++ 14 minimum) car j'utilise std::println, mais tu peux directement l'essayer sur ce lien ou remplacer std::println par le classique std::cout.

#include <climits>
#include <print>

int main() {

  std::println("unsigned(-1)={}", unsigned(-1));

  std::println("UINT_MAX={}", UINT_MAX);

}

En revanche, parce qu'il faut bien rendre à César ce qui appartient à César, ce programme est extrêmement rapide et fonctionnel. Aucun doute la dessus et c'est somme toute le principal ! La phase de mise au propre survient toujours en aval de la production.

Tu as raison sur le fait que je devrais peut-être repartir du code python pour tout refaire. Ça serait peut-être moins chronophage. J'essaierai les deux approches.

LEG a écrit :

pourquoi // famille .push_back(1)

J'ai bien compris la logique de ce passage. Ce que je demandais, tu pourras me relire, 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 :

std::vecteur<int> familles = { 7, 11, 13, 17, 19, 23, 29 };

est strictement supérieur, dans ton programme, à

  vector<int> familles;

  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);

car C++ doit allouer de la mémoire et réaliser des copies au push_back de certains éléments, pour agrandir le tableau qui contient tous les éléments de ton vecteur, ralentissant le tout — certes cela reste imperceptible pour si peu d'éléments et peut être contrecarré en réservant la quantité de mémoire nécessaire d'entrée de jeu

  vector<int> familles;

  familles.reserve(7);

  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);

mais la complexité de lecture et d'écriture du code demeure : si tu ajoutes une valeur par push_back, soit le vector doit être resized auquel cas C++ va allouer de la mémoire vive et réaliser une copie, soit tu dois changer la valeur dans reserve avec le risque d'oublie parce que c'est peu pratique. Rien de tout cela n'apparait dans le one-liner qui réalise tout ça pour toi en étant à la fois simple et efficace.

Pour ce qui est du fonctionnement interne ou de la réécriture, pas besoin d'ouvrir un nouveau fil de discussion. Celui-ci est très bien. Je ne vais pas trop le polluer. Je poserai un nombre limité de questions au besoin et posterai la réécriture finale lorsqu'elle sera prête.

Dernière modification par DrStone (07-11-2024 20:10:58)

LEG · 08-11-2024 09: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...

Dernière modification par LEG (08-11-2024 10:19:42)

yoshi · 08-11-2024 13:13:03

RE,

LEG a écrit :

Pour moi, je ne vais pas à mon âge, apprendre à programmer

Alors là, l'ami, tu touches un point sensible..
D'abord parce que tu t'adresses à des gens qui aiment ça...
Ensuite, parce qu'à te lire, on pourrait croire que tu n'es plus qu'un vieillard cacochyme...

À ton âge, dis-tu ?...
Et au mien alors ? J'ai 77 ans (78 l'an prochain, et ça fera plaisir à Cohn-Bendit...) mais je ne me sens pas vieux (sauf quand je remonte sur mon vélo et que je veux attaquer un col...)

Sache que
<< Vieux, ça n'existe pas ! Il n'y a que des gens qui sont jeunes depuis plus longtemps que les autres !... >> ^_^

Plus "sérieux" :
<< On ne devient pas vieux pour avoir vécu un certain nombre d'années, on devient vieux parce qu'on a déserté son
idéal. Les années rident la peau ; renoncer à son idéal ride l'âme ! >> (Général Douglas Mac Arthur) >>

Leg, il n'y a pas d'âge pour apprendre (à programmer)...

@+

DrStone · 08-11-2024 15:06:01

Bonjour à LEG, bonjour yoshi.

LEG, notre bon modérateur yoshi a mille fois raison ! En quoi l'âge est censé être une barrière à l'apprentissage ? C'est quoi cette excuse ? Je ne connais pas ton âge ; néanmoins, je sais que ça va bientôt faire sept ans que tu as ouvert cette discussion. Durant toute cette période, tu aurais quand même pu apprendre, au moins, quelques rudiments d'informatique nécessaires en toute circonstance ainsi que les rudiments de Python et de C++, non ?
Je ne te demande alors bien entendu pas d'apprendre la science informatique elle-même ; mais au moins les bases de la programmation dans les langages que tu utilises.

Si tu avais fait cela tu aurais pu comprendre le message d'erreur de compilation, on ne peut plus clair, disant

error: 'UINT_MAX' was not declared in this scope

if (p == UINT_MAX) {

note: 'UINT_MAX' is defined in header '<climits>'; this is probably fixable by adding '#include <climits>'

  +++ |+#include <climits>

et réaliser l'unique tâche d'inclure par toi-même l'header correspondant ; plutôt que me demander s'il fallait changer des choses partout dans le programme.

Tu aurais aussi pu comprendre que les quelques lignes

#include <climits>

#include <print>

int main() {

  std::println("unsigned(-1)={}", unsigned(-1));

  std::println("UINT_MAX={}", UINT_MAX);

}

ne sont qu'un exemple et qu'il est inutile de l'importer dans ton programme : il se suffit à lui-même et c'est pour cela que tu peux le tester en tant que tel au lien godbold que j'avais fourni.

LEG a écrit :

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 ...

Pourquoi tu n'aurais pas le choix ? Si on reste à ton niveau de maîtrise du C++, tu peux faire exactement faire ce que tu as déjà fait pour les push_back : déplacer l'accolade ainsi que le point virgule puis mettre en commentaire ce que tu ne veux pas utiliser. Par exemple comme cela :

std::vector<int> familles = { 7, 11, 13 }; // , 17, 19, 23, 29 };

Ton code ne se déroulera alors que pour les familles 7, 11 et 13; laissant les familles 17, 19, 23 et 29 sur le carreau.
Si tu veux ajouter la famille 17, eh bien pas de problème, tu décales encore

std::vector<int> familles = { 7, 11, 13, 17 }; // , 19, 23, 29 };

Bien entendu, il y a de meilleurs approches que celle-ci, mais il me semble que c'est difficile à mettre en place dans un bout de code utilisé par une personne n'ayant aucune réelle connaissance en programmation (d'autant plus en C++).

Je réitère donc ma proposition en toute amitié : si tu veux, au moins, apprendre les rudiments de C++ afin d'être en mesure de t'en sortir dans ces cas très simples (et plus encore) je peux te fournir bon nombre de ressources pour se faire. :=)

Dernière modification par DrStone (08-11-2024 15:06:19)

LEG · 08-11-2024 19: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

std::vector<int> familles = { 7, 11, 13 }; // , 17, 19, 23, 29 };

à 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...!

Dernière modification par LEG (08-11-2024 19:33:42)

DrStone · 08-11-2024 19:56:55

Rebonjour LEG

LEG a écrit :

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é.

Il ne s'agit pas que de ça. Il s'agit aussi d'être capable d'apporter des modifications ou des améliorations par toi-même. Tu le dis toi-même, tu aimerais avoir la possibilité d'imprimer un tableau criblé (donc avec un résultat qui s'apparente à ce qu'on trouve dans ce post, j'imagine ?).
Mettons que je décide de ne pas le faire et de simplement réécrire le programme tel qu'il est en l'état simplement en le modernisant. Tu comptes faire quoi ? Attendre que quelqu'un d'autre débarque et le fasse pour toi ?

Ça s'apparente légèrement à profiter de la gentillesse des gens, non ? Alors même que, pourtant, cette idée d'imprimer le tableau comme dans le post mis en lien ci-dessus, ne demande presqu'aucune connaissance : juste les bases. Particulièrement en C++ moderne. Et nul besoin d'apprendre l'anglais pour apprendre les rudiments de la programmation. Il existe une littérature française fort bien fournie sur ces sujets — y compris des traductions d'ouvrages anglo-saxons.

Il ne fait aucun doute que certaines de tes idées peuvent et doivent être difficile à mettre en œuvre. Sache néanmoins qu'avec juste quelques rudiments, de la logique et un minimum de capacité à mettre tes idées en place (ça se travail), tu peux écrire 90 à 95% de tous les programmes et logiciels qui existent, par toi-même. Ça sera juste long. Parce que bon, il y en a un paquet de logiciels et programmes dans le monde !

Et très franchement, je comprends à 100% qu'une personne qui ait tenté de traduire ce programme en Haskell ait abandonné. Vu la complexité à la lecture du bousin.

LEG · 08-11-2024 21: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 !

yoshi · 08-11-2024 21:41:30

RE,

@LEG
Oh, je suis loin d'avoir fini d'injecter numpy dans le script Python : je termine juste la fonction eratosthene...
Je me rends compte que certains points de manipulations des Listes en Python pur qui ne me posent plus de problèmes particuliers maintenant sont à repenser de A à Z en numpy et que c'est très loin d'être évident : même que je galère grave...
Mais ce n'est pas pour autant que je vais tout envoyer promener !
C'est un défi que je me suis - volontairement et librement - lancé et j'irais au bout...
Ainsi, les défis sont là pour empêcher les cerveaux de se ramollir : j'ai trop vu la lente dégénérescence de celui de ma pauvre mère, certes victime d'Alzheimer, mais quand même...

[HS]
Eh, camarade, il paraîtrait que l'on va remplacer les courroies de distribution par des chaînes (comme par le passé...) pour les véhicules thermiques, ça cassera moins, se changera moins souvent (actuellement 80 000 km sur la clio diesel de ma fille, 120 000 km pour mon Scenic 1.6 turbo D)
Bah... Puisqu'on nous dit que le tout électrique, c'est l'avenir, alors toutes ces basses contingences matérielles ne nous causeront plus de soucis...
[/HS]

Pour en revenir à numpy, c'est pratiquement un nouveau langage de programmation et il exact qu'en le connaissant bien on peut éviter pas mal de boucles...
Il me faut beaucoup chercher, beaucoup tester par morceaux et ça me prend du temps : les sites d'aides qui pullulent sur Internet ne m'aident que rarement du 1er coup : leurs concepteurs et moi avons donc probablement rarement la même façon, de sorte que les termes que j'utilise pour mes recherches ne me conduisent pas souvent directement au bon endroit...
Mais, pour pouvoir avancer, je suis obligé de faire avec. J'avance, mais j'avance lentement !
Chi va piano va sano, chi va sano va sicuro, chi va sicuro va lontano...
Ou encore : hâte-toi dit le sage, mais hâte-toi lentement...
Demander des conseils, comme en donner, sont des sports à haut risque, même si on a coutume de dire en Français :
les conseilleurs ne sont pas les payeurs.
Là encore, je préfère la version italienne : a chi consiglia, non duole il capo ( traduction presque presque littérale : à celui qui conseille, la tête ne fait mal !).
Je ne vais pas te conseiller tel ou tel langage, et donc a fortiori comment l'apprendre, je ne peux juste que t'encourager à essayer et persévérer.
Quand j'avais décidé de me me lancer dans l'apprentissage du Kendo, je savais pertinemment que j'allais en... baver !
Ça n'a pas loupé, mais j'y étais préparé et j'ai persévéré là quand de jeunes (et moins jeunes) inscrits me dépassaient comme des météores pour finir par capituler notamment quand ils prenaient conscience que pour franchir leur mur de verre, il leur faudrait... crier !!!
Pas si simple ! J'ai pu le vérifier dans le gymnase de mon bahut quand le club y était allé en démo (ce furent pourtant généralement les plus "gueulards" qui ne purent s'y résoudre... Incroyable : une épidémie d'aphonie s'était répandue parmi eux comme une trainée de poudre ! ^_^)...

Donc, je ne peux (et ne veux) que t'encourager avec un peu de chimie ;-).
Voilà la devise des Taupins (pour les non-initiés : élèves de Maths Spé) qui est inscrite en gros caractères sur la page de garde de ma table de logs) :

S et KOH

@+

[EDIT] En relisant ce qu'a écrit LEG, je ne peux m'empêcher de repenser aux reproches faits à Omhaf et à mon intervention : y a comme un écho... ^_^

Dernière modification par yoshi (08-11-2024 21:59:53)

DrStone · 08-11-2024 22:21:44

Je me doutais que tu le prendrais mal. ;=)

Je n'ai pas mis de postscriptum te demandant de bien relire mon message une ou deux fois afin de ne pas le prendre de travers car je me disais que ça serait instructif d'avoir ta réponse. Effectivement, ça l'est.

LEG a écrit :

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 !

Bien sûr que je ne te connais pas ! Il n'empêche que j'ai quand même décidé, malgré tout, de moderniser et dépoussiérer ton programme afin que toi, ou d'autres, puissent l'améliorer sans s’arracher les cheveux… pourquoi à ton avis ?

LEG a écrit :

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 n'ai jamais posté quoi que ce soit sur les-mathematiques.net. Tout au plus j'y passe de temps en temps pour voir ce qui s'y dit. Néanmoins, je ne compte aucunement m'y inscrire ou m'y investir. bibmath.net est très bien et est largement suffisant comme ça.

LEG a écrit :

... 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) .

Et encore une fois : ça tourne, c'est tout ce qu'on lui demande initialement… certes. Mais maintenant, sans vouloir dénigrer le travail effectué en amont : tu veux y ajouter des fonctionnalités et… tu te retrouves coincé. Pour deux raisons :

Le programme est illisible et quasi impossible à améliorer : il mélange du C et du C++, des types dans tous les sens, il réalise aussi les mêmes taches de plusieurs manières, en mode C et en mode C++ old-school (C+Classes). Exemple typique présent dans ton code source :
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++)
et
unsigned cs = crible.size();
[…]
for (unsigned i = 1; i < cs; ++i)
sont deux manières (la première typiquement C, la seconde typiquement C++89… oui, 1989 !) de faire la même chose ; chose qui aujourd'hui se fait, proprement et lisiblement, comme en python
for(const auto& c : crible) {
que tu peux traduire en bon français par : pour chaque élément constant (dont on déduit le type automatiquement) du tableau crible.
Note que cette ligne, à elle seule, fait même bien plus que simplement permettre d'itérer sur les éléments du vector (c'est du C++ "safe"), mais tu t'en fiches probablement… après tout, tu as déjà un truc qui tourne. Je suis bête aussi, pourquoi je me prends la tête avec tout ça alors que ça sert à rien ?
On ne sait même plus où donner de la tête.
Tu es toi-même incapable d'ajouter la moindre ligne de code que tu aurais produit seul à ton programme. Oui, tu peux ajouter une ligne qu'on t'aurait écrite et qu'on te dirait où placer… mais, au fond, c'est ton "programme", ton "projet", tu ne devrais pas avoir besoin de compter sur les autres, particulièrement après toutes ces années, non ? Enfin ça, ce n'est que mon avis (de bohémien ?).
Et puis, paraît-il, que tu es vieux.

LEG a écrit :

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 ...

Tu t'inventes une réalité alternative, mon ami.

LEG a écrit :

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 cadeaux à sa fille car je connais très bien la famille .... En 2003 il était étudiant à l'essi de Sophia

Oui, et ? Elle va durer longtemps cette tirade ? Je ne dénigre pas le travail des autres. De toute façon c'était mon boulot fut un temps de prendre des codes sources du style et de les réécrire en C++ moderne, propre, et tout le reste : j'ai vu bien pire que ce que tu nous présentes ici… mais ce n'est aucunement une raison pour niveler par le bas.

Non, je rouspète, car tu décides simplement de compter sur les autres plutôt que d'apprendre à faire toi-même quelque chose qui n'est pas sorcier sous prétexte que tu serais, je cite, «vieux». Rien de plus, rien de moins. :=)

LEG a écrit :

Alors respecte le travaille d'autrui cela te serra profitable et avant de juger , réfléchis un peu mieux.. ou demande ...

Je respecte le travail d'autrui, moi. J'apporte des critiques constructives (et jusqu'à qu'on l'inscrive dans une loi divine, ce n'est pas être irrespectueux), si tu les trouves trop courtes je peux te faire un pavé de 100 lignes sur chacune de ces critiques — peut-être qu'alors, comme tout bon Français, tu les trouveras parfaitement constructives parce que, comme en dissertation, c'est bien connu : "la quantité fait la qualité"… ou pas — et je prends même le temps d'étudier le bousin, comme tu dis, afin de l'améliorer à terme.
Contrairement à toi qui t'es contenté de le regarder béât moult années sans chercher à y comprendre quoi que ce soit. De fait, je ne suis pas certain que ce soit moi le plus irrespectueux du travail d’autrui dans la salle. :=)

LEG a écrit :

Si tu avais pris la peine de lire tout le déroulement de ce sujet depuis 2018

Bien sûr et je peux aussi réaliser tous tes désirs. Je n'ai pas de vie après tout !

LEG a écrit :

Pour te répondre , tu es venu sur ce forum ...je te cite :
[…]
.....IL TOURNE ... TRÈS BIEN ET TRÈS VITE ...!

Ai-je jamais prétendu le contraire ?

LEG a écrit :

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...

Excuse-moi d'avoir (eu) une vie, de n'être arrivé sur les forums de mathématiques (et plus spécifiquement : uniquement sur bibmath.net) à date de mon inscription ici, soit le 7 janvier 2024.

En attendant, toi tu as le programme entre les mains depuis des années mais tu n'as rien fait pour ne serait-ce qu'être en mesure d'y apporter le moindre changement… la preuve en est : tu n'es même pas en mesure de changer 8 caractères sans que cela ne déclenche une erreur, parfaitement documentée, que tu te retrouves bien incapable de corriger.

————————————————————————————————————————————

Initialement, je suis venu avec aucun autre but que de te proposer, gentiment, d'améliorer ce programme C++ en le faisant passer d' «imbitable» (ça c'est de moi, oui, mais c'est factuel) à propre, moderne et facilement modifiable.
Je t'ai même proposé de te rediriger vers des ressources (et pourquoi pas même te partager des ressources au format PDF) qui t'auraient permis d'apprendre les rudiments du C++ afin que tu puisses enfin, aussi, y apporter tes modifications.
Mais non, notre ami LEG est vieux, messieurs dames ! Ainsi donc, comme il est vieux et âgé, il est à présent en incapacité d'apprendre quoi que ce soit de nouveau !

Comme tu le dis, je ne te connais pas autrement que par les trois ou quatre messages qu'on s'est échangé depuis hier ; et force est de constater que tu me donnes une bien mauvaise image à voir… celle de la personne âgée qui pense ne plus pouvoir rien faire de sa couane
Pour autant, je ne crois pas que tu sois comme ça dans la vraie vie. Toutefois, c'est bien l'image que tu m'as renvoyée ici en 24h.

Notre modérateur au contraire, prend la chose dans le bon sens : il ne sait pas ou ne sait pas faire ? Eh bien il apprend, il expérimente, il fait ! Autrement dit, il a une démarche pro-active ! Et c'est probablement comme ça qu'il a fait pendant toutes ces années pour t'aider ! Il a appris, il a expérimenté, il a fait.

————————————————————————————————————————————

Cette petite guerre peut s'éterniser, mon ami, néanmoins moi je n'ai rien à me reprocher, aussi bien au niveau de la temporalité (prétendant que j'aurais pu et du me manifester à une époque où je n'étais même pas sur les différents forums que tu fréquentes…), que niveau moralité (vu que tu m'attaques sur ce point; soi-disant que je serais médisant).

————————————————————————————————————————————

PS. Tu marques un point dans ton EDIT, yoshi. Deux fois en deux jours. Soit, j'imagine que le problème émane de moi. ^_^' Du coup je vais simplement me retirer et je reviendrai un jour, peut-être, avec le programme modifié.

Dernière modification par DrStone (08-11-2024 23:53:35)

yoshi · 08-11-2024 23:14:22

Bonsoir,

Soit, j'imagine que le problème émane de moi. ^_^ Du coup je vais simplement me retirer (...)

Meuuh non !
Pourquoi donc ? Personne ne te chasse ni ne veut chasser qui que ce soit, nous ne sommes que deux (Fred et moi) à le pouvoir (et à en user avec modération !)...
Il ne faut pas le prendre dans le mauvais sens : pour le coup, LEG - qui a le cœur sur la main - (je le "pratique" lui aussi depuis pas mal de temps) a pris la mouche : j'ai mal senti son post, je n'ai pas trouvé comment l'adoucir et je m'attendais donc plus ou moins à ce qu'il se passe.
Sur un forum, mieux vaut ne pas être (trop) susceptible, tout le monde n'a pas forcément appris à juger de la portée de ses propres écrits... Et c'est moi qui écrit ça ??? Moi qui, Lycéen, avait Commentaire de textes et Dissertation en horreur : je restais << sec comme un coup de trique ! >>
Les temps ont bien changé... et pourtant, il m'arrive aussi parfois de me rater...

Dr Stone a écrit :

Eh bien il apprend, il expérimente, il fait ! Autrement dit, il a une démarche pro-active !

Bin, c'est seulement que depuis que je fais des maths et de la programmation, je suis incapable d'avancer autrement : S et KOH, autrement dit, Souf(f)re et potasse ! J'suis ptêt maso, sans le savoir...

J'apprécie tes interventions, d'autres intervenants aussi, des P.O (je me suis toujours demandé ce que cachait cet acronyme : Science sans conscience ... etc disait, Rabelais),pourtant, pour une fois, je le reprends à mon compte) sûrement également...
Et nos échanges alors, que deviendraient-ils ?

La nuit porte conseil !

@+

Forum de mathématiques - Bibm@th.net

#401 31-10-2024 11:10:14

Re : crible en python

#402 31-10-2024 11:57:27

Re : crible en python

#403 01-11-2024 06:35:55

Re : crible en python

#404 01-11-2024 13:43:13

Re : crible en python

#405 01-11-2024 15:34:05

Re : crible en python

#406 01-11-2024 18:31:10

Re : crible en python

#407 02-11-2024 08:16:04

Re : crible en python

#408 02-11-2024 14:16:35

Re : crible en python

#409 02-11-2024 16:37:04

Re : crible en python

#410 02-11-2024 17:52:58

Re : crible en python

#411 03-11-2024 06:17:00

Re : crible en python

#412 03-11-2024 22:16:32

Re : crible en python

#413 04-11-2024 07:40:27

Re : crible en python

#414 06-11-2024 21:02:02

Re : crible en python

#415 07-11-2024 10:03:25

Re : crible en python

#416 07-11-2024 19:49:38

Re : crible en python

#417 08-11-2024 09:48:51

Re : crible en python

#418 08-11-2024 13:13:03

Re : crible en python

#419 08-11-2024 15:06:01

Re : crible en python

#420 08-11-2024 19:11:38

Re : crible en python

#421 08-11-2024 19:56:55

Re : crible en python

#422 08-11-2024 21:09:10

Re : crible en python

#423 08-11-2024 21:41:30

Re : crible en python

S et KOH

#424 08-11-2024 22:21:44

Re : crible en python

#425 08-11-2024 23:14:22

Re : crible en python

Réponse rapide

Pied de page des forums