Approximations de Pi: Algorithmes de Borwein

Télécharger le projet
Commenter

Description

Bonjour,

Pour les calculs de Pi, l'apport des frères Jonathon et Peter Borwein (nés en 1951 et 1953) est immense.
Nous allons voir ici trois algorithmes qui "multiplient" le nombre de décimales précises à chaque itération, comme sous (Algorithme de Brent-Salamin).

Cet article fait partie de la série CodeS-SourceS: Approximations de Pi <<< cliquez !.
 

Convergence quadratique 1984

 
A chaque itération, on double le nombre de chiffres précis.

a[0] = sqrt(2)
b[0] = 0
p[0] = 2 + sqrt(2)

a[n+1] = (sqrt(a[n]) + 1/sqrt(a[n])) / 2
b[n+1] = (1 + b[n]) * sqrt(a[n]) / (a[n] + b[n])
p[n+1] = (1 + a[n+1]) * p[n] * b[n+1] / (1 + b[n+1]) 
double Borwein_2(int n) { // 1984
  double a=sqrt(2.0), b=0.0, p=2.0+a;
  for (int i=1; i<=n; ++i) {
    b = (1+b)*sqrt(a)/(a+b);
    a = sqrt(a);
    a = (a + 1.0/a)/2.0;
    p = (1+a)*p*b / (1+b);
  }
  return p;
} // chaque itération double le nombre de chiffres précis

Convergence cubique 1991

 
A chaque itération, on triple le nombre de chiffres précis.

p[0] = 1/3
y[0] = (sqrt(3) - 1) / 2

r = 3 / (1 + 2*(1 - y[n]^3)^(1/3))
y[n+1] = (r - 1) / 2
p[n+1] = r*r*p[n] - (r*r - 1)*3^n 
double Borwein_3(int n) { // 1991
  double a=1.0/3.0, p=1.0, r, s=(sqrt(3.0)-1.0)/2.0;
  for (int i=1; i<=n; ++i) {
    r = 3.0 / (1.0 + 2.0*pow(1.0 - s*s*s, 1.0/3.0));
    s = (r-1.0)/2.0;
    a = r*r*a - p*(r*r - 1.0);
    p *= 3.0;
  }
  return 1.0/a;
} // chaque itération triple le nombre de chiffres précis

Convergence quartique (biquadratique) 1985

 
A chaque itération, on quadruple le nombre de chiffres précis.

p[0] = 6 - 4*sqrt(2)
y[0] = sqrt(2) - 1

y[n+1] = (1 - (1 - y[n]^4)) / (1 + (1 - y[n]^4))
p[n+1] = p[n] * ()^4 - y[n+1] * (1 + y[n+1] + y[n+1]^2) * 2^(2n+3) 
double Borwein_4(int n) { // 1985
  double a=6.0-4.0*sqrt(2.0), p=2.0, q, y=sqrt(2.0)-1.0;
  for (int i=1; i<=n; ++i) {
    y = sqrt(sqrt(1.0 - y*y*y*y)); // sqrt(sqrt(x)) = pow(x, 0.25)
    y = (1.0-y) / (1.0+y);
    p *= 4.0;
    q = (1.0+y)*(1.0+y);
    a = a*q*q - p*y*(1.0 + y + y*y);
  }
  return 1.0/a;
} // chaque itération quadruple le nombre de chiffres précis


Le Zip contient le seul fichier source Borwein.cpp dont voici l'Output: 
Borwein_2: 1984 chaque itération double le nombre de chiffres précis
  n= 1: pi=3.14260675394162
  n= 2: pi=3.14159266096604
  n= 3: pi=3.14159265358979
précis: pi=3.14159265358979

Borwein_3: 1991 chaque itération triple le nombre de chiffres précis
  n= 1: pi=3.14159058520590
  n= 2: pi=3.14159265358980
  n= 3: pi=3.14159265358980
précis: pi=3.14159265358979

Borwein_4: 1985 chaque itération quadruple le nombre de chiffres précis
  n= 1: pi=3.14159264621355
  n= 2: pi=3.14159265358981
  n= 3: pi=3.14159265358981
précis: pi=3.14159265358979


Wiki: Borwein's algorithm
Wiki: Algoritmo de Borwein
Mathematical Intelligencer: The Quest for Pi
 
 
Bonne lecture ...
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (William VOIROL)