Bibm@th

Forum de mathématiques - Bibm@th.net

Bienvenue dans les forums du site BibM@th, des forums où on dit Bonjour (Bonsoir), Merci, S'il vous plaît...

Vous n'êtes pas identifié(e).

#1 02-01-2021 13:42:19

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Programmes sous linux debian

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.

Hors ligne

#2 02-01-2021 13:56:52

yoshi
Modo Ferox
Inscription : 20-11-2005
Messages : 15 628

Re : Programmes sous linux debian

Salut,

Et ton programme en Python sous linux mint a-t-il une limite inférieure à celle qu'il avait sous Windows 10 ?
Je viens de vérifier : linux.mint.20 Ulyana abandonne le 32 bits pur passer en 64 bits.
Donc, ce n'est pas ça le pb...

Alors, c'est peut-être un pb de compilateur et de compilation C++ :  pose la question à celui qui l'a récrit en C++ puis compilé.
Il me semble que les exécutables en Linux ne doivent pas être en .exe, mais en .bin ou .com.

@+


Arx Tarpeia Capitoli proxima...

Hors ligne

#3 02-01-2021 14:31:15

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

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

Dernière modification par LEG (02-01-2021 14:39:22)

Hors ligne

#4 02-01-2021 14:53:42

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

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 .

Dernière modification par LEG (02-01-2021 15:59:01)

Hors ligne

#5 03-01-2021 09:46:45

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

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)

Hors ligne

#6 03-01-2021 09:57:48

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

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

Dernière modification par LEG (19-02-2021 07:37:05)

Hors ligne

#7 17-01-2021 09:02:31

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

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

Dernière modification par LEG (17-01-2021 09:59:04)

Hors ligne

#8 19-02-2021 11:42:43

LEG
Membre
Inscription : 19-09-2012
Messages : 585

Re : Programmes sous linux debian

Bonjour
@Yoshi
je viens de regarder les deux programmes en C++ pour les raccorder je pense qu'il n'y a que trois ligne à modifier :


// -*- 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;   ## couper à partir de cette ligne et rajouter :  return crible,lencrible; ###
    return crible,lencrible;
    }
  }

typedef unsigned long long ulonglong;

size_t EGCrible(const vector<ulonglong> & premiers,crible,lencrible,ulonglong n,int fam){    ## et donc modifier cette ligne pour réutiliser le tableau criblé ##
  int cl=clock();
  size_t nbpremiers=premiers.size();             ## supprimer donc lencrible=n/30 puisque l'on rapelle le tableau criblé ci dessus ##
  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;
  }
  crible,lencrible(ECrible(premiers,N,fam));        ## ici j'ai pris l'exemple de python, rajouter cette ligne  si il n'y a pas d'erreur ##
  EGCrible(premiers,crible,lencrible,N,fam);                         ## et donc modifier cette ligne##
  cin>>N;
}
 

Mais ça ne fonctionne pas ...? errors ......si tu as un avis ...?

Dernière modification par LEG (19-02-2021 15:28:18)

Hors ligne

Réponse rapide

Veuillez composer votre message et l'envoyer
Nom (obligatoire)

E-mail (obligatoire)

Message (obligatoire)

Programme anti-spam : Afin de lutter contre le spam, nous vous demandons de bien vouloir répondre à la question suivante. Après inscription sur le site, vous n'aurez plus à répondre à ces questions.

Quel est le résultat de l'opération suivante (donner le résultat en chiffres)?
quatre-vingt trois moins soixante quatre
Système anti-bot

Faites glisser le curseur de gauche à droite pour activer le bouton de confirmation.

Attention : Vous devez activer Javascript dans votre navigateur pour utiliser le système anti-bot.

Pied de page des forums