Bonjour,
Je suis eleve a l'insa et on m'a demandé de faire plusieurs algorithmes sur les series pour la rentrée.
Je bloque en fait sur 2 d'entre eux.
Le premier est tel que : On veut obtenir une table de la fonction cos pour x variant de 0 a pi par pas de pi/n ou n est un entier >0 introduit au clavier par l'utilisateur en utilisant la formule :
cos x = somme de 0 a pi de ((-1)^p *(x^2p)/(2p)!);  
(c'est le developpement limité de la fonction cosx en série de Taylor).
 
Pour l'instant j'ai realisé le programme avec dev-c++,et il fonctionne mais je n'arrive pas a repondre a quelques questions que mon professeur m'a posé:
1)Que constate-t-on pour certaines valeurs de n?
2) Quelle est la cause de l'anomalie observée?
3) Comment y remédier?
Le voici:
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
main()
{
      float x,s,t,xx;
      int p,n;
      printf("Entrez un entier n >0\n" );
      scanf("%d",&n);
      for(x==0;x<=M_PI;x=x+(M_PI/n))
      {
      xx=pow(x,2);
      p=0;
      t=1;
      s=1;
          while(fabs(t/s)>1e-6)
          {
          p++;
          t=-t*(xx/(2*p-1)*(2*p));
          s=s+t;                  
          }
          printf("cos(%e)=%e\n",x,s);
      }
system ("pause" );
}  
 
Le second est tel que: calcul d'approximation de pi.
Soit la série de Leibniz : pi/4=somme de 0 a l'infini de ( (-1)^p / (2p+1)).
Elle converge tres lentement. On peut lui appliquer des methodes d'acceleration de convergence.
Par exemple:
(2) pi/4=(1-1/3)+(1/5-1/7)+... = somme de 0 a l'infini de (2/(4p+1)*(4p+3)).
=> on obtient une valeur de pi par defaut.
(4) pi/4=1-(1/3-1/5)-(1/7-1/9)-...=1 - somme de 0 a l'infini de (2/(4p+3)*(4p+5)).
=> on obtient une valeur de pi par exces.
On peut aussi faire la moyenne arithmetique entre la formule (2) et (3) et on obtient ainsi (c'est moi qui l'ai calculé):
(4) pi/4 = 1/2 + 4*somme de 0 a l'infini de  (1/(4p+1)*(4p+3)*(4p+5)).
Les questions :
Programmer les formules pour obtenir des valeurs approchées de pi et comparer les resultats lorsqu'on fixe le nombre de termes calculés.
Verifier egalement qu'au dela d'un certain rang les calculs sont inutiles car une limite numerique a été atteinte.
Ici, j'ai programmé la série de Leibniz a l'état initial et ça donne:
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
main()
{
      float t,s;
      int p,n;
      p=0;
      t=1;
      s=1;
      printf("Entrez un entier n >0\n" );
      scanf("%d",&n);
      while(p<n)
      {
                p++;
                t=-(t*(2*p-1))/(2*p+1);
                s=s+t;
      }
      s=4*s;
      printf("%e\n",s);
      system ("pause" );
}                
Mais j'ai aussi essayé de programmer la série (4) et ça ne fonctionne pas.
La voici:
#include<stdlib.h>
#include<stdio.h>
#include<math.h>
main()
{
      float t,s;
      int p,n;
      p=0;
      t=23/30;
      s=23/30;
      printf("Entrez un entier n >0\n" );
      scanf("%d",&n);
      while(p<n)
      {
                p++;
                t=t+(4/(4*p+1)*(4*p+3)*(4*p+5));
                s=s+t;
      }
      s=4*s;
      printf("%e\n",s);
      system ("pause" );
}                
Je ne pense pas que mes systemes recurrents posent problemes, alors je vous demande qu'est ce qui pourrait clocher?
Je vous remercie par avance.  
Bye. Florian.

Regarde par là http://www.mines.inpl-nancy.fr/~to [...] fo015.html et tu devrais comprndre pourquoi il y a une limite  

Si j'ai bien compris, le probleme vient du fait que l'exposant occupe un espace trop reduit pour pouvoir representer les reels-machines calculés a partir d'un certain rang... est-ce ça?

Il n'y a pas que le problème des exposants, il y a aussi le problème de la mentisse qui n'a pas une précision absolue... Tu peux repousser un peu cette limite en utilisant des double à la place des float mais elle existe toujours...