Algorithmique numrique et arithmtique : TP4

Arthur Cormerais Victor Cameo Ponz 15 juin 2011

Introduction
Le but de ce TP est dtudier le comportement de la convergence sur machine de la suite rcurrente suivant : un = 111 1130 3000 + un1 un2 un1
11 2 61 11

(1)

avec les conditions initiales suivantes : u0 = u1 = (2)

Pour ce faire nous allons utiliser plusieurs mthodes, dans une premier temps nous ferons une tude thorique de cette suite (i.e. points xes, convergence thorique). Puis nous implmenterons cette suite en C en double et simple prcision. Pour terminer nous chercherons un moyen de montrer la convergence de cette suite sur machine. Cette suite est une suite rcurrente instable, cest dire que la syntaxe dans laquelle la suite est prsent est trs favorable la propagation derreurs d aux arrondis.

1
1.1

Etude de thorique de un
Les points xes

Soit x la limite de un quand n +. Pour trouver les points xes de un on remplace un , un1 et un2 par x dans lquation (1). On obtient lquation suivante : 1130 3000 + 2 x x 1130 3000 0 = 111 x + 2 x x x3 + 111x2 1130x + 3000 0 = x2 3 2 0 = x 111x + 1130x 3000 x = 111

(3) (4) (5) (6)

Figure 1 Visualisation des points xes de la suite un . On retrouve un polynme de degrs 3, on trouve les trois racines : (1 , 2 , 3 ) = (5, 6, 100). On peut les voir sur la courbe suivante (gure 1) : Nous avons donc trois valeurs possibles de convergence pour cette suite, et celle-ci dpendra des conditions initiales.

1.2

La convergence de un

Dans cette partie on cherche une expression de un tel que un = f (n). Pour ce faire nous allons poser : un = vn+1 vn (7)

On remplace alors un , un1 et un2 par leurs quivalent en fonction de vn dans lquation (1). On obtient lquation suivante : vn+1 vn vn+1 vn vn+1 1130
vn vn1

= = =

111

3000
vn1 vn1 vn2 vn

(8) (9) (10)

1 (111vn 1130vn1 + 3000vn2 ) vk 111vn 1130vn1 + 3000vn2

On tudie alors le polynme caractristique dordre 3 dnit par la suite vn : x3 = 111x2 1130x + 3000 (11)

Comme on la vu prcdemment ce polynme 3 racines relles : 5,6 et 100. On peut donc crire la suite vn en fonction de n : vn = 5k + 6k + 100k (12)

Les trois constantes , et dpendent des conditions initiales. On retrouve grce lquation (7), les condition initiales de la suite vn : v0 v1 v2 = 1 11 = 2 61 = 2 (13) (14) (15)

On pose le systme suivant pour trouver , et : 1 1 1 v0 5 6 100 = v1 25 36 10000 v2

(16)

On rsout facilement ce systme linaire (avec la mthode de Gauss par exemple) et on obtient la solution suivante : 0, 5 = 0, 5 (17) 0 Dou lexpression de la suite vn suivante : vn = 5k + 6k 2 (18)

Nous remarquons ici que = 0 ce qui peut avoir une forte inuence sur le comportement de la convergence sur machine. Daprs les calcul prcdents on a rigoureusement, avec les condition initiale donnes de un la proprit suivante : 5k+1 + 6k+1 (19) 5k + 6k On doit donc chercher la limite de un , ce qui va savrer trs simple : un = un = = = = Dou la proprit suivante de un :
n

5k+1 + 6k+1 5k + 6k 5 k 6 (5( 6 )k 6) 6k (( 5 )k 1) 6

5 5( 6 )k 6 5 k (6) 1 5 6 5( 6 )k 5 1 ( 6 )k

(20) (21) (22) (23)

lim un = 6

(24)

Il est facile de voir que si la suite vn avait eu un coecient = 0, mme trs petite, la suite un aurait alors converg vers 100. De mme si en plus de de = 0 on avait eu = 0 la suite un aurait converg vers 5. A partir de ces 3

constatations on pourrait facilement trouver les conditions initiales de un pour quelle converge vers 5,6 ou 100 partir du systme dquation (16). La mauvaise syntaxe de la suite un pourrait expliquer lintroduction de cette composante non nulle , d des erreurs darrondis, qui perturberai alors la convergence machine de la suite de 6 vers 100. Nous allons donc maintenant tudier le comportement de cette suite sur machine.

2
2.1

Convergence de un sur machine

Codage des direntes reprsentation de un en C

On implmente la suite un sous la forme donne au dpart, correspondant la formule (1) et sous la forme ou un dpend uniquement de n, correspondant la formule (19). On peut trouver limplmentation en Annexe en partie A page 8. Voici la sortie que lon observe : Sortie de un.c
1 S u i t e mal p o s e e en s i m p l e p r e c i s i o n 5.590164 5.633438 5.674782 5.715675 5.790154 6.490219 16.722908 71.068787 97.624153 99.857391 99.991600 99.999504 99.999969 100.000000 100.000000 L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : 1 0 0 . 0 0 0 0 0 0 S u i t e mal p o s e e en d o u b l e p r e c i s i o n 5.590164 5.633431 5.674649 5.713329 5.749121 5.781811 5.811314 5.837656 5.860948 5.881320 5.898177 5.897965 5.647011 0.968340 507.321605 107.120635 100.395942 100.023519

11

16

21

26

31

36

41

46

51

56

61

66

71

76

81

100.001404 100.000084 100.000005 100.000000 100.000000 100.000000 100.000000 100.000000 100.000000 100.000000 100.000000 100.000000 L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : 1 0 0 . 0 0 0 0 0 0 S u i t e b i e n p o s e e en s i m p l e p r e c i s i o n 5.545455 5.590164 5.633431 5.674649 // . . . Quelques l i g n e p l u s t a r d // 5.999998 5.999998 5.999999 5.999999 L i m i t e de l a s u i t e b i e n p o s e e en s i m p l e p r e c i s i o n : 5 . 9 9 9 9 9 9 S u i t e b i e n p o s e e en d o u b l e p r e c i s i o n 5.545455 5.590164 5.633431 5.674649 // . . . Beaucoup de l i g n e s p l u s t a r d // 6.000000 6.000000 6.000000 6.000000 6.000000 6.000000 L i m i t e de l a s u i t e b i e n p o s e e en d o u b l e p r e c i s i o n : 6 . 0 0 0 0 0 0

On remarque que les deux suites mal codes ne converge pas du tout vers la limite attendue. Il est intressant de voir que pour les deux prcisions, les suites se rapprochent de 6 dans un premier temps puis dcroche. Ceci peut tre expliqu par lapparition dune composante (vue en partie 1.2, page 3) non nulle engendre par des erreurs darrondis qui change un tout petit peu les condition initiales. Etant donn que la suite est cod de manire rcurrente lerreur se propage. On a vu aussi quune composante mme inme engendrait une convergence de un vers 100. Cela explique donc lerreur de rsultat. En revanche, les deux suite bien poses converge toutes deux vers 6, la limite attendue. Dans cette reprsentation de la suite le est x 0 une fois pour toute ce qui empche la propagation derreurs.

2.2

Codage de un mal pose en C avec lutilisation de la librairie Cadna

On implmente donc la suite mal pos en utilisant CADNA (Le code est toujours disponible en Annexes portie B page 9) Nous remarquons que la librairie Cadna, qui eectue un controle stochastique des erreurs, remarque lapparition dinstabilits. CADNA stoppe alors le programme avant la propagation de ces erreurs, et nous remarquons bien que la suite na pas encore "dcroch", elle sarrte proche de 6 dans les deux cas. Cest donc bien un problme de stabilit qui est lorigine de lerreur de convergence.

2.3

Mapple

Mapple faisant des calculs exactes, cest dire en laissant sous forme fractionnaire, obtient donc la bonne limite : 6. La condition darrt est x 230 , mais on peut facilement la x bien plus bas. Elle est largement susante pour observer la convergence. Le script Mapple est disponible en Annexes, partie C page 9.

Conclusion
Ce TP fut trs intressant, cela nous apprend nous mer de plus en plus des rsultats machines et toujours vrier par la thorie les chires obtenus. Cette suite met en vidence les limites de larithmtique limite, ainsi que leurs consquences parfois incroyables sur les rsultats obtenus. Sur certaines suites lorsquune erreur darrondi apparait, la propagation de cette erreur amplie considrablement les comportements originaux. Il faut bien tudier le problme mathmatique avant dattaquer un rsolution informatique an de dceler les ventuelles erreurs que la future implmentation machine va commettre. Il faut trouver la bonne formulation, cest dire celle qui vitera les erreurs machine et leur propagation.

Annexes
A Codage brut en C
un.c
#include<s t d i o . h> #include<math . h> i n t main ( ) { double l i m F l o a t , limDouble ; l i m F l o a t = pow(2 , 24) ; limDouble = pow(2 , 53) ; 10 p r i n t f ( " \ n" ) ; printf (" S u i t e mal p o s e e en s i m p l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; f l o a t us_2 , us_1 , us_0 ; us_0 = 1 1 . / 2 . ; us_1 = 6 1 . / 1 1 . ; do{ us_2 = 1 1 1 . 1130/ us_1 + 3 0 0 0 / ( us_1us_0 ) ; us_0 = us_1 ; us_1 = us_2 ; p r i n t f ( "%f \n" , us_2 ) ; } while ( f a b s ( us_1 us_0 ) > l i m F l o a t ) ; p r i n t f ( " L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : %f \n" , us_2 ) ; p r i n t f ( " \ n" ) ; printf (" S u i t e mal p o s e e en d o u b l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; double ud_2 , ud_1 , ud_0 ; ud_0 = 1 1 . / 2 . ; ud_1 = 6 1 . / 1 1 . ; do{ ud_2 = 111 1130/ud_1 + 3 0 0 0 / ( ud_1ud_0 ) ; ud_0 = ud_1 ; ud_1 = ud_2 ; p r i n t f ( "%l f \n" , ud_2 ) ; } while ( f a b s ( ud_1 ud_0 ) > limDouble ) ; p r i n t f ( " L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : %l f \n" , ud_2 ) ; p r i n t f ( " \ n" ) ; printf (" S u i t e b i e n p o s e e en s i m p l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; f l o a t us_n = 1 1 . / 2 . ; i n t n=1;

15

20

25

30

35

40

45 do{ us_1=us_n ; us_n=(pow ( 5 . , n+1)+pow ( 6 . , n+1) ) / ( pow ( 5 . , n )+pow ( 6 . , n ) ); p r i n t f ( "%f \n" , us_n ) ; n++;

50

} while ( f a b s ( us_1 us_n ) > l i m F l o a t ) ; p r i n t f ( " L i m i t e de l a s u i t e b i e n p o s e e en s i m p l e p r e c i s i o n : %f \n" , us_n ) ; 55 p r i n t f ( " \ n" ) ; printf (" S u i t e b i e n p o s e e en d o u b l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; double ud_n = 1 1 . / 2 . ; n=1; do{ ud_1=ud_n ; ud_n=(pow ( 5 . , n+1)+pow ( 6 . , n+1) ) / ( pow ( 5 . , n )+pow ( 6 . , n ) ); p r i n t f ( "%f \n" , ud_n ) ; n++; } while ( f a b s ( ud_1 ud_n ) > limDouble ) ; p r i n t f ( " L i m i t e de l a s u i t e b i e n p o s e e en d o u b l e p r e c i s i o n : %f \n" , ud_n ) ;

60

65

70

return 0 ; }

Codage en C avec CADNA

unCadna.cc

#include<cadna . h> #include<s t d i o . h> #include<math . h> i n t main ( ) { c a d n a _ i n i t ( 1) ; d o u b l e _ s t limDouble ; float_st limFloat ; l i m F l o a t = pow ( 2 . , 2 4 . ) ; limDouble = pow ( 2 . , 5 3 . ) ;

13

p r i n t f ( " \ n" ) ; printf (" S u i t e mal p o s e e en s i m p l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; f l o a t _ s t us_2 , us_1 , us_0 ; us_0 = 1 1 . / 2 . ; us_1 = 6 1 . / 1 1 . ; do{ us_2 = 1 1 1 . 0 1 1 3 0 . 0 / ( us_1 ) + 3 0 0 0 . 0 / ( us_1us_0 ) ; us_0 = us_1 ; us_1 = us_2 ; p r i n t f ( "%s \n" , s t r p ( us_2 ) ) ; } while ( f a b s f ( us_1 us_0 ) > l i m F l o a t ) ; p r i n t f ( " L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : %s \n" , s t r p ( us_2 ) ) ; p r i n t f ( " \ n" ) ;

18

23

28

printf (" S u i t e mal p o s e e en d o u b l e p r e c i s i o n \n" ) ; p r i n t f ( " \ n" ) ; d o u b l e _ s t ud_2 , ud_1 , ud_0 ; 33 ud_0 = 1 1 . / 2 . ; ud_1 = 6 1 . / 1 1 . ; do{ ud_2 = 1 1 1 . 0 1 1 3 0 . 0 / ( ud_1 ) + 3 0 0 0 . 0 / ( ud_1ud_0 ) ; ud_0 = ud_1 ; ud_1 = ud_2 ; p r i n t f ( "%s \n" , s t r p ( ud_2 ) ) ; } while ( f a b s f ( ud_1 ud_0 ) > l i m F l o a t ) ; p r i n t f ( " L i m i t e de l a s u i t e mal p o s e e en s i m p l e p r e c i s i o n : %s \n" , s t r p ( ud_2 ) ) ;

38

43 cadna_end ( ) ; return 0 ; }

Codage de un grace Mapple

un.m

> D i g i t s := 1 0 0 ; u0 := 1 1 / 2 ; u1 := 6 1 / 1 1 ; while abs ( u1u0 ) > 2^( 30) do u2 := 111 1130/ u1 +3000/( u1 u0 ) ; u0 := u1 ; u1 := u2 ; end do ; u2 ; > e v a l f ( u2 ) ;