Bonjour, présentant une grande connaissance du langage des calculettes casio graph 35+, je me lance dans le python je connais les base mais malgré un nombre conséquent d'essais je me décide a demander de l'aide au pres de vous.

J'aimerai calculer je nombre pi avec la célèbre série Grégory-Leibniz:

π(pi) = (4/1) - (4/3) + (4/5) - (4/7) + (4/9) - (4/11) + (4/13) - (4/15)...

Mon programme étant le suivant j'aimerai savoir pourquoi il se n'arrete pas a la fin et si il contient des erreurs.

Merci d'avance !

import os
y = 0
n = 1
x = 1
pi = 3.141592653589793238462643383279502884197169399375
while abs(y+pi)>=0.0000000000000000000000000000000000000000000000001
    imput (((4/x)*(-1)^n)+y)=y
    n = n + 1
    x = x + 2
    print(y)
os.system("pause")

Oui ton script contient des erreurs (syntaxe et sémantique), et c'est justement pour ça qu'il ne se mets pas en pause.

Oublie os.system, oublie même l'idée de mettre un programme en pause à la fin de son exécution. Un programme pour console doit être exécuté depuis une console !

L'assignation ne se fait que d'un côté:

#Bien
y = 3

#Pas bien
3 = y

Ensuite, je pense que ce n'est pas l'addition que tu souhaites comparer, mais la soustraction (la différence entre les 2 valeurs):

while abs(y-pi)

Je ne comprends pas pourquoi tu utilises la fonction input. Cette fonction sert à demander à l'utilisateur d'entrer une valeur. Ici, son utilisation n'est absolument pas pertinente. On voit bien qu'un schéma se répète dans l'équation (changement de signe à chaque élément, numérateur qui reste identique et dénominateur qui prend que les nombres impairs). À partir de ce constat, on peut commencer à construire le programme . Pour rester dans le simple, on peut définir 3 variables:

• signe: qui prendra à chaque tour de boucle la valeur 1 ou -1
• pi_equation: la valeur de pi qu'on va calculer à chaque tour de boucle
• impair: la valeur du dénominateur qu'on incrémentera de +2 à chaque tour de boucle

Donc initialement, signe = 1, pi_equation = 0 et impair = 1. Et ensuite à chaque tour de boucle les valeurs vont évoluées. Avec ça, je pense que tu peux coder quelque chose de plus logique .

PS: Bonne habitude à prendre: nommer intelligemment les variables. Sur ce petit bout de code (de 11 lignes), à quoi correspondent x, y et n? (pas la peine de me donner une réponse, c'est juste pour souligner le manque de cohérence dans le nommage ).

PS2: Autant te le dire direct, ça va prendre un temps fou pour avoir un résultat pour:

0.0000000000000000000000000000000000000000000000001

Essaie simplement avec 0.00000001 pour te rendre compte du temps que ça prend 

-
Edité par Olygrim 14 février 2016 à 14:03:38

Merci pour votre aide!

Je vous présente ici le programme fonctionnel pour les prochaine personnes qui se risqueront a ce code:(il ne reste plus qu'a rajouter des zéros en décimal a la fin de la 5e ligne pour obtenir plus de précision, mais rappelez vous qu'a chaque décimal de plus le nombre de calcul pour obtenir le résultat est 10 fois supérieur)

pi_equation = 0
impair = 1
signe = 1
pi = 3.14159265358
while abs (pi_equation+pi) >= 0.00001 :
    if  signe%2==0 :
        pi_equation = (((4/impair))+pi_equation)
    else :
        pi_equation = (((4/impair)*(-1))+pi_equation)
    signe = signe + 1
    impair = impair + 2
    print (signe)
print(-pi_equation)

Yop,

Juste pour préciser, d'après certains tests déjà effectués, il me semble que l'on ne peut obtenir une précision inférieure à \(10^{-20}\) en Python ( sauf module externe en tout cas )

-
Edité par BunshinKage 14 février 2016 à 16:41:05

Rooooh ! Calculer Pi, c'est enfantin comme tout.

On fait comme çà : 

Ou alors comme ça : 

C'est quand même pas compliqué, si ?  

Ne me posez pas de questions tout de suite, je file rendre visite à mamy. D'ailleurs, elle connait pi jusqu'à sa 500.000 ème décimale.  

-
Edité par Anonyme 14 février 2016 à 16:56:43

Ton code fonctionne, mais il n'est pas bon (pi_equation n'est pas sensé être négatif). Tu t'es trompé dans les signes. De plus, signe n'est pas une variable à incrémenter, sa valeur doit juste osciller entre la valeur 1 et -1:

pi_equation, impair, signe = 0, 1, 1
pi = 3.14159265358
while abs(pi_equation-pi) >= 0.00001 :
    pi_equation = pi_equation + (signe * 4 / impair)
    signe, impair = -signe, impair + 2

print("A n={}, l'approximation de pi vaut {}".format(impair-2, pi_equation))

HS: Pour insérer du code, il y faut utiliser les balises </> et choisir le langage python

Si tu veux faire des calcules avec de très grands nombres décimaux, utilise le module standard decimal. Sa seule limite c'est l'espace mémoire.

-
Edité par Anonyme 14 février 2016 à 17:37:44