Étape 12 : Codage formule de Gauss
Lors de notre étape précédente, nous avons trouvé la formule :
Π/4=12*arctan(1/18) + 8*arctan(1/57) - 5*arctan(1/239)
Nous pouvons facilement transformer cela en une fonction en python si nous supposons que nous avons défini une fonction arctan :
Maintenant nous devons créer une fonction arctan. La méthode la plus rapide à mettre en œuvre serait d’utiliser la formule que nous avons vu à l’étape 9 :
arctan (x) = x - (x³/3) + (x⁵/5) - (x⁷/7) + (x⁹/9) - (x¹¹/11)...
Cependant vu que nous sommes seulement calcul d’arctan de nombres sous forme de 1 / x c’est plus logique de redéfinir la formule comme :
arctan(1/x) = (1 / x)-(1/3 x ³) + (1/5x⁵) - (1/7x⁷) + (1/9x⁹) - (1/11 x ¹¹)...
Cela nous donne la fonction suivante en Python :
Cette fonction est un peu plus avancée que nos fonctions précédentes, car elle ne nécessite pas l’utilisateur de saisir le nombre d’itérations pour exécuter. Au lieu de cela, il se penche sur la valeur de .prec () getcontext et détecte que la valeur plus petite que le programme Python peut distinguer de zéro (par exemple si getcontext () .prec = 2, alors la plus petite valeur que Python peut distinguer de 0 est de 0,1).
Il compare ensuite la valeur de la dernière législature dans la séquence : si elle est inférieure à la plus petite valeur que python peut distinguer de 0 alors il n’y a aucun point en remontant pour le programme s’arrête.
Si nous mettons les deux fonctions ensemble, on obtient le programme suivant (gauss_pi_method.py) :
Si vous exécutez cette option pour trouver 10 000 décimales de π, il devrait prendre moins d’une minute. Sur mon ordinateur, il a fallu 17 secondes. C’est beaucoup mieux que le précédent meilleur programme que nous avions, l’une basée sur la méthode des polygones, qui a pris 43 secondes sur mon ordinateur pour calculer 100 décimales de π.
Cependant, nous pouvons faire beaucoup mieux en utilisant la même fonction pour calculer π si nous pourrions calculer arctan(1/x) plus rapidement.
Heureusement, Euler est venu avec une façon de faire exactement cela :
arctan(1/x) = (x / (1 + x²)) + ((2 * x) / (3*(1+x²)²)) + ((2 * 4 * x) / (3*5*(1+x²)³)) + ((2 * 4 * 6 * x) / (3*5*7*(1+x²)⁴)) +...
Le nième terme de cette série est donné par la fonction f (n) :
f (n) = f(n-1) * (2 * n) / ((2*n+1)*(1+x²))
où le premier terme est (x / (1 + x²))
Afin de rendre le code courir plus vite, nous pouvons calculer 1 + x² avant la boucle, alors il faut seulement une fois le calculer. Le code mis à jour (gauss_pi_method_accelerated_arctan.py) est :
Ce code a pris un peu plus d’une demi-seconde pour calculer π à 10 000 chiffres, c’est environ 30 fois plus rapide qu’avant !
Il y a une astuce pour rendre le code courir encore plus vite. Jusqu’ici nous avons utilisé la bibliothèque décimale en Python. Toutefois, si nous faisons les calculs à l’aide de tout entiers, il sera beaucoup plus rapide. Pour ce faire, nous avons d’abord multiplier la valeur de départ par les grandes puissances de 10 et plus tard, quand nous voulons utiliser le résultat, nous diviser par ce même pouvoir de 10. Voici comment le code ressemblera (gauss_pi_method_fixed_point.py) :
Cette version du code calculé 10 000 décimales de π en 0,26 secondes seulement, qui est presque deux fois aussi rapide que la méthode précédente !