Leibniz formule pour le π - Est-ce bon? (Python)

Je suis en train de faire un exercice qui demande une fonction qui se rapproche de la valeur de pi à l'aide de Leibniz formule. Voici les explications sur Wikipedia:

La pensée logique vient à moi facilement, mais je n'ai pas eu beaucoup de une formation dans les maths, donc je suis un peu perdu quant à ce que le plus à gauche des symboles dans le second représentent. J'ai essayé de rendre le code pi = ( (-1)**n /(2*n + 1) ) * 4, mais qui a renvoyé 1.9999990000005e-06 au lieu de 3.14159..., j'ai donc utilisé un accumulateur motif de la place (depuis le chapitre du guide que c'était dans les mentionne aussi) et il a bien fonctionné. Cependant, je ne peux m'empêcher de penser que c'est un peu artificiel et il y a sans doute une meilleure façon de le faire, compte tenu de Python accent sur la simplicité et de faire des programmes aussi court que possible. C'est le code complet:

def myPi(n):
    denominator = 1
    addto = 1

    for i in range(n):
        denominator = denominator + 2
        addto = addto - (1/denominator)
        denominator = denominator + 2
        addto = addto + (1/denominator)

    pi = addto * 4

    return(pi)

print(myPi(1000000))

Personne ne sait mieux fonctionner?

Que représente - calculer la somme de la joint expression pour n = 0 à l'Infini
Merci pour l'info!
Vous verrez que le plus gros problème n'est pas l'algorithme.
Ouais, les nombres à virgule flottante m'ont donné plus d'un mal de tête depuis que je suis en ce.

InformationsquelleAutor reggaelizard | 2013-08-03

python python-3.x

La capitale sigma ici est notation sigma. C'est la notation utilisée pour représenter une sommation de façon concise.

De sorte que votre somme est en fait une somme infinie. Le premier terme, pour n=0, est:

(-1)**0/(2*0+1)

Il est ajouté à

(-1)**1/(2*1+1)

puis à

(-1)**2/(2*2+1)

et ainsi de suite pour toujours. La sommation est ce qui est connu mathématiquement comme un convergente de somme.

En Python vous l'écrire comme ceci:

def estimate_pi(terms):
    result = 0.0
    for n in range(terms):
        result += (-1.0)**n/(2.0*n+1.0)
    return 4*result

Si vous vouliez optimiser un peu, vous pouvez éviter l'exponentiation.

def estimate_pi(terms):
    result = 0.0
    sign = 1.0
    for n in range(terms):
        result += sign/(2.0*n+1.0)
        sign = -sign
    return 4*result

....

>>> estimate_pi(100)
3.1315929035585537
>>> estimate_pi(1000)
3.140592653839794

InformationsquelleAutor David Heffernan

4

La formule de Leibniz se traduit directement en Python avec pas de muss ou de chichi:
```
>>> steps = 1000000
>>> sum((-1.0)**n / (2.0*n+1.0) for n in reversed(range(steps))) * 4
3.1415916535897934
```
InformationsquelleAutor Raymond Hettinger
1

À l'aide pur Python, vous pouvez faire quelque chose comme:
```
def term(n):
    return ( (-1.)**n / (2.*n + 1.) )*4.

def pi(nterms):
    return sum(map(term,range(nterms)))
```
puis de calculer pi avec le nombre de termes que vous avez besoin pour atteindre une précision donnée:
```
pi(100)
# 3.13159290356

pi(1000)
# 3.14059265384
```
InformationsquelleAutor Saullo G. P. Castro

C'était mon approche:

def estPi(terms):
    outPut = 0.0
    for i in range (1, (2 * terms), 4):
        outPut = (outPut + (1/i) - (1/(i+2)))
    return 4 * outPut

Je prends du nombre de termes de l'utilisateur veut, puis dans la boucle for je le double en compte uniquement à l'aide de la cote.

at 100 terms I get        3.1315929035585537
at 1000 terms I get       3.140592653839794
at 10000 terms I get      3.1414926535900345
at 100000 terms I get     3.1415826535897198
at 1000000 terms I get    3.1415916535897743
at 10000000 terms I get   3.1415925535897915
at 100000000 terms I get  3.141592643589326
at 1000000000 terms I get 3.1415926525880504
Actual Pi is              3.1415926535897932

Suis pour l'amour d'une série convergente.

InformationsquelleAutor user3220980

-1

La version suivante utilise la formule de Ramanujan comme indiqué dans cette SORTE de post - it utilise une relation entre le pi et le "monstre de groupe", tel que discuté dans cet article.

import math

def Pi(x):
    Pi = 0
    Add = 0
    for i in range(x):
        Add =(math.factorial(4*i) * (1103 + 26390*i))/(((math.factorial(i))**4)*(396**(4*i)))
        Pi = Pi + (((math.sqrt(8))/(9801))*Add)
    Pi = 1/Pi
    print(Pi)

Pi(100)

InformationsquelleAutor Jasper Tresidder

Vous devez vous connecter pour publier un commentaire.