Méthode de Simpson

Version imprimable

Méthode de Simpson

Bonjour,
Après avoir fait le programme pour calculer une intégrale sur un domaine ]a,b[ par la méthode de Simpson, je me casse la tête pour savoir où est l'erreur.
Pouvez-vous alors m'aider ?
Merci
Voilà mon code :

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
 
          program simpsone
          real inte
          CALL simpson(0.0,1.0,100,F,inte)
          print*,'integrale entre 0 et 1 de F =',inte
          end
 
          real function F(X)
          real X
          F = X
          return
          end
 
 
 
          subroutine simpson(A,B,m,F,REP)
          real A,B,REP,S,V
          integer m,j,i
          S=0.0
          V=0.0
          do i=1,m
             S=S+F(A+(2*i-1)*(B-A)/(2*m))
          enddo
          do j=1,m
             V=V+F(A+j*(B-A)/m)
          enddo
          REP=((B-A)/(3*m))*(F(A)+F(B)+2*S+V)
          end

26/09/2007, 16h48
feynman

C est résolu,
il fallait enlevé ce méchant F:evilred: de la subroutine
merci
26/09/2007, 16h56
feynman

Malgré ca si je donne m=1000000 le programme diverge
pourquoi?
26/09/2007, 17h10
Sylvain Bergeron

Citation:

Envoyé par feynman

Malgré ca si je donne m=1000000 le programme diverge
pourquoi?

En lisant en diagonale ton code, c'est possiblement parce qu'en découpant en millionnième l'interval, tu dépasses la précision des réels simples. Fais un test en augmentant la précision des reals à double precision...

En décimale, les reals ont un peu moins de 7 chiffres de précision. Donc, quand tu découpe l'intervalle en 1 000 000, tu produis une sommation dont les termes sont de l'ordre du millionnième de la somme. Dès lors, il est possible que la somme tourne « dans le vide », que les termes ne soit plus compter dans le total.
26/09/2007, 17h18
feynman

J ai changé tout en double precision et ca na pas marché
26/09/2007, 17h22
Sylvain Bergeron

Montre nous ton code source, sans quoi toute tentative d'explication serait totalement spéculative.

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
 
         program simpsone
          real inte
          CALL simpson(0.0,1.0,100,F,inte)
          print*,'integrale entre 0 et 1 de F =',inte
          end
 
          double precision function F(X)
          double precision X
          F = X
          return
          end
 
 
 
          subroutine simpson(A,B,m,F,REP)
          double precision A,B,REP,S,V
          integer m,j,i
          S=0.0
          V=0.0
          do i=1,m
             S=S+F(A+(2*i-1)*(B-A)/(2*m))
          enddo
          do j=1,m
             V=V+F(A+j*(B-A)/m)
          enddo
          REP=((B-A)/(3*m))*(F(A)+F(B)+2*S+V)
          end

26/09/2007, 18h59
Sylvain Bergeron
Il y a plusieurs erreurs dans ton programme :
- Aucune procédure ne contient de « implicit none », ce qui est une mauvaise habitude de travail
- L'appel à la routine Simpson passe des variables real alors que la routine s'attend à des double precision
- La fonction F doit être déclaré comme double precision et external dans les proédures où elles est référencée
Ces erreurs peuvent être détectées si tu actives le mode « debug » de ton compilateur.