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

Répondre

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)?
trente trois moins vingt cinq
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.

Retour

Résumé de la discussion (messages les plus récents en premier)

leg.01
23-10-2018 20:01:02

Bonjour Yoshi

1) c'est exact, mais je ne pouvais pas modifier l'erreur de la ligne :
# On crible directement à partir de l'index avec pi
par rapport au message #296

donc tu peux supprimer le #299.

2) Mais, le nouveau code dans son intégralité a bien été publié #293.
avec cette phrase erronée "# on crible directement avec le reste "

Pour ta question personnelle , ce n'est pas moi qui vais te dire le contraire car j'ai du mal à digérer que les programme doivent être écrit en anglais, alors que la langue Française est largement plus riche en nuances... que cette langue pourrie....! Ca n'engage que moi...!

Il en est de même des démonstrations Mathématique qui doivent être publiées en anglais et non dans la langue du pays d'origine.
Jusqu'à preuve du contraire c'est pas les anglais qui ont découvert les Mathématiques , ni le fil à couper le beurre.....

yoshi
23-10-2018 08:13:05

RE,

Copie conforme du message #296.
J'ai eu (et ai toujours) d'autres chats à fouetter.
Quelques remarques :
1. Il aurait été bien que tu publies  le nouveau code intégral et pas un petit morceau,
2. Là, c'est personnel : je ne supporte pas, que dans la programmation, pour la raison que le langage est en Anglais, on mette aussi les noms des variables voire des fonctions ou des classes auss en anglais i (j'en ai déjà discuté avec mon neveu : lui, il considère que c'est normal, moi je trouve que c'est au mieux du snobisme, au pire une capitulation devant l'impérialisme... de la langue anglaise).
3. A quand une communication à l'Académie des Sciences ou à Cédric Villani ? ^_^

@+

leg.01
22-10-2018 14:57:37
leg.01 a écrit :

De ce que j'ai compris , il a repris tes idées sur ta dernière version , pour l'adapter à son programme la partie s2 s3 et la  fin pour le comptage des 1: total = sum(crible)
car avant il mettait 3 fois plus de temps que ta dernière version.

tout est là dedans ... et on n'à plus besoins "des pfam"


  if reste % 2 == 0:
      reste += premier
    pi2 = 2*premier
    while reste % 30 != fam:
      reste += pi2
    # Ensuite on divise ri par 30 pour obtenir l'indexe
    reste //= 30
    # On crible directement à partir de l'index avec pi
    for index in range(reste, lencrible, premier):
      crible[index] = 0

  total = sum(crible)
 

LEG
04-10-2018 18:51:14
yoshi a écrit :

RE,
Le 0 n'a rien à faire dans un crible, pourtant...
Curieux !
@+

je suppose que tu fais allusion à l'index = 0

Ce qui est vrai , car on travaille par famille et la famille en question dans ce crible est la famille 1, donc si le reste de 2n%Pi = 1; l'index de 1 par 30 serra bien =  à 0 .

d'où la première cellule [1] a pour indice 0 , la cellule d'indice 1 vaut 31 ; 61 ;....etc 1 + 30k.

Si je crible la famille 7, la cellule d'indice 0 vaut 7 ; puis 37 ; 67 ;..etc 7 + 30k. Donc si le reste de 2n%Pi est 7 , l'indexe = 0.....etc

LEG
04-10-2018 18:33:27

re : pour info, j'ai remplacer le crible _G(n), qui crible de 0 à n... de la première page par la version modifiée . qui s'inspire de la dernière version ci-dessus qui crible par famille ... GCrible(premiers, n, 1) il suffit de remplacer le 1 par {7,ou 11,13,17,19,23, ou 29}
@+

leg.01
03-10-2018 21:02:51

De ce que j'ai compris , il a repris tes idées sur ta dernière version , pour l'adapter à son programme la partie s2 s3 et la  fin pour le comptage des 1: total = sum(crible)
car avant il mettait 3 fois plus de temps que ta dernière version.

tout est là dedans ... et on n'à plus besoins "des pfam"


  if reste % 2 == 0:
      reste += premier
    pi2 = 2*premier
    while reste % 30 != fam:
      reste += pi2
    # Ensuite on divise ri par 30 pour obtenir l'indexe
    reste //= 30
    # On crible directement avec l'index
    for index in range(reste, lencrible, premier):
      crible[index] = 0

  total = sum(crible)
 

yoshi
03-10-2018 18:53:20

RE,

Je n'avais pas vu tes posts..
Je vais essayer de trouver un moment pour comprendre.
Le 0 n'a rien à faire dans un crible, pourtant...
Curieux !

@+

leg.01
03-10-2018 18:07:58

tu remarqueras que l'on a modifié la def eratostene , car dans la version #6.3, elle génère une erreur dû à la racine de 2n.
par exemple pour une valeur de n = 300 ou 210 ..ou certaine valeur elle double le dernier nombre premier Pi..mais cela n'a pas d'incidence sur le crible G4Y ou autre....
@+

leg.01
03-10-2018 18:00:46

Salut Yoshi
je suis au québec, et voici sur la base de tes idées et conseils la dernière mouture du crible de Goldbach.
les restes sont les j de ta dernière version. La Famille est définie à la fin :fam = 1 dans { GCrible(premiers, n, 1)  }
et on limite les restes = j à restes%30 != fam

voici le programme:


from time import time


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)
  prime_list = [2, 3]
  sieve_list = [True] * (n+1)
  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)
  return prime_list[3:]


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


def lprint(text="", liste=None):
  if len(liste) < 100:
    print(text + str(liste))


def GCrible(premiers, n, fam):
  start_crible = time()
 
  # On génère un tableau de N/30 cases rempli de 1
  crible = n//30*[1]
  lencrible = len(crible)

  # On calcule les restes: ri = 2*n/pi
  nbpremiers = len(premiers)
  n2 = 2*n
 
  for i, premier in enumerate(premiers):
    reste = n2 % premier
    # tant que ri % 30 != fam on fait ri += 2pi
    if reste % 2 == 0:
      reste += premier
    pi2 = 2*premier
    while reste % 30 != fam:
      reste += pi2
    # Ensuite on divise ri par 30 pour obtenir l'indexe
    reste //= 30
    # On crible directement avec l'index
    for index in range(reste, lencrible, premier):
      crible[index] = 0

  total = sum(crible)
  lprint("crible:", crible)
  print(f"Nombre premiers criblés famille {fam} entre {n} et {n2}: {total} ----- {int((time()-start_crible)*100)/100}")


def main():
  # On demande N a l'utilisateur
  n = demander_N()

  # On récupère les premiers entre 7 et √2N
  premiers = eratostene(n)
  lprint("premiers:", premiers)
  print(f"nombres premiers entre 7 et {int((2*n)**0.5)}: {len(premiers)}")

  start_time = time()
  # On crible
  GCrible(premiers, n, 1)
  temps = time()-start_time
  print(f"--- Temps total: {int(temps*100)/100} sec ---")


main()
 

LEG
09-09-2018 09:28:31

Bonjour
Salut @Yoshi.

j'ai une petite question (ça n'a pas grande importance..)

Dans le premier crible de base :Crible_G(n), il crible dans l'ensemble des entiers naturels 0,1,2,3.....n

le programme marque toujours la première cellule [1] qui correspond à 1...de ce fait , même si je n'ai pas de reste r = j = 1, il me compte un nombre premier en moins..par exemple 46 au lieu de 47 pour n = 300, 53 au lieu de 54 pour 330,....etc 56  au lieu de 57; n = 360...pour n = 390 c'est ok car il y a un reste R = 1

le programme est :

import os
import math

def eratostene(n):
  n = int((2*n)**0.5)
  m = (n-1) // 2
  limite = 1 + n
  b = [True]*m
  premiers = [2]
  for i,p in enumerate(range(3,limite,2)):
    if b[i]:
      premiers.append(p)
      j = 2*i*i + 6*i + 3
      debut,pas = j,2*i + 3
      for j in range(debut,m,pas):
          b[j] = False
  debut = i
  for i in range(debut,m):
    if b[i]:
      premiers.append(p)
    p += 2
  #print(premiers)
  return premiers


def premiersNa2N(n):
  #liste1 = eratostene(n*2)
  liste = crible_G(n)
  print("> Avec goldbach: On compte " + str(len(liste)) + " nombres premiers entre " + str(n) + " et " + str(2 * n))


def crible_G(n):
  nombres = n*[1]  # (0, puis n*[1]cela crée une erreur de -1 au final, du fait que l'on ne commence pas par 0
  nombres[0] = 0
  p = eratostene(n)
  pi = p
  r = []
  for i,pi in enumerate(pi):
    r.append(2*n % pi)
    j = r[i]
    while j <= n:
      nombres[j-1] = 0
      j += p[i]
  premiers = []
  for i in range(n-1, 0, -1):
    if nombres[i] == 1:
      premiers.append(nombres[i] == 1)
       #print(r)
  return premiers


n = int(input("Donnez la valeur de N : "))
premiersNa2N(n)
os.system("pause")
 

le programme devrait partir de 0,1,2,3....n car si il y a un reste R = 0 soit il part de 0 soit il part directement de Pi, puis il marque [0] par pas de Pi....

donc mon petit fils en fin de programme
avait mis l'instruction suivante , pour corriger cette erreur de 1 nombre...


premiers = []
  #print("√2N = "+str(int(math.sqrt(2*n))))
  for i in range(n-1, 0, -1):
    if nombres[i] == 1:
      premiers.append(nombres[i] == 1)
  # on regarde si il y a un reste égal à 1
  resteUn = 0
  lenr = len(r)
  for i in range(lenr):
    if r[i] == 1:
      resteUn = 1
  # si aucun reste n'est égal à 1 2*n-1 est premier
  if resteUn == 0:
    premiers.append(nombres[i] == 1)
  return premiers
 

mais je pense que c'est idiot de rappeler tous les reste r pour vérifier si il y a un reste r = 1 et si il n'y en a pas on rajoute un nombre premier au total....
alors que l'on devrait partir de 0, si R = 0  ou de Pi directement sans marquer la première cellule 1 = [1] en [0] il me semble que cela provient du fait qu'il commence à compter 0,1,2...etc...
donc lorsqu'il y a un reste R = 0 et bien il change la première cellule [1] = 1, en [0] alors qu'il ne devrait pas....lorsque le reste R = 1, pas de problème...le compte est bon ...

je suppose que la première ligne du programme, devrait commencer par la cellule 0 = [0], puis n * [1].....?????

def crible_G(n):
    nombres = n*[1]
  # (0, puis n*[1]cela crée une erreur de -1 au final, du fait que l'on ne commence pas par 0
    nombres[0] = 0
....
Si tu as une idée...sinon ce n'est pas grave...@+

LEG
28-08-2018 06:26:13

Re
Ah ,ok. Tu as parfaitement raison..car en effet, au maximum J serra toujours < pi*30 et d'autant plus, si on ne travaille que par Famille.

par exemple on crible la famille 1 modulo 30, on va traiter les j jusqu'à j%30 == 1.
Si dans la ligne de code à : fin , je paramètre l'instruction   ....,min(pi*30,n)....
et que j'édite les j ; pour N = 300 ; pour $P_i\leqslant\sqrt{600} = 23$ le dernier j serra 255 + 46 = 301 , mais il va imprimer 255 et il traitera bien 301; donc, il s'arrête bien en dessous de la limite maxi = 690 possible , pour les 8 fam par ex..

la liste des 8 j > r = nn%pi qui seraient à traiter, sont :

{2+pi : 25, 71, 117, 163, 209, 255,  301 } fin; ( 347, 393, 439, 485, 531, 577, 623, 669.) # Ensuite on rebouclerait pi*30 + j donc, sur 25 + 690..etc..

Alors que si je met pour fin : ....,min(pi*30,nn).... pour n =300 , le dernier j imprimé serra 577, donc il traitera aussi 623....pour rien puisque l'on ne veux que j %30 == 1, donc 301.

Et pour fin : ....,pi*30,.... il va jusqu'à j = 669 multiple de 3.

Tu vois que pour des valeurs n = 27 000 000 000 , ou plus, cela risque de faire quand même beaucoup de j à itérer et à traiter pour rien ; si on ne limite pas fin à :min(pi*30,n).... " avec un seul n. Cela n'enlèverai rien au résultat final...mais inutile.

yoshi
27-08-2018 18:12:23

Re,

J'ai eu et j'ai encore d'autres chats à fouetter, mais toujours la possibilité d'amélioration dans un coin de ma tête : je ne crois pas trop qu'une idée me vienne, mais sait-on jamais...

juste une question pourquoi dans cette ligne de programme , à l'instruction fin , tu as mis nn ;  min(pi*30,nn) et non pas n tout seul c'est ce que j'ai fait ...

C'est simple, il m'avait semblé que dans certains cas, il n'était pas nécessaire de fixer la limite fin à n et qu'on pouvait la mettre à minimum de pi*30 et de n soit pi*30, quand pi*30<n...

@+

Mais ce ne doit pas se ressentir en matière de gain de temps, sinon tu l'aurais vu

LEG
27-08-2018 15:34:16

Bonjour
Salut@Yoshi

j'ai fait un peu le tour du programme , et on ne peut pas faire plus...Ce qui me convient parfaitement.
la ligne d'instructions :


for i,pi in enumerate(Primes_init):      
        r=nn%pi
        debut,fin,pas=r+pi*(1-r%2),min(1+r+pi*29,nn),pi*2
 

joue bien son rôle de limite des j qui sont traités à la volée un par un...Je pensais qu'il traitait tous les j jusqu'à fin, c'est à dire les 15 J par séquence, ou par  Pi, il n'en est rien.

je l'ai vérifié sur différente valeur de 30k en éditant les J, et en comparant avec fin = pi*30 uniquement, c'est à dire


debut,fin,pas=r+pi*(1-r%2),pi*30,pi*2
 

juste une question pourquoi dans cette ligne de programme , à l'instruction fin , tu as mis nn ;  min(pi*30,nn) et non pas n tout seul c'est ce que j'ai fait ...

voici mon bloc de programme que j'ai modifié pour ne travailler que par famille, et comme tu le vois c'est l'avant dernière version...il y a 2 à 3 secondes d'écart avec la dernière version ...ils fonctionnent impeccables.


def CribleG3Y_mod30(n)  :
    # INITIALISATION
    global nombres,nbcell
    start_i= time()
    Primes_init = eratostene(n)
    nn,nbcell = n*2,n//30
    nombres = []
    for i in range(1):
        nombres.append([1]*nbcell)
    P8 = {1:0}   #pour 8 fam remettre les 8[1,7,...,29]
    s_1=time()-start_i
    print("Phase d'initialisation: %s seconds ---" % s_1)
   
    # FAMILLES POUR CHAQUE Pi
    start_time = time()
    for i,pi in enumerate(Primes_init):      
        j = nn%pi
        debut,fin,pas = j+pi*(1-j%2),min(pi*30,n),pi*2
        Fam = [0]   #pour 8 fam remettre les 8[0,0,...,0]
        for j in range(debut,fin,pas):
            if j%30 == 1:   # changer le paramètre pour une fam fxée
                fam = P8[1]  # changer le paramètre par fam fixée, pour P8fam remettre [j%30]
                if not Fam[fam]:
                    Fam[fam] = 1
                    debut_index = j//30
                    Nombres_fam = nombres[fam]
                    for index in range(debut_index, nbcell,pi):
                        Nombres_fam[index] = 0
 

je te met les tests jusqu'à 30 000 000 000, par tranche de 3 000 000 000 , pour le criblage de la famille J%30 == 1 ...résultat du nombres de nombres premiers q = 29%30 entre n et 2n.
On peut remarquer qu'il est assez linéaire , jusqu'à 27 000 000 000  ensuite pour la dernière tranche " ce qui est assez curieux d'ailleurs " il patine dans la semoule...je suppose qu'il arrive au bout de ses possibilité en mémoire et donc il rame grave....

Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) [MSC v.1900 64 bit (AMD64)] on win32
Type "copyright", "credits" or "license()" for more information.
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 3000000000
Phase d'initialisation: 0.4212009906768799 seconds ---
Bloc S2_s3 : 12.38642168045044 seconds ---
2271979
Extraction des premiers n à 2*n : 0.7644011974334717 seconds ---

**  16889354 nombres trouvés en 13.572023868560791 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 6000000000
Phase d'initialisation: 0.7176012992858887 seconds ---
Bloc S2_s3 : 25.755645036697388 seconds ---
3179221
Extraction des premiers n à 2*n : 1.5288028717041016 seconds ---

**  32748571 nombres trouvés en 28.002049207687378 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 9000000000
Phase d'initialisation: 1.029601812362671 seconds ---
Bloc S2_s3 : 40.06087040901184 seconds ---
3777621
Extraction des premiers n à 2*n : 2.277604103088379 seconds ---

**  48272991 nombres trouvés en 43.36807632446289 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 12000000000
Phase d'initialisation: 1.1856024265289307 seconds ---
Bloc S2_s3 : 55.770097732543945 seconds ---
4441039
Extraction des premiers n à 2*n : 3.0420053005218506 seconds ---

**  63579183 nombres trouvés en 59.99770545959473 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 15000000000
Phase d'initialisation: 1.419602632522583 seconds ---
Bloc S2_s3 : 71.6509256362915 seconds ---
4877519
Extraction des premiers n à 2*n : 3.790806770324707 seconds ---

**  78726833 nombres trouvés en 76.8613350391388 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 18000000000
Phase d'initialisation: 1.7940030097961426 seconds ---
Bloc S2_s3 : 89.48175716400146 seconds ---
5562837
Extraction des premiers n à 2*n : 4.570807933807373 seconds ---

**  93754572 nombres trouvés en 95.84656810760498 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 21000000000
Phase d'initialisation: 2.106003761291504 seconds ---
Bloc S2_s3 : 105.17538475990295 seconds ---
5744411
Extraction des premiers n à 2*n : 5.335209131240845 seconds ---

**  108685478 nombres trouvés en 112.6165976524353 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 24000000000
Phase d'initialisation: 2.3556039333343506 seconds ---
Bloc S2_s3 : 120.88461256027222 seconds ---
6144439
Extraction des premiers n à 2*n : 6.099610805511475 seconds ---

**  123530551 nombres trouvés en 129.33982729911804 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 4.321207523345947 seconds ---
Bloc S2_s3 : 337.5377926826477 seconds ---
6506779
Extraction des premiers n à 2*n : 7.1760125160217285 seconds ---

**  138301355 nombres trouvés en 349.0350127220154 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 2.542804479598999 seconds ---
Bloc S2_s3 : 138.07584238052368 seconds ---
6506779
Extraction des premiers n à 2*n : 6.80161190032959 seconds ---

**  138301355 nombres trouvés en 147.42025876045227 secondes **
>>>
===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====
Donnez la valeur de n = 30k : 27000000000
Phase d'initialisation: 2.542804479598999 seconds ---
Bloc S2_s3 : 136.59383988380432 seconds ---
Extraction des premiers n à 2*n : 6.848412275314331 seconds ---

**  138301355 nombres trouvés en 145.98505663871765 secondes ** ""je suppose qu'il y a eu un bug""

===== RESTART: E:\Documents\conjecture de Goldbach\cribleG3Y_modulo30.py =====## V. 6.2 ##
Donnez la valeur de n = 30k : 30000000000
Phase d'initialisation: 4.134007453918457 seconds ---
Bloc S2_s3 : 6937.051384449005 seconds ---
Extraction des premiers n à 2*n : 46.768882036209106 seconds ---

**  153006648 nombres trouvés en 6987.954273939133 secondes **
>>>

===== RESTART: E:\Documents\conjecture de Goldbach\cribleG4Y_modulo30.py =====## V. 6.3 ##
Donnez la valeur de n = 30k : 30000000000
Phase d'initialisation: 3.8532068729400635 seconds ---
Bloc S2_s3 : 6236.376153707504 seconds ---
Extraction des premiers n à 2*n : 47.28368306159973 seconds ---

**  153006648 nombres trouvés en 6287.513043642044 secondes **

C'est intéressant aussi l'augmentation du nombre de premiers q, par tranche de 3 000 000 000...
Bertrand avec son postulat il va se retourner dans sa tombe....Je plaisante....

@ +
Gilbert .

LEG
20-07-2018 14:42:25

je pense qu'au niveau du criblage lorsque l'on dépasse 29 700 000 000 ce n'est pas liste nombres = 1 000 000 000 par famille le point faible..
c'est bien le criblage par pas de Pi qui pose problème, car il faut compter les 1 ..... et ça on ne pourra s'en passer.

car regarde que je crible 29 100 000 000 le temps par famille pi et d'environ 3 secondes pour 29 910 000 000 il est de 4 secondes environ  et pour 29 940 000 000 quelques dixièmes en plus....
mais en criblage on passe de 180 seconde à 2800 secondes puis à 5600 secondes alors que le temps d'extraction ne varie pratiquement que de très peu de 7 à 10 seconde. justement grâce à ta partie 4 extraction...

or dans les trois cas la liste nombres est établie les Pi sont stockée...la boucle des j ne varierai que de très peu , même en limitant cette boucle la finà (while j%30 == 1).

c'est le même problème dans nbpremiers win 32 d'Eratosthène modulo 30 par famille..qui lui prend nombres = 15 000 000 000 de 1 mais le temps est d'environ 2h 20 avec mon pc, le programme est en c++.

par contre il est clair qu'il peut être amélioré par plusieurs points déjà la partie 4 de ton programme qui est très rapide par rapport au début où le temps est divisé au moins par 30....et d'autre point comme la racine carrée des premiers extraits par le GM ('Grupe Multiplicatif)..
Là probablement que l'utilisation d'un processeur multicœurs serait utile chacun prendrait une base il y en a 8...Mais c'est suffisant ...

Est ce que tu veux cet exécutable ? qui se présente sous la forme d'un calculateur sous Windows...

yoshi
20-07-2018 11:07:38

Re,

je travaille avec ta dernière version par famille uniquement... ce qui fait qu'effectivement pour chaque pi je ne travaille qu'avec un j%30==1 que je range via Dico[1] dans fam...

Oui, fam ne contient toujours qu'une valeur en tout et pour tout...

Il n'y a que la liste de listes nombres qui est imposante après sa construction : pour n=30 000 000 000, elle contient en tout 8 000 000 000 de 1...

Python a une extension mathématique numpy qui elle gère de vrais tableaux et est censée aller plus vite que Python tout seul (elle est installée chez moi) : j'avais donc remplacé les listes par des tableaux et testé...
J'ai abandonné : c'était bien plus lent !

Le point faible maintenant c'est clairement nombres !
Je n'ai toujours pas trouvé comment s'en passer : en fait j'ai bien une idée depuis le début, mais les résultats sont faux...

Une solution serait de paralléliser les calculs et d'utiliser le fait que nos processeurs sont multicœurs et qu'on ne s'en sert pas : mais ça, je ne sais pas faire pour le moment...

@+

Pied de page des forums