Approximation de pi

Version imprimable

Approximation de pi

Bonjour tous le monde

Bon je suis nouveau au domaine de programmation
J'ai cherché partout mais je ne trouve toujours pas une solution a mon problème :

Citation:

Il y a différentes façons de calculer π en mathématique. L’une d’elle est la méthode des séries infinies, on vous demande de calculer π en utilisant la série ci-dessous :

Citation:

π = 4Σ((-1)k/(2k+1)) ; k= 0, k ∞

et en vérifiant votre résultat contre 3.14159. Afficher la valeur de k pour obtenir le résultat

J'ai réussi à écrire ce code, mais je suis sure qu'il n'est pas correct : j ai vraiment besoin d'aide et merci d'avance
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 #include<iostream> #include<cmath> #include<iomanip> using namespace std; int main (void) { double puiss(1) , terme(1) , division , somme ,epsilon , pi , valeur; int k , i; cout.setf(ios::fixed); epsilon = 0.00001; somme = 0; k = 0; do { k++ ; puiss = puiss * (-1) ; terme = 2*k +1 ; division = puiss / terme; for ( i =1 ; i <= k ; i++) somme += division ; pi = 4* somme ; valeur = fabs( 3.14159- pi ); } while( valeur < epsilon ); cout << k << endl; cout << setw(7) << setprecision(5) << pi << endl; return 0; }

07/02/2013, 18h18
gbdivers
Bonjour et bienvenue sur le forum

Citation:

J'ai réussi à écrire ce code, mais je suis sure qu'il n'est pas correct

Pourquoi dis tu cela ?
Tu as eu un bug ? Il faut le donner
Tu as eu un résultat incorrect ? Il faut le donner aussi

En C++, prend l'habitude de déclarer une variable par ligne, de ne le faire que lorsque tu en as besoin et de l’initialiser tout de suite. Utilise const pour les constantes.
Code:

1 2 3 4 const double epsilon = 0.00001; int k = 0; (...) const double terme = 2*k +1;
Code:

1 2 for ( i =1 ; i <= k ; i++) somme += division;
Ce que tu fais s'appelle une multiplication...

Code:

somme += k * division;

Je suppose que ce n'était pas ça que tu voulais faire

Code:

while( valeur < epsilon );

Tu es sur de vouloir continuer le calcul "tant que le différence est inférieure à epsilon" (et donc arrêter quand la différence est plus grande que epsilon) ?
07/02/2013, 18h29
Rho10

pour les declaration t'as bien raison c'est ce que je dois faire

Mais quand je compile ca me donne la valeur

k=1 et pi = -1.3333

mais moi j'ai besoin de trouvé le k pour que pi sois egale a 3.14159 je pense pas que j'ai erreur dans le epsilon et l'affichage vers la fin .. mais je sais que j'ai foiré quelque part dans les somme et division ce problème m'a pris deux jours mais toujours aucun résultat j'arrive juste pas a trouvé l'erreur

et pour la dernière ligne de

Code:

while( valeur < epsilon );

quand j essaye l'inverse rien ne s,affiche j'imagine que cava vers des calcul infini

Merci pour votre réponse rapide
07/02/2013, 18h41
gbdivers

Oui, le calcul implémenté n'est pas le même que la formule donnée.
Méthode pour résoudre le problème : prend une feuille de papier et un crayon et déroule la formule pour k=0, k=1, k=2, etc. Exécute ensuite ton algorithme sur la feuille de papier, en notant pour chaque ligne de ton code la valeur prise par tes variables.
Tu trouveras ce qui est différent entre les 2
07/02/2013, 22h11
Rho10

ca c'est une leçon que tu ma donné merci
07/02/2013, 22h28
gbdivers

Ce qui veut dire que tu as réussit à résoudre ton problème ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include<iostream>
#include<cmath>
#include<iomanip>
 
using namespace std;
 
int main (void)
{
	const double epsilon = 0.0009;
	const double pi1 = 3.14159;
	int k = 0 ;
	double somme = 0.0;
	double pi2 =0.0;
	double val=0.0;
	cout.setf(ios::fixed);
 
	while ( fabs(val) <= epsilon )
	{
		somme += ((pow(-1.0, k)/(2*k+1))) ;
 
		val = pi1 - 4*somme;
			k++;
	}
	pi2 = 4*somme;
	cout << k << endl;
	cout << setw (7) << setprecision(5) << pi2 <<endl;
	return 0;
}

Bon j'en peux plus la hahaha ca commence a devenir chiant

08/02/2013, 00h35
JolyLoic

Tu n'es plus très loin... D'ailleurs, une autre méthode pour compléter l'étude au crayon ou papier est d'exécuter le code sous débogueur, afin de voir ce qu'il fait vraiment (c'est comme ça que j'ai vu les soucis dans ton code).

Ta condition de boucle est toujours mauvaise : Tu vas continuer tant que ton écart sera inférieur à epsilon, c'est à dire que tu vas t'arrêter très vite...

Par contre, une fois ta condition d'arrêt corrigée, tu va te rendre compte d'un autre problème : Ton écart est initialisé à 0 (quand on te disait d'initialiser au plus vite, c'est initialiser avec la bonne valeur, pas une valeur arbitraire dénuée de sens), c'est à dire qu'à la première évaluation la boucle va s'arrêter : Initialise le donc à une grande valeur arbitraire, ou à double val=pi1 - 4*somme;. Mieux: remet une boucle do/while : C'est bien à la fin de chaque cycle que tu veux évaluer ta condition.

Ayant fait ça, tu auras un programme qui marchera.

Mais qui me semble mauvais...

Quel intérêt de calculer pi si pour ça on a besoin dans l'algorithme de la valeur de pi... Je pense que l'énoncé est plus de calculer pi indépendamment, et d'utiliser la valeur fournie lors du test unitaire de ta fonction, et non comme condition d'arrêt de ta boucle. Quand donc s'arrêter ? Et bien, chaque terme de la série est plus petit que le précédent. Donc quand le nouveau terme de la série est inférieur à un certain seuil, le nombre ne devrait plus trop bouger...

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include<iostream> #include<cmath> #include<iomanip> using namespace std; int main (void) { const double epsilon = 0.00001; const double pi1 = 3.14159; int k = 0 ; double somme = 0.0; double pi2 =0.0; double val=pi1 - 4*somme; cout.setf(ios::fixed); do { somme += ((pow(-1.0, k)/(2*k+1))) ; k++; } while ( (fabs(val) <= epsilon) && (somme <= (pi1/4))); pi2 = 4*somme; cout << k << endl; cout << setw (7) << setprecision(5) << pi2 <<endl; return 0; }
ici j ai ajouté la condition

Code:

&& (somme <= (pi1/4))

mais toujours rien si je change

Code:

(fabs(val) <= epsilon)

et je met plus grand ça va vers des calcul infini je n'ai aucune réponse :( je n ai jamais eu de tel problèmes avec des exercices mais la ça commence a devenir un peu dure

08/02/2013, 16h42
droggo

Hoa,

Un des problèmes avec ce genre de calcul, c'est que les approximations dues à la représentation des réels pour l'ordinateur conduisent rapidement à la divergence des calculs, et il est donc difficile de s'arrêter en fonction d'un écart prédéfini.

Une solution souvent adoptée est plutôt de comparer les écarts successifs entre deux (ou plus) pas de calcul : on continue tant que le nouvel écart est inférieur à celui du tour précédent, OU devient inférieur au maximum fixé.

:)
08/02/2013, 16h47
Rho10

olala je n'ai rien compris de cela je suis encore débutant l'ami hahah
08/02/2013, 16h57
gbdivers

Citation:

Envoyé par Rho10

Afficher la valeur de k pour obtenir le résultat

Je crois que le but de l'exercice est d'avoir une idée du nombre d'itération nécessaire pour réussir à avoir une valeur avec une précision fixée. Dans ces condition, la comparaison avec une valeur donnée de Pi peut se comprendre

Idem pour la précision, avec des doubles et une précision ciblée de 5 chiffres après la virgule, on n'aura pas de problème d'erreur de représentation

@Rho10
Pour le test, tu ne prends pas le problème dans le bon sens. Tu dois réfléchir au test qui sera correct et l'utiliser. C'est pas parce que ça plante qu'il faut tester d'autres conditions, il faut plutôt regarder si tu n'as pas d'erreur ailleurs
En plus, lorsque tu lances le programme, il s'arrête pour k = 1, donc trop vite, la condition actuelle n'est pas correcte

Dans ton code, val n'est pas modifié dans la boucle et pourtant tu le testes dans la condition, c'est normal ?
En plus, tu ne teste plus la différence entre la valeur calculé et la valeur attendue et la tester avec epsilon
C'était mieux avant...

Pour la condition somme <= (pi1/4), c'est pas faux, mais c'est pas forcement une bonne idée de faire la division à chaque boucle
Il est facile d'éviter la division en développant le "*4" dans chaque addition :

Citation:

π = 4 Σ( (-1)^k / (2k+1) )
<=> π = 4 * (1/1 -1/3 + 1/5 - 1/7 ...)
<=> π = Σ( 4 * (-1)^k / (2k+1) )
<=> π = 4 *1/1 - 4*1/3 + 4*1/5 - 4*1/7 ...)

Pour t'aider à débuter le code, tu peux aussi ajouter un cout dans la boucle, qui afficher les intermédiaires de calculs. Actuellement, si je fais ça, j'obtiens :

Citation:

k:1 terme:1.000000 pi:4.000000 error:0.858410

Donc la première itération est correcte. Si on corrige les 2 points signalés (test d'arrêt + calcul de val), on obtient :

Citation:

k:1 terme:1.000000 pi:4.000000 error:0.858410
k:2 terme:-0.333333 pi:2.666667 error:0.474923
k:3 terme:0.200000 pi:3.466667 error:0.325077
k:4 terme:-0.142857 pi:2.895238 error:0.246352
...

Donc les 4 premières itérations (et le suivantes...) sont correctes. Tu n'es plus très loin de la solution...

Pour info, il faut 23xxx itérations ;)
10/02/2013, 14h28
Iradrille

Citation:

Envoyé par gbdivers

Idem pour la précision, avec des doubles et une précision ciblée de 5 chiffres après la virgule, on n'aura pas de problème d'erreur de représentation

Et pourtant 3.14159 semble impossible à représenter dans un double (=3.1415899999999999 chez moi). Ce qui pose des problèmes pour savoir quand s’arrêter d'ailleurs :?

@Rho10, ton epsilon est trop grand, abs(3.14159 - 3.141581) < 0.00001 mais tu n'as pas le bon nombre de chiffres significatifs corrects.

Et tu devrais faire un k--; après être sorti de ta boucle, k sera trop grand de 1 là. (Tu fais le calcul pour k == n, puis tu l'incrémente, donc une fois sorti de ta boucle t'as k == n+1)
18/02/2013, 15h57
oodini

Prochaine étape : réaliser l'exercice en métaprogrammation. :)
18/02/2013, 16h13
gbdivers

J'avais oublié de répondre à Iradrille :aie:

Citation:

Envoyé par Iradrille

Et pourtant 3.14159 semble impossible à représenter dans un double (=3.1415899999999999 chez moi). Ce qui pose des problèmes pour savoir quand s’arrêter d'ailleurs :?

Le fait que 3.14159 n'est pas représentable exactement n'est pas problématique ici. On ne teste par l'égalité, mais que la constante est supérieure à la valeur calculée. On aura forcement un moment où l'epsillon calculé sera supérieur à la constante puis deviendra inférieure, même si l'égalité n'est vérifiée à aucun moment
18/02/2013, 16h25
gbdivers

@oodini
Je te prend au mot... ;)
[Exercice débutant métaprogrammation C++] Calculer Pi à la compilation