Pour retourner sur la page de l'accueil
Vous êtes actuellement sur une page avec des programmes et leurs formules pour calculer pi.
Tous les programmes seront triés par ordre croissant de temps pour calculer 1 000 décimales de pi. Ils seront tous programmés en python
la fonction racine serat utilisé sur toute la page. Toutes les formules ont été trouvé sur ces pages :
https://fr.wikipedia.org/wiki/Pihttps://en.wikipedia.org/wiki/Borwein%27s_algorithm
Et voici la formule la plus rapide avec son programme
la formule la plus rapide est la formule brent-salamin grâce à ce programme et prends en moyenne 0.001602532550068645 sec pour 1 000 décimales mais peut faire 4 sec pour 100 000 décimales ou 2 jours pour 1 000 000 000 de décimales
def racine(n): xav = d("2.0") x = d(sqrt(n)) precision_cible = getcontext().prec + 1 cp = getcontext().prec = 25 while xav != x or cp < precision_cible: x, xav = (x + n / x) / 2, x if cp * 2 < precision_cible: getcontext().prec = cp = cp * 2 elif cp != precision_cible: getcontext().prec = cp = precision_cible getcontext().prec -= 1 return xav def wiki_pi(nbd): getcontext().prec = nbd + 2 debut = time.process_time() un, deux = d("1.0"), d("2.0") a = p = un b = racine(d("0.5")) t = d("0.25") a, av = (a+b)/deux, a n = av - a x = p*n*n while x+un != un: t -= x b = racine(av*b) p += p a, av = (a+b)/deux, a n = av - a x = p*n*n getcontext().prec -= 1 n = a+b return n*n/(d("4.0")*t), time.process_time()-debut
|
la deuxième fonction la plus rapide est la fonction de convergence quadratique avec un temps de 0.00438527599999361 sec !
def quadratic(nbd): getcontext().prec = nbd debut = time.process_time() un, deux, quatre = d(1), d(2), d(4) a = racine(d("2.0")) b = d('0') p = deux + a pav = 0 while pav != p: m = racine(a) a, av = (m+un/m)/2, a b = (un+b)*m/(av+b) p, pav = (un+a)*p*b/(un+b), p return p, time.process_time()-debut
la troisième fonction la plus rapide est la fonction de convergence quartique avec un temps de 0.08003652699972008 sec !
def quartic(nbd): getcontext().prec = nbd debut = time.process_time() racine = d.sqrt un, deux, trois, quatre = d(1), d(2), d(3), d('4') y = d(racine(deux))-un quarts = (un/quatre) pi = deux*y**deux piav = 1 k = d('0') while piav != pi: y = (un-y*y*y*y)**quarts y = (un-y) / (un+y) piav, pi = pi, pi * (un + y)**quatre-deux**(deux*k+trois)*y*(un+y+y*y) k += un return un/pi, time.process_time()-debut
la quatrième fonction la plus rapide est la fonction de convergence cubique avec un temps de 0.10184746899994934 sec !
def cubic(nbd): getcontext().prec = nbd debut = time.process_time() un, deux, trois = d(1), d(2), d(3) pi = tiers = un/trois s = (racine_spec(trois)-un)/deux piav = un k = d(0) while pi != piav: k += un piav = pi r = trois/(un+deux*(un-s*s*s)**tiers) s = (r-un)/deux pi = r*r*pi-trois**(k-un)*(r*r-un) return un/pi, time.process_time()-debut
la cinquième fonction la plus rapide est la fonction de convergence nonique avec un temps de 0.20983729299996412 sec !
def nonic(nbd): getcontext().prec = nbd + 2 debut = time.process_time() un, deux, trois, neuf, vs = d(1), d(2), d(3), d(9), d(27) pui = pi = tiers = (un/trois) r = (racine_spec(trois)-un)/deux s = (un-r*r*r)**tiers while True: t = un+deux*r u = (neuf*r*(un+r+r*r))**tiers v = t*t+t*u+u*u w = (vs*(un+s+s*s))/v pi = w*pi+pui*(un-w) p = (un-r) s = p*p*p/((t+deux*u)*v) if s == 0: break r = (un-s*s*s)**tiers pui *= neuf return un/pi, time.process_time()-debut