Livre MN Java

METHODES NUMERIQUES APPLIQUEES cours, exercices corrig es et mise en uvre en JAVA
M.A. Aziz Alaoui et C. Bertelle Facult e des Sciences et Techniques 25 rue Philippe Lebon - BP 540 76058 Le Havre Cedex - France 13 septembre 2002
R esum e On pr esente bri` evement quelques m ethodes num eriques usuelles et e l ementaires a ` lusage des e tudiants en n de premiers cycles scientiques universitaires ou de ceux d ebutant un second cycle. .............. A REVOIR .............. Les math ematiciens et autres scientiques se sont toujours int eress es a ` la r esolution num erique des probl` emes quils rencontrent, lanalyse math ematique classique ne pouvant r esoudre tous les probl` emes qui se posent (par exemple en int egration, e quations diff erentielles, interpolation, r esolution d equations non lin eaires ...). Lint er et des scientiques pour les m ethodes et lanalyse num erique en g en eral, na donc cess e daugmenter. Deux notions sav` erent alors importantes : -lerreur num erique -la notion de stabilit e. Abord ees de mani` ere rapide dans cet ouvrage, nous renvoyons le lecteur a ` des ouvrages sp ecialis es [?, ?] pour approfondir ces notions utiles pour la validation des m ethodes num eriques. Les th eor` emes et propositions e nonc es ne seront pas d emontr es, la plupart sont, ou peuvent e tre facilement, trait es en exercices, nexigeant pas darguments math ematiques profonds. Nous compl etons un certain nombre de chapitres par des petits programmes dapplications en Java o` u lon a privil egi e une lecture facile pour des d ebutants dans ce langage et la programmation objet plut ot que des d eveloppements exhaustifs et g en eriques n ecessitant souvent des constructions e labor ees qui d epassent le cadre des objectifs d enis pour ce manuel. Le choix de Java pour impl ementer des m ethodes num eriques est discutable en raison des faibles performances de calcul des plate-formes de d eveloppement actuelles en Java mais qui sam eliorent r eguli` erement de mani` ere importante. Notre souci premier est avant tout p edagogique et Java est un langage orient e objet propre et qui se veut simple. Sa portabilit e int egrant des possibilit es graphiques int eressantes r epond a ` nos pr eoccupations p edagogiques et de rentabilisation de linvestissement dans un nouveau langage dans une discipline informatique en e volution permanente.
Table des mati` eres

1 ` Java Introduction a 1.1 Pr esentation de Java . . . . . . . . . . . . . . . . . . . . . . . . 1.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.2 Historique . . . . . . . . . . . . . . . . . . . . . . . . . 1.1.3 Une machine virtuelle . . . . . . . . . . . . . . . . . . 1.1.4 Caract eristiques . . . . . . . . . . . . . . . . . . . . . . 1.2 Types primitifs et structures de contr ole . . . . . . . . . . . . . 1.2.1 Types primitifs . . . . . . . . . . . . . . . . . . . . . . 1.2.2 Structures de contr ole . . . . . . . . . . . . . . . . . . 1.3 Classes et objets en Java . . . . . . . . . . . . . . . . . . . . . 1.3.1 D enition dune classe . . . . . . . . . . . . . . . . . . 1.3.2 D eclaration, cr eation et destruction dobjets . . . . . . . 1.3.3 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . 1.3.4 Construction de la classe vecteur . . . . . . . . . . . . . 1.3.5 Composants de type static . . . . . . . . . . . . . . 1.3.6 Composants de type public et de type private . . . 1.3.7 Cha nes de caract` eres . . . . . . . . . . . . . . . . . . . 1.4 Organisation des chiers sources dun programme Java . . . . . 1.4.1 Structure des chiers sources . . . . . . . . . . . . . . . 1.4.2 Commandes de compilation et de lancement dun programme . . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.3 Packages . . . . . . . . . . . . . . . . . . . . . . . . . 1.4.4 Visibilit e des composants dans les packages . . . . . . . 1.4.5 packages pr ed enis en Java . . . . . . . . . . . . . . . 1.5 H eritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.5.1 Construire une classe d eriv ee . . . . . . . . . . . . . . . 1.5.2 Constructeur dune classe d eriv ee . . . . . . . . . . . . 1.5.3 Accessibilit e : public, protected et private . . . . . . . . 1.5.4 M ethodes virtuelles et classes abstraites . . . . . . . . . 1.5.5 Un exemple : quelques objets g eom etriques . . . . . . . 2 2 2 2 3 3 4 4 4 5 5 5 6 7 10 11 12 14 14 14 15 16 16 17 17 18 18 19 20
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
M ethodes num eriques avec Java

1.5.6 Interfaces . . . . . . . . . . . . . . . . . . . . . . . 1.5.7 Passage dune fonction en param` etre dune m ethode Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.6.1 Notions g en erales . . . . . . . . . . . . . . . . . . . 1.6.2 D enir sa propre exception . . . . . . . . . . . . . . Entr ees/Sorties . . . . . . . . . . . . . . . . . . . . . . . . 1.7.1 Classes de gestion de ux . . . . . . . . . . . . . . 1.7.2 Saisies au clavier . . . . . . . . . . . . . . . . . . . 1.7.3 Lecture dun chier . . . . . . . . . . . . . . . . . . 1.7.4 Ecriture dans un chier . . . . . . . . . . . . . . . . 1.7.5 Compl ements . . . . . . . . . . . . . . . . . . . . . Conclusion provisoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2 23 24 26 26 27 29 29 30 31 33 33 34 35 35 36 39 41 41 42 43 43 44 44 45 47 51 61 61 63 66 68 69 69 69 70 71 73 75
1.6
1.7
1.8 2
quations non lin R esolution des e eraires dans 2.1 Localisation (ou s eparation) des racines . . . . . . . . . . . . . 2.2 M ethode des approximations successives . . . . . . . . . . . . . 2.3 Ordre dune m ethode . . . . . . . . . . . . . . . . . . . . . . . 2.4 Exemples de m ethodes it eratives . . . . . . . . . . . . . . . . . 2.4.1 M ethode de Lagrange (ou de la corde) . . . . . . . . . . 2.4.2 M ethode de Newton . . . . . . . . . . . . . . . . . . . 2.5 Acc eleration de la convergence . . . . . . . . . . . . . . . . . . dAitken . . . . . . . 2.5.1 M ethode dAitken, ou Proc ed e 2.5.2 M ethode de Steffensen, exemple de composition de m ethodes . . . . . . . . . . . . . . . . . . . . . . . . . 2.5.3 M ethode de Regula-Falsi . . . . . . . . . . . . . . . . . 2.6 Enonc es des exercices corrig es . . . . . . . . . . . . . . . . . . 2.7 Enonc es des exercices non corrig es . . . . . . . . . . . . . . . . 2.8 Corrig es des exercices . . . . . . . . . . . . . . . . . . . . . . 2.9 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . 2.9.1 Une classe abstraite de description de processus it eratifs 2.9.2 La m ethode de Lagrange . . . . . . . . . . . . . . . . . 2.9.3 La m ethode de Steffensen . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . .
R esolution des syst` emes lin eaires 3.1 M ethode d elimination de Gauss . . . . . . . 3.1.1 R esolution dun syst` eme triangulaire . 3.1.2 M ethode de Gauss . . . . . . . . . . 3.1.3 Factorisation . . . . . . . . . . . 3.1.4 Remarque sur le Pivot . . . . . . . . 3.2 Enonc es des exercices corrig es . . . . . . . . 3.3 Enonc es des exercices non corrig es . . . . . .

. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .
. . . . . . .

3.4 3.5 Corrig es des exercices . . . . . . . . . . . . . . . . . . . . . . Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . 3.5.1 Les tableaux multidimensionnels en Java . . . . . . . . 3.5.2 Une classe matrice . . . . . . . . . . . . . . . . . . . . 3.5.3 Une classe abstraite de syst` eme lin eaire . . . . . . . . . 3.5.4 Les classes syst` emes lin eaires triangulaires . . . . . . . 3.5.5 La classe syst` emes lin eaires g en erals impl ementant la factorisation LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3 77 85 85 85 90 91 97 102 102 102 103 104 104 104 104 106 110 110 111 112 115 118 118 118 120 121 123 124 132 141 141 142 144 147 149
Graphisme scientique avec Java 4.1 Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.1 Un premier exemple . . . . . . . . . . . . . . . . . . . . 4.1.2 Passage de param` etres . . . . . . . . . . . . . . . . . . . 4.1.3 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.4 Compl ements . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Gestion de fen etres avec AWT . . . . . . . . . . . . . . . . . . . 4.2.1 Trac es dans des applets . . . . . . . . . . . . . . . . . . . 4.2.2 Construire des interfaces fen etr ees . . . . . . . . . . . . . 4.3 Construction de courbes de trac es scientiques . . . . . . . . . . 4.3.1 Les domaines bidimensionnels de lutilisateur et du dispositif dafchage . . . . . . . . . . . . . . . . . . . . . 4.3.2 Un gestionnaire de fen etres de base . . . . . . . . . . . . 4.3.3 Une classe dutilitaires pour le trac e de graphismes scientiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.4 Un exemple dutilisation . . . . . . . . . . . . . . . . . . Interpolation Polyn omiale 5.1 Introduction. Existence et unicit e du polyn ome dinterpolation 5.2 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . 5.3 Interpolation dHermite . . . . . . . . . . . . . . . . . . . . 5.4 Enonc es des Exercices Corrig es . . . . . . . . . . . . . . . . 5.5 Enonc es des exercices non corrig es . . . . . . . . . . . . . . . 5.6 Corrig es des exercices . . . . . . . . . . . . . . . . . . . . . 5.7 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . Approximation par moindres carr es 6.1 Principe dapproximation et crit` ere de moindres carr es 6.2 R egression lin eaire . . . . . . . . . . . . . . . . . . . 6.2.1 Mise en uvre en Java . . . . . . . . . . . . . 6.3 G en eralisation aux mod` eles lin eaires . . . . . . . . . . 6.3.1 Ecriture matricielle du probl` eme . . . . . . . .
. . . . . . .
. . . . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .

6.3.2 Mise en uvre en Java . . Enonc es des exercices corrig es . . Enonc es des exercices non corrig es Corrig es des exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4 150 160 161 161 162 162 162 163 163 164 165 168 170 173 179 179 180 181 182 183 186 186 187 189 189 190 190 190 190 192 193 197 203 211 211 215
6.4 6.5 6.6 7
Int egration Num erique 7.1 M ethodes des Rectangles . . . . . . . . . . . . . . . . . . . . . . 7.1.1 M ethode des Rectangles sup erieurs et inf erieurs . . . . . . 7.1.2 M ethode des r ectangles points-milieux . . . . . . . . . . 7.2 M ethodes des trap` ezes . . . . . . . . . . . . . . . . . . . . . . . 7.3 M ethode de Simpson . . . . . . . . . . . . . . . . . . . . . . . . 7.4 M ethode de Romberg . . . . . . . . . . . . . . . . . . . . . . . . 7.5 Enonc es des exercices corrig es . . . . . . . . . . . . . . . . . . . 7.6 Enonc es des exercices non corrig es . . . . . . . . . . . . . . . . . 7.7 Corrig es des exercices . . . . . . . . . . . . . . . . . . . . . . . 7.8 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 7.8.1 Des classes abstraites dint egration num erique . . . . . . 7.8.2 Des classes dimpl ementation de la m ethode des trap` ezes . 7.8.3 Des classes dimpl ementation de la m ethode de Simpson . 7.8.4 Un programme de test des m ethodes des trap` ezes et de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . 7.8.5 Mise en uvre de la m ethode de Romberg . . . . . . . . . quations diff R esolution Num erique des e erentielles 8.1 Introduction, le probl` eme math ematique . . . . . . . . . . 8.2 La M ethode dEuler . . . . . . . . . . . . . . . . . . . . . 8.2.1 Etude de lerreur dEuler . . . . . . . . . . . . . . 8.3 M ethodes de Taylor dordre deux . . . . . . . . . . . . . . 8.4 M ethodes de Runge-Kutta . . . . . . . . . . . . . . . . . 8.4.1 Runge-Kutta dordre 2 : RK2 . . . . . . . . . . . 8.4.2 Runge-Kutta dordre 4 : RK4 . . . . . . . . . . . 8.5 G en eralit es sur les m ethodes a ` un pas . . . . . . . . . . . 8.6 R esolution de syst` emes diff erentiels dans IR . . . . . . . 8.7 Enonc es des exercices corrig es . . . . . . . . . . . . . . . 8.8 Enonc es des exercices non corrig es . . . . . . . . . . . . . 8.9 Corrig es des exercices . . . . . . . . . . . . . . . . . . . 8.10 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . 8.10.1 R esolution num erique des e quations diff erentielles 8.10.2 R esolution num erique des syst` emes diff erentiels .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
. . . . . . . . . . . . . . .
Chapitre 1 ` Java Introduction a

Lobjectif de ce chapitre nest pas de faire une pr esentation exhaustive de Java, mais den donner les notions essentielles au lecteur qui ny est pas coutumier, pour quil en saisisse lesprit et puisse comprendre les d eveloppements dapplications de m ethodes num eriques qui seront faites dans les chapitres suivants. Le lecteur d esirant des renseignements plus complets sur ce langage pourra consulter, par exemple [?, ?]. Nous supposons, par ailleurs, que le lecteur a une connaissance pr ealable dun langage de programmation e volu e - C par exemple - mais pas n ecessairement en programmation objet. On peut consid erer que cest le cas de la majorit e des e tudiants en premier cycle scientique.
1.1
1.1.1
Pr esentation de Java
Objectifs
Le langage Java a e t e d evelopp e an de pouvoir g en erer des applications qui soient ind ependantes des machines et de leur syst` eme dexploitation. Une des autres caract eristiques du langage est de pouvoir e crire des applications structurellement distribu ees sur des r eseaux. Il appartient, par ailleurs, a ` la famille des langages objets purs o` u rien ne peut exister en dehors des classes.
1.1.2
Historique
Au d ebut des ann ees 1990, une e quipe de d eveloppeurs de la soci et e SUN Microsystems travaille sur limpl ementation du langage OAK pour lint egrer en domotique, notamment pour le d eveloppement de la t el evision interactive. Il fallait que les codes des applications dans ce langage soit peu volumineux, efcaces
et ind ependants de larchitecture. A cette e poque, la t el evision interactive na pas connue lessor escompt e alors que le d eveloppement dInternet et du Web faisait appara tre des besoins urgents de m eme nature. En 1995, OAK devient Java et se trouve popularis e rapidement pour ses possibilit es de d eveloppement li es au Web. Les ann ees qui suivent font conna tre a ` Java une popularit e en tant que langage g en eraliste qui d epasse les pr evisions de SUN. Les grands industriels du d eveloppement ladopte rapidement en lespace de quelques ann ees. Pour les ann ees a ` venir, les industriels projettent la cr eation de puces e lectroniques d edi ees a ` Java ... un juste retour vers les pr eoccupations initiales des concepteurs originaux de OAK/Java. Certes Java est un langage propri etaire, mais de licence ouverte, ce qui lui a permis de se faire adopter par tous les professionnels du d eveloppement avec un engouement sans pr ec edent par rapport aux autres langages plus anciens.
1.1.3
Une machine virtuelle
Le langage Java est un langage compil e et interpr et e. Cette d enition contradictoire sexplique par le fait que le code source est transform e dans un byte-code universel ex ecutable par une machine virtuelle. Cette machine virtuelle peut e tre install ee a ` partir dune distribution du langage comme le Java Development Kit (JDK) de SUN. Elle peut e tre e galement int egr ee sous une forme compact ee dans un navigateur an quil puisse ex ecuter des applets Java. Ces caract eristiques conf` erent au langage des propri et es de portabilit e sans pr ec edents, mais ont aussi un co ut correspondant au fonctionnement de la machine virtuelle qui r eduit les performances dex ecution du programme. An de r esoudre ce probl` eme, un effort important est consenti pour d evelopper des compilateurs a ` la vol ee en code machine qui fonctionnent lors de lex ecution du programme (compilateurs identi es sous la d enomination de JIT - Just In Time).
1.1.4
Caract eristiques
Le langage Java poss` ede une syntaxe inspir ee du C++. Il se veut plus propre en terme de d eveloppement objet, ne permettant pas de construction en dehors des classes. Il se veut aussi plus simple en affranchissant le programmeur de toute la gestion dynamique des objets construits, gr ace au fonctionnement dun ramassemiettes (Garbage Collector) dont la fonction est didentier et d eliminer tous les objets qui ne sont plus r ef erenc es. Java propose des ex ecutions parall` eles de programmes gr ace a ` une utilisation qui se veut plus facile des threads (ou processus l egers) par rapport au langage C. Il poss` ede e galement des aspects li es a ` la distribution gr ace a ` ses possibilit es dint egration dans des documents Web distribu es par les applets, mais e galement
avec la biblioth` eque RMI (Remote Methods Invocation) qui propose de la programmation dobjets r epartis. L evolution de cette biblioth` eque la fait converger progressivement vers CORBA, le standard dans le domaine des objets r epartis. Les biblioth` eques CORBA sont aujourdhui int egr ees dans les distributions du JDK 1.2 ou sup erieures de SUN. Dans cet ouvrage o` u Java sert de langage e l ementaire dimpl ementation de m ethodes num eriques, les threads et la programmation en objets distribu es ne seront pas utilis es. Le parall elisme et la programmation distribu ee sont ind eniablement des apports r ecents et majeurs en calcul scientique et feront certainement lobjet douvrages sp eciques compl ementaires a ` celui que nous pr esentons ici.
1.2
1.2.1
Types primitifs et structures de contr ole

Types primitifs
Comme tout langage de programmation e volu e, Java poss` ede un certain nombre de types de donn ees de base : le type boolean qui prend une des 2 valeurs true ou false sur 1 octet ; le type char qui correspond a ` un caract` ere sur 2 octets ; les types byte, short, int et long qui sont 4 types dentiers stock es respectivement sur 1, 2, 4 et 8 octets ; les types float et double qui sont 2 types de ottants stock es respectivement sur 4 et 8 octets. Les d eclarations de telles variables peuvent se faire nimporte o` u dans le code mais avant leur utilisation, comme en C++. On utilise les op erateurs usuels sur les variables de ces types avec la syntaxe du C.
1.2.2
Structures de contr ole
Ce sont essentiellement les m emes constructions quen C, a ` savoir Laffectation qui se fait par lop erateur = et qui consiste a ` recopier la valeur de la variable primaire a ` droite du symbole dans la variable situ ee a ` gauche. Les structures conditionnelles : if (cond) instruction1 ; [else instruction2 ;] switch (selecteur) case c1 : instructions1 ; ... case cn : instructionsN ;

default : instructionsNP ; Les structures r ep etitives ou boucles : for (initialisation ; condition ; instructionDeSuite), while (condition) instruction ; do instruction ; while (condition).
1.3
1.3.1
Classes et objets en Java

D enition dune classe
Une classe permet de d enir un type dobjets associant des donn ees et des op erations sur celles-ci appel ees m ethodes. Les donn ees et les m ethodes sont appel es composants de la classe. Lexemple de base d ecrit dans un paragraphe suivant permettra de d enir une classe Vecteur repr esentant des vecteurs au sens math ematique. A chaque vecteur, seront rattach es : une structure de donn ees - un tableau - pour le stockage de ses coefcients ; des traitements comme les suivants, son addition avec un autre vecteur, son produit scalaire avec un autre vecteur, ... et aussi son proc ed e de cr eation.
1.3.2
D eclaration, cr eation et destruction dobjets
Pour manipuler un objet (par exemple, un vecteur particulier de la classe Vecteur), on doit tout dabord d eclarer une r ef erence sur la classe correspondant au type dobjet. Cette op eration permet de r eserver en m emoire une adresse qui r ef erencera lobjet. Par exemple, pour d eclarer un objet x de type Vecteur on e crira : Vecteur x; Pour que cet objet soit r eellement construit, cest a ` dire que la r ef erence d esigne un emplacement a ` partir duquel on pourra acc eder aux caract eristiques de lobjet, on devra appeler lop eration new qui alloue cet emplacement en m emoire et le renvoie a ` la r ef erence de lobjet. On dispose alors dune nouvelle instance de lobjet. Par exemple, pour la construction effective de notre vecteur x, on e crira : x = new Vecteur();
Cette instruction fait appel a ` un proc ed e de construction dobjets, appel e constructeur, qui est d eni par d efaut, mais qui peut aussi e tre red eni comme op eration dans la classe Vecteur. Si cette instruction de construction nest pas effectu ee, la r ef erence associ ee a ` x est initialis ee par d efaut a ` NULL, qui est une adresse ctive ne pointant vers aucun emplacement m emoire r eel. Par ailleurs, si lon a besoin de r ef erencer lobjet courant dans la d enition de la classe, cette r ef erence se fait par le mot r eserv e this qui vaut donc ladresse de lobjet courant dans une instance de la classe. La destruction des objets est pris en charge par le Garbage Collector, appel e encore ramasse-miettes dans sa d enomination francis ee. Cet outil logiciel fonctionne en m eme temps que le programme, il recherche, identie et supprime de la m emoire les objets qui ne sont plus r ef erenc ables. On peut toutefois ajouter a ` chaque classe un service finalize(), qui sera appel e au moment de la destruction de lobjet, sil est utile deffectuer des op erations sp eciques a ` cet instant. Comme nous lavons indiqu e pr ec edemment, le nom dun objet permet de d enir une r ef erence, cest a ` dire une adresse. Il est alors possible de faire une affectation entre deux objets de m eme nature. Une telle op eration va donc recopier ladresse de lobjet affect e. Ainsi une affectation est notablement diff erente lorsquelle se fait entre des variables de type simple (int, char, double, ...) ou entre des objets. Le passage de param` etres dans les fonctions se fait par valeur, comme en C. Ainsi, soit le param` etre est de type simple alors on recopie sa valeur dans celui de la fonction appel ee, soit cest un objet, on recopie alors ladresse r ef erenc ee par lobjet (qui est bien sa valeur) dans celui de la fonction appel ee.
1.3.3
Tableaux
Un tableau va permettre de stocker un certain nombre d el ements de m eme type dans une structure de donn ees qui dispose dun index pour y acc eder. Un tableau en Java est un objet a ` part enti` ere. Par exemple, un tableau monodimensionnel de ottants de type double sera d eclar e de la mani` ere suivante : double monTableau[]; ou encore double[] monTableau; Comme nous lavons expliqu e pr ec edemment, cette d eclaration a permis daffecter une r ef erence au nom du tableau une r ef erence (cest a ` dire une adresse,
10
initialis ee par d efaut a ` NULL). Pour construire effectivement le tableau, cest a ` dire disposer de plusieurs emplacements m emoire, par exemple 10, qui lui sont propres, on invoque lop eration de construction dobjets suivante : monTableau = new double[10]; Ces deux instructions de constructions peuvent s ecrire en une seule fois : double[] monTableau = new double[10]; Il est e galement possible dinitialiser la construction en affectant un tableau constant de la mani` ere suivante : double[] montableau = {0.0, 1.1, 3.5}; Les tableaux en tant quobjets proposent un certain nombre dop erations, notamment ils poss` edent une donn ee propre length qui renvoie la taille du tableau. Par exemple, les instructions suivantes permettent dafcher le contenu du tableau pr ec edent, en utilisant la m ethode1 dafchage standard sur l ecran 2 System.out.print : for (int i=0; i<montableau.length; i++) System.out.print(montableau[i]+" "); Lexemple pr ec edent nous apprend par ailleurs que, comme en C, le premier indice dun tableau est 0. On dispose aussi de m ecanismes de v erication de d epassement de bornes des tableaux que lon peut interroger par linterm ediaire des techniques dexceptions3 que lon d ecrira apr` es. Lexception concern ee se nomme ArrayIndexOutOfBoundsException .
1.3.4
Construction de la classe vecteur
Nous allons contruire maintenant une classe Vecteur permettant de manipuler des vecteurs au sens math ematique. Cest une classe e l ementaire all eg ee de certains concepts de programmation objet qui seront pr esent es et introduits progressivement dans la suite de cet ouvrage. Dans cette classe, on utilise une structure de donn ees, appel ee composant, correspondant a ` un tableau o` u seront stock es les coefcients du vecteur. On d enit deux constructeurs qui sont des m ethodes portant le nom de la classe et qui ne renvoie pas de r esultat :
voir 1.3.1 voir 1.7 pour une description g en erale des m ethodes dentr ees/sorties 3 voir 1.6
2 1
11
Le premier constructeur construit un vecteur dont le nombre de composants est donn e en param` etre. Le second constructeur construit un vecteur en recopiant un tableau pass e en param` etre. Par linterm ediaire de ces deux constructeurs, il est ainsi possible de d enir des m ethodes de m eme nom, a ` condition quelles diff` erent au niveau du type ou du nombre de param` etres ou de leur r esultat renvoy e. On parle alors de surcharge de m ethodes. On d enit diff erentes m ethodes : elt renvoyant la valeur de sa composante dont lindice est donn e en param` etre ; toElt permettant de modier la composante dont lindice et la nouvelle valeur sont pass es en param` etres ; dim renvoyant la taille du vecteur ; afficher afchant les valeurs de ses composantes ; add renvoyant un vecteur qui est la somme du vecteur courant avec le vecteur pass e en param` etre ; prodScalaire renvoyant le produit scalaire du vecteur courant avec le vecteur pass e en param` etre. Cet exemple permet dillustrer la fac on dont on acc` ede aux composants de lobjet courant, en invoquant simplement leur nom, mais aussi la fac on dont on acc` ede aux composants dun objet ext erieur, en invoquant le nom de la composante prec ed ee dun point et du nom de lobjet en question. L ecriture de la classe Vecteur est la suivante,
class Vecteur { double[] composant; // constructeurs Vecteur(int dim) { composant = new double[dim]; } Vecteur(double tableau[]) { composant = tableau; } // acces a la composante i double elt(int i) { return composant[i]; } // modification de la composante i void toElt(int i, double x) { composant[i] = x; } // renvoie sa tailla int dim() { return composant.length; }

// affiche ses composantes void afficher() { for (int i=0; i<dim(); i++) System.out.print(elt(i)+" "); System.out.println(""); } // renvoie sa somme avec le vecteur en parametre Vecteur add(Vecteur x) { Vecteur w = new Vecteur(dim()); for (int i=0; i<dim(); i++) w.toElt(i, elt(i) + x.elt(i)); return w; }
12
// renvoie son produit scalaire avec le vecteur en parametre double prodScalaire(Vecteur x) { double p = 0; for (int i=0; i<dim(); i++) p += elt(i)*x.elt(i); return p; } }
Nous donnons dans le listing suivant un exemple de classe qui va contenir un programme principal, cest-` a-dire une m ethode de type public static void main(String args[]) . Le param` etre args correspond a ` d eventuels arguments dappel.
class TestVecteur { public static void main(String args[]) { double []t1 = {1.0, 2.0, 3.0}; double []t2 = {5.5, 7.5, 9.5}; Vecteur x1 = new Vecteur(3); for (int i=0; i<x1.dim(); i++) x1.toElt(i, t1[i]); System.out.println("premier vecteur :"); x1.afficher(); Vecteur x2 = new Vecteur(t2); System.out.println("deuxieme vecteur :"); x2.afficher();
13
Vecteur x3 = x1.add(x2); System.out.println("leur somme vaut :"); x3.afficher(); double produit=x1.prodScalaire(x2); System.out.println("leur produit scalaire vaut : "+ produit); } }
Les commandes a ` utiliser pour compiler et ex ecuter le programme seront d ecrites au paragraphe 1.4.2. Le programme g en` ere alors lafchage suivant a ` lex ecution :
premier vecteur : 1.0 2.0 3.0 deuxieme vecteur : 5.5 7.5 9.5 leur somme vaut : 6.5 9.5 12.5 leur produit scalaire vaut : 49.0
1.3.5
Composants de type static
Il est possible de d enir des composants4, donn ees ou m ethodes, qui ne sont pas rattach es de mani` ere propre a ` chaque objet instanci e, cest-` a-dire a ` chaque instance de la classe, mais qui sont communs a ` toutes. Pour cela il suft de d eclarer le composant avec le qualicatif static. Par exemple, on peut ajouter a ` la classe vecteur une donn ee enti` ere qui va compter le nombre dobjets de la classe qui ont e t e instanci es. On peut e galement remplacer la m ethode add par une m ethode qui est static et qui prend 2 objets Vecteur en param` etres : on redonne a ` l ecriture de cette fonction une apparence de sym etrie sur ses arguments correspondant a ` la propri et e de communtativit e de laddition. Ci-dessous nous avons partiellement r ee crit la classe Vecteur en prenant en compte ces modications.
class Vecteur { double[] composant; static int nb =0; // constructeurs
4
voir 1.3.1
14
Vecteur(int dim) { composant = new double[dim]; nb++; System.out.println("creation de lobjet "+nb); } Vecteur(double tableau[]) { composant = tableau; nb++; System.out.println("creation de lobjet "+nb); } ... // renvoie sa somme avec le vecteur en parametre static Vecteur add(Vecteur x, Vecteur y) { vecteur w = new vecteur(x.dim()); for (int i=0; i<x.dim(); i++) w.toElt(i, x.elt(i) + y.elt(i)); return w; } ... }
Pour acc eder a ` la nouvelle m ethode add, on proc edera de la mani` ere suivante :
double[] t1 = {1.0, 3.2, 5.3}; double[] t2 = {3.0, 4.1, 6.3}; Vecteur x1 = new Vecteur(t1); Vecteur x2 = new Vecteur(t2); Vecteur x3 = Vecteur.add(x1, x2);
1.3.6
Composants de type public et de type private
Une notion fondamentale en programmation objet consiste a ` s eparer, dans la description ou limpl ementation des objets, les parties visibles de lext erieur et que lon appelle interface de celles qui nont pas besoin d etre connues a ` lext erieur de lobjet. Les composants de la premi` ere partie porteront alors le qualicatif public et ceux de la seconde le qualicatif private. Dans notre exemple de classe vecteur, nous avons d eni les op erations dacc` es en lecture (fonction elt) et en e criture (fonction toElt) dans un objet, si bien quil nest jamais utile dacc eder
15
au tableau composant interne a ` la classe. Ainsi nous d eclarerons public les deux fonctions elt et toElt mais private le tableau composant. Lint er et de s eparer ainsi les parties publiques des parties priv ees est de garantir une e volutivit e possible des classes, sans avoir a ` modier les programmes qui les utilisent, a ` partir du moment o` u lon conserve leur interface publique. Ainsi la classe vecteur pourra utiliser des types de structures de donn ees autres que des tableaux pour stocker ses composantes. On pourra par exemple, utiliser un stockage directe sur chier (pour des vecteurs de dimension importante) ou encore un stockage sp ecique pour des structures creuses (en ne stockant que les coefcients non nuls et leur position). Il sufra alors de red enir correctement les deux fonctions dacc` es en lecture (elt) et en e criture (toElt) en respectant leur mode dappel. Tous les programmes utilisant des classes vecteurs nauront alors pas lieu de subir la moindre modication pour pouvoir utiliser ces nouveaux types de vecteurs. La classe vecteur pourra alors e tre partiellement r ee crite avec des parties publiques et priv ees, comme ci-dessous :
class Vecteur { private double[] composant; static int nb =0; // acces a la composante i public double elt(int i) { return composant[i]; } // modification de la composante i public void toElt(int i, double x) { composant[i] = x; } ... }
Lutilisation de ces fonctions nest pas affect ee par ces d eclarations suppl ementaires : on introduit simplement des limitations aux composants comme d ecrit pr ec edemment. Il est a ` noter quen nindiquant ni public ni private, les composants sont consid er es comme e tant d enis public par d efaut, sauf si lon se trouve dans un autre package que celui de la classe consid er ee - nous reviendrons sur cette nuance dans le paragraphe 1.4.3.
1.3.7
Cha nes de caract` eres
Les cha nes de caract` eres en Java sont des objets, instances de la classe pr ed enie String, et elles r ef erencent des cha nes constantes. On pourra les

d eclarer comme dans lexemple suivant : String ch1 = new String("bonjour"); ou encore, sous une forme condens ee qui est sp ecique au type String : String ch1 = "bonjour";
16
La cha ne "bonjour" est ici constante mais ch1 peut e tre r eaffect ee pour r ef erencer une autre cha ne constante, comme dans lexemple suivant : String ch2 = "au revoir"; ch1 = ch2; Lensemble des m ethodes de la classe String peut e tre obtenu en consultant la documentation de lAPI (Application Programming Interface) associ ee au JDK utilis e. Cette documentation, au format HTML, se r ev` ele insdispensable dans la pratique, pour pouvoir acc eder aux descriptions des interfaces des nombreuses classes propos ees dans Java. Toutefois nous allons examiner quelques unes des m ethodes les plus utiles relatives a ` la classe String : La m ethode static String valueOf(int i) renvoie une cha ne contenant la valeur de i. Cette fonction existe aussi pour des param` etres de tous les types primaires. Notons que cest une m ethode statique qui sappelle, par exemple, de la mani` ere suivante : String.valueOf(12) et qui retourne ici la cha ne 12. La m ethode boolean equals(String s) compare le contenu de la cha ne courante avec la cha ne s. La m ethode String concat(String s) renvoie la concat enation de la cha ne courante (celle qui va pr ex ee la fonction concat) et de s. Il faut noter toutefois que les concat enations de cha nes peuvent se faire simplement avec lop erateur +, comme on peut le remarquer dans les appels de la fonction dafchage dans certains des exemples qui pr ec` edent. La m ethode int length() renvoie la longueur de la cha ne courante. La m ethode int indexOf(int c) renvoie la position de la premi` ere occurence du charact` ere de code ASCII c. Elle renvoie -1 si ce caract` ere nappara t pas. La m ethode char charAt(int i) renvoie le caract` ere a ` la position i. Nous avons vu que les objets String r ef erencent des cha nes constantes. On peut, en fait, travailler avec des cha nes modiables, en utilisant des objets de la classe pr ed enie StringBuffer dont on va d ecrire, sommairement, les m ethodes essentielles. L` a encore, pour plus dinformations, on consultera la documentation en ligne de lAPI. Les diff erents constructeurs de la classe StringBuffer sont :
17
StringBuffer() permettant de cr eer une cha ne vide ; StringBuffer(int dim) permettant de cr eer une cha ne de longueur dim ; StringBuffer(String s) permettant de cr eer une cha ne contenant s. Les principales m ethodes de la classe StringBuffer sont : int length() renvoyant la longueur de la cha ne ; StringBuffer append (String s) ajoutant s a ` la n de la cha ne courante ; String toString() renvoyant dans une cha ne constante la cha ne modiable courante.
1.4
1.4.1
Organisation des chiers sources dun programme Java

Structure des chiers sources
Un programme Java correspond a ` une collection de classes dans un ou plusieurs chiers sources dont lextension est "java". Lun de ces chiers doit contenir une classe qui impl emente la m ethode public static void main(String args[]), comme cela est fait dans lexemple pr ec edent de construction de la classe vecteur et de son programme de test.
1.4.2
Commandes de compilation et de lancement dun programme
Pour compiler et ex ecuter les programmes java on utilise les outils fournis avec le JDK. On commence par lancer la compilation des chiers avec la commande javac. Par exemple, pour les deux chiers relatifs a ` notre classe vecteur et a ` son programme de test, on e crira : javac Vecteur.java javac TestVecteur.java Deux chiers : Vecteur.class et TestVecteur.class ont e t e g en er es et correspondent aux noms de toutes les classes d enies dans les chiers sources. Ce sont des chiers en byte-code portables sur toute machine devant e tre trait es par la machine virtuelle java lanc ee par la commande java. On ex ecute donc le programme principal, qui est dans la classe TestVecteur, en tapant la commande :

java TestVecteur
18
1.4.3
Packages
Un package permet de regrouper un ensemble de classes. Linstruction package nomPack en d ebut de chier indique que les classes qui y sont d enies appartiennent au package nomm e nomPack. Pour acc eder aux classes de ce package, lorsque lon est dans une classe qui ny appartient pas, on utilise la d enomination nomPack.className , o` u className d esigne le nom de la classe. Les d esignations de package suivent un sch ema de construction arborescent du type : name.subname.subsubname . Il existe un lien entre les noms de package et les r epertoires o` u se trouvent les classes y appartenant . Par exemple, une classe watch appartenant au package time.clock doit se trouver dans le chier time/clock/watch.class . Les r epertoires o` u Java effectue sa recherche de packages sont d enis dans la variable denvironnement : CLASSPATH. Linstruction import packageName permet dutiliser des classes du package d eni, sans avoir besoin de les pr exer par leur nom de package. On peut importer toutes les classes dun package en utilisant un import du type import packageName.* ;, mais, ATTENTION, limport dun niveau de package ne permet pas dimporter les packages qui sont en-dessous dans larborescence des r epertoires. Voici un exemple dillustration qui montre une organisation de classes java, dans diff erents r epertoires et leur utilisation. La variable denvironnement CLASSPATH doit e tre dans le chier .profile ou dans .bashrc, par exemple, sous Unix, de la mani` ere suivante : CLASSPATH = /myJavaClass Voici maintenant des extraits de diff erents chiers rang es dans les r epertoires indiqu es : le chier /myJavaClass/bibMat/calVecteur/Vecteur.java correspond a ` package bibMat.calVecteur; public class Vecteur { ... } le chier /myJavaClass/bibMat/calMatrice/Matrice.java correspond a ` package bibMat.calMatrice; public class Matrice { ... } le chier /myJavaClass/calUtil/TestBibMat.java correspond a `

package calUtil; import bibMat.calMatrice.*; public class TestBibMat { public static void main (String args[]) { bibMat.calVecteur.Vecteur x = new bibMat.calVecteur.Vecteur(3); Matrice M = new Matrice(3, 3); ... } }
19
1.4.4
Visibilit e des composants dans les packages
On a vu pr ec edemment que laccessibilit e des composants dune classe se fait gr ace aux qualicatifs private ou public. En fait, elle est e galement li ee aux localisations dans les packages. Ainsi, lorsquun composant ne pr ecise pas sa nature (private ou public) alors il est, par d efaut, public dans les classes du package (ou du r epertoire) auquel il appartient et private en dehors. Nous illustrons ces propos avec lexemple suivant : Package P1 : class C1 { public int xa; int xc; private int xd; } class C2 { ... } Package P2 : class C3 { ... } Dans cet exemple, la classe C2 peut acc eder a ` xa et xc. Par contre C3 ne peut acc eder qu` a xa uniquement.
1.4.5
packages pr ed enis en Java
Le langage Java poss` ede un grand nombre de packages pr ed enis regroup es par th` emes. Ces packages et les classes quils contiennent sont d ecrits de mani` ere exhaustive dans une documentation fournie par Sun et qui reprend lensemble des interfaces. Cette documentation est appel ee API (Application Programming Interface) et est distribu ee sous un format HTML, permettant ainsi une navigation hy-
20
pertexte particuli` erement adapt ee aux recherches dinformations n ecessaires pour le d eveloppement de programmes. On y trouve principalement : java.lang qui correspond aux classes de base (cha nes, math, ...), java.util qui correspond aux structures de donn ees (vector, piles, les, ...), java.io qui correspond aux entr ees/sorties, java.awt qui correspond au graphisme et fen etrage, java.net qui correspond aux communications Internet, java.applet qui correspond aux insertions dans des documents HTML.
1.5
1.5.1
H eritage
Construire une classe d eriv ee
La notion dh eritage est importante en programmation objet. Elle permet de d enir une classe d eriv ee a ` partir dune autre classe dont on dit quelle h erite. La classe d eriv ee poss` ede alors, par d efaut, lensemble des composants de la classe dont elle h erite - on lappelle classe m` ere - sauf si des restrictions ont e t e pos es sur ces composants. Lh eritage est donc un concept essentiel renforc ant les propri etes de r eutilisabilit e des programmes objets. Lutilisation r ep et ee de lh eritage sur des classes successives conduit a ` la construction dune hi erarchie entre elles, que lon peut sch ematiser par un arbre dh eritage. La gure 1.1 pr esente un exemple darbre dh eritage construit sur des classes permettant de repr esenter des gures g eom etriques.
Figure
Polygone Triangle Rectangle
Cercle
F IG . 1.1: Arbre dh eritage de classes dobjets g eom etriques
La construction effective des diff erentes classes de la gure 1.1 est faite dans lexemple complet du paragraphe 1.5.5. Pour d enir une classe ClB qui d erive de la classe ClA, on fera une d eclaration du type :

class ClB extends ClA { ... }
21
Un objet de la classe ClB est alors aussi un objet de la classe ClA, il peut e tre utilis e partout o` u un objet de la classe ClA est attendu. On peut tester lappartenance dun objet a ` une classe gr ace a ` lop erateur instanceof, comme dans lexemple qui suit : ClB x; if ( x instanceof ClA) System.out.println(voici un objet ClA !); Lex ecution des lignes pr ec edentes provoque lafchage de voici un objet ClA !.
1.5.2
Constructeur dune classe d eriv ee
Si lon d enit un constructeur dune classe d eriv ee, celui-ci doit explicitement faire appel a ` un constructeur de la classe m` ere, auquel on acc` ede avec la m ethode pr ed enie super( ... ). Si cet appel explicite nest pas fait, lex ecution du programme provoquera un appel implicite du constructeur par d efaut, cest a ` dire sans param` etre, de la classe m` ere ; il faut donc imp erativement que celui-ci existe sinon une erreur de compilation sera diagnostiqu ee. Ainsi, si lon a d eni un ou des constructeurs dans la classe m` ere, une de ses versions devra e tre sans param` etre. Lappel explicite du constructeur de la classe m` ere se fait par la m ethode pr ed enie super( ... ), cet appel est obligatoirement la premi` ere instruction du constructeur. On ne peut donc transmettre que des valeurs de param` etres du constructeur courant lors de lappel de super( ... ). On retrouve de telles constructions dans lexemple du paragraphe 1.5.5 o` u la classe Figure poss` ede un composant de type Point correspondant a ` son origine et pouvant e tre initialis e par le param` etre x du constructeur Figure(Point p). On d enit la classe Cercle d erivant de Figure, dont le constructeur est d eni par : Cercle (Point centre, double r) { super(centre); ... }
1.5.3
Accessibilit e : public, protected et private
On a vu pr ec edemment que les composants dune classe pouvaient e tre e ventuellement quali es des termes public ou private. Il existe, en fait, un
22
troisi` eme qualicatif protected qui indique que ce composant est accessible uniquement dans les classes d eriv ees et les classes du m eme package. Par exemple, soit la classe ClA d enie de la mani` ere suivante :
package aa; public class ClA { protected int JJ; ... }
et la classe ClB d enie ainsi :

package bb; import aa.*; class ClB extends void PP() { JJ++; // ClB b; b.JJ++ // ClA a; a.JJ++ // } }
ClA { autoris e autoris e interdit
1.5.4
M ethodes virtuelles et classes abstraites
Une classe peut annoncer une m ethode sans la d enir, on dit alors que la classe est abstraite. Elle doit e tre introduite avec le mot cl e abstract. Par exemple, on peut d enir la classe abstraite ClA suivante et une classe ClB qui en d erive.
abstract class ClA { abstract void fctP() ; void fctQ() { ... }; ... } class ClB extends ClA { void fctP() { ... }; ... }
En raison de sa d enition incompl` ete, il est impossible dinstancier une classe abstraite qui ne sert qu` a la construction de classes d eriv ees. Ces derni` eres devront red enir toutes les m ethodes abstraites, pour ne pas l etre elles-m emes et pouvoir ainsi e tre instanci ees.
23
1.5.5
Un exemple : quelques objets g eom etriques
Nous donnons un exemple dimpl ementation des diff erentes classes d ecrites sur la gure 1.1. Nous commenc ons par d enir une classe Point qui servira dans les autres classes :
class Point { double abscisse; double ordonnee; Point(double x, double y) {abscisse=x; ordonnee=y;} Point(Point p) {abscisse=p.abscisse; ordonnee=p.ordonnee;} static double distance(Point p, Point q) { double dx=p.abscisse-q.abscisse; double dy=p.ordonnee-q.ordonnee; return Math.sqrt(dx*dx+dy*dy); } }
Nous d enissons ensuite une classe abstraite pour d enir le type Figure constitu e de deux m ethodes abstraites dafchage et de calcul de p erim` etre :
abstract class Figure { private static final Point zero=new Point(0,0); Point origine; Figure(){origine=zero;} Figure(Point p){origine=new Point(p);} abstract double perimetre(); abstract void affiche(); }
La classe Cercle qui suit d erive de la classe Figure en impl ementant ses deux m ethodes abstraites perimetre et affiche :
class Cercle extends Figure { private static final double pi=3.141592; double rayon; Cercle(Point centre, double r) {super(centre); rayon=r;} double perimetre() {return 2*pi*rayon;} void affiche() { System.out.println("Cercle");
24
System.out.println("rayon : " + rayon +" et centre : " + "(" + origine.abscisse + "," + origine.ordonnee + ") "); } }
La classe Polygone d erive de la classe Figure. Elle se caract erise par un tableau de Point :
class Polygone extends Figure { Point sommet[]= new Point[100]; int nbs; Polygone(){nbs=0;} Polygone(Point[] m, int n) { super(m[0]); nbs=n; for (int i=0; i<n; i++) sommet[i]=m[i]; } double lcote(int i) { if (i<nbs) return Point.distance(sommet[i-1], sommet[i]); else return Point.distance(sommet[i-1], sommet[0]); } double perimetre() { double somme=0; for (int i=1; i<=nbs; i++) somme += lcote(i); return somme; } void affiche() { System.out.println("Polygone"); for (int i=0; i<nbs; i++) System.out.print("(" + sommet[i].abscisse + "," + sommet[i].ordonnee + ") System.out.println(); } }
");
La classe Triangle est une classe e l ementaire d eriv ee de la classe polygone :

class Triangle extends Polygone {

Triangle(Point[] m) { super(m,3); } }
25
La classe Rectangle d erive de la classe Polygone. Elle est d enie avec ses caract eristiques math ematiques classiques, cest a ` dire la longueur de ses c ot es et un de ses sommets, le sommet inf erieur gauche. On a alors une bonne illustration de lutilisation des constructeurs successifs des classes d eriv ees. Pour appeler le constructeur de Polygone qui poss` ede le tableau de ses sommets en param` etres, il faudrait tout dabord faire la construction de ce tableau a ` partir des caract eristiques de Rectangle, ce qui nest pas possible, car lappel de super doit e tre la premi` ere op eration. Il faut donc utiliser le constructeur par d efaut dans la classe Polygone qui sera appel e au d ebut de lex ecution du constructeur de Rectangle. La composante sommet de la classe sera alors construite plus loin :
class Rectangle extends Polygone { double largeur; double longueur; Rectangle(Point m, double lo, double la) { // appel implicite du constructeur de // Polygone sans parametre // lappel du constructeur de Polygone avec parametres // ne peut se faire car il faut dabord construire // le tableau a lui transmettre qui ne peut se faire // quapres lappel explicite ou implicite de super Point P1= new Point(m.abscisse+ lo, m.ordonnee); Point P2= new Point(m.abscisse, m.ordonnee+ la); Point P3= new Point(m.abscisse+ lo, m.ordonnee+ la); Point mr[]={m, P1, P3, P2}; sommet=mr; nbs=4; largeur= la; longueur= lo; } }
Voici un programme principal de test :

class Geometrie { public static void main(String args[]) { Point P1= new Point(3,4); Point P2= new Point(4,4); Point P3= new Point(0,0); Point P4= new Point(1,0);

Point P5= new Point(0,1); Point [] TabP={P3, P4, P5}; Cercle c= new Cercle(P1,2); Rectangle r= new Rectangle(P2,5,2); Triangle t= new Triangle(TabP); Figure f; //autorise, mais pas new Figure ! System.out.println("perimetre cercle");
26
f=c; f.affiche(); // appel de affiche de Figure // puis de sa forme derivee de cercle System.out.println("perimetre : " + f.perimetre()); f=r; f.affiche(); System.out.println("perimetre : " + f.perimetre()); f=t; f.affiche(); System.out.println("perimetre : " + f.perimetre()); } }
Lex ecution du programme afche :

java Geometrie perimetre cercle Cercle rayon : 2.0 et centre : (3.0,4.0) perimetre : 12.566368 Polygone (4.0,4.0) (9.0,4.0) (9.0,6.0) (4.0,6.0) perimetre : 14.0 Polygone (0.0,0.0) (1.0,0.0) (0.0,1.0) perimetre : 3.414213562373095
1.5.6
Interfaces
Une interface, en Java, permet de d ecrire un mod` ele de construction de classe dans lequel on nindique uniquement que les en-t etes des m ethodes. Cela e quivaut, dune certaine mani` ere, a ` une classe o` u toutes les m ethodes sont abstraites. On dira quune classe impl emente une interface, si elle red enit toutes les m ethodes d ecrites dans cette interface. Par exemple, on d enit un mod` ele de probl` eme par une interface qui comporte deux m ethodes poserProbleme et resoudreProbleme :

interface AResoudre { void poserProbleme(); void resoudreProbleme(); }
27
On peut alors construire une classe equationPremierDegre qui impl emente linterface aResoudre :
class EquationPremierDegre implements AResoudre { double coefx, coef1, solution; void poserProbleme() { // on lira coefx et coef1 } void resoudreProbleme() { // on affecte une valeur a solution } ... }
Un autre int er et des interfaces provient de la limitation de Java en terme dh eritage multiple. En effet, Java ne permet pas quune classe d eriv ee puisse avoir plusieurs classes m` eres et donc de b en ecier des composants d enis dans ces diff erentes classes. Pour pallier cette limitation, on devra utiliser conjointement lh eritage et limpl ementation dinterfaces. Il est, par ailleurs, possible dimpl ementer plusieurs interfaces en Java, contrairement a ` lh eritage.
1.5.7
Passage dune fonction en param` etre dune m ethode
Nous nous int eressons au probl` eme du passage dune fonction en tant que param` etre dans une m ethode. Par exemple, on souhaite d ecrire dans une classe un proc ed e qui approche le calcul dune d eriv ee dune fonction r eelle dune variable r eelle par un taux daccroissement :
'("9681354@# !!"$#&% '("0)213545#768 1
Nous allons montrer comme ce proc ed e peut e tre d ecrit dune mani` ere g en erique, cest a ` dire en utilisant une fonction abstraite , param` etre du proc ed e. On applique alors ce proc ed e de d erivation num erique a ` une fonction particuli` ere en la transmettant par linterm ediaire de ce param` etre. Dans beaucoup de langages, comme le C ou le C++, le passage dune fonction en param` etre seffectue en g erant un pointeur qui contient ladresse effective du code de la fonction. Le langage Java ne proposant pas de gestion explicite de pointeur, on doit alors cr eer une enveloppe de type objet contenant une m ethode
28
correspondante a ` l evaluation de la fonction. Cest cette classe enveloppe qui correspond au param` etre a ` g erer. Il faut donc commencer par d enir une classe abstraite, ou une interface, qui d ecrit les fonctionnalit es minimales de la classe correspondant au param` etre fonctionnel. Nous donnons un exemple qui sappuie sur lutilisation dune interface minimale caract erisant une fonction r eelle dune variable r eelle. Les nombres r eels sont impl ement es par le type double :
interface FoncD2D { public double calcul(double x); }
Nous pouvons alors utiliser cette interface pour d ecrire un proc ed e g en erique de calcul de d erivation num erique, comme d ecrit ci-dessus :
class DiffFinies { public double derivOrdre1 (FoncD2D f, double x, double h) { return (f.calcul(x+h/2) - f.calcul(x+h/2))/h ; } }
Pour utiliser ce proc ed e, il suft maintenant de d enir une fonction particuli` ere dans une classe qui impl emente linterface FoncD2D :
class FoncCarre implements FoncD2D { public double calcul (double x) { return x*x ; } }
Le programme principal suivant va alors construire un objet de la classe FoncCarre qui permet dutiliser la fonction particuli` ere qui y est d enie. Il construit aussi un objet de la classe DiffFinies qui permet dutiliser le proc ed e de d erivation num erique qui est invoqu e sur lobjet de type FoncCarre, reconnu comme une impl ementation de FoncD2D :
class TestDiffFinies { public static void main (String args[]) { FoncCarre f = new FoncCarre(); DiffFinies df = new DiffFinies(); System.out.println ("Diff erences finies dordre un "+ "en 1 de pas 0.01 : "+ df.derivOrdre1(f, 1, 0.01)); } }
Le r esultat de lex ecution est :

java TestDiffFinies Diff erences finies dordre un en 1 de pas 0.01 : 1.9999999999999685
29
1.6
1.6.1
Exceptions
Notions g en erales
Lintroduction de la notion dexception dans un langage de programmation a pour but de simplier le traitement de certaines situations. Ces derni` eres sont consid er ees comme exceptionnelles, au sens o` u leur d etection n ecessite de les g erer, en les sortant du contexte dans lequelle elles sont d etect ees. Dans les langages ne g erant pas sp eciquement ces situations dexception, il est n ecessaire dutiliser de nombreuses instructions conditionnelles successives, an de r eorienter le d eroulement du programme de mani` ere ad equate. De tels processus peuvent conduire a ` une complexit e du programme dont la lecture nit par salourdir. Certains langages proposent de mani` ere facultative lutilisation des exceptions (cest le cas du C++). Avec Java, on a lobligation de les g erer lorsque certains appels de m ethodes sont succeptibles, de par leur conception, de d eclancher des traitements dexception. Une gestion dexception est caract eris ee par une s equence try - Catch - finally qui correspond typiquement au d eroulement suivant :
try { //s equence succeptible de d eclancher une exception ... } catch (classException e1) { //traitement ` a effectuer si e1 a et e d eclanch ee ... } catch ( ....) { ... } //autre d eclanchement eventuel finally { //traitement effectu e avec ou sans d eclanchement dexception ... }
Nous donnons ci-dessous un exemple de programme qui r ecup` ere les arguments fournis au lancement du programme. Il calcule et afche la moyenne de ces
30
arguments lorsque ce sont des entiers. Il d eclanche un traitement dexception si lun des arguments ne correspond pas a ` un entier.
class exceptionCatch { static int moyenne (String[] liste) { int somme=0, entier, nbNotes=0, i; for (i=0; i<liste.length; i++) try { entier=Integer.parseInt(liste[i]); // conversion cha ne en valeur enti` ere somme += entier; nbNotes++; } catch (NumberFormatException e) { System.out.println("note: "+(i+1)+" invalide"); } return somme/nbNotes; } public static void main (String[]argv) { System.out.println("moyenne "+moyenne(argv)); } }
Une ex ecution possible du programme est la suivante :

java exceptionCatch ha 15 12 13.5 note: 1 invalide note: 4 invalide moyenne 13
1.6.2
D enir sa propre exception
Pour d enir sa propre exception, il faut d enir une classe qui h erite de la classe pr ed enie Exception. On pourra surcharger, en particulier, la m ethode pr ed enie toString() dont la cha ne renvoy ee correspond au message afch e, lorsque lon demande dafcher lexception elle-m eme. Une m ethode succeptible de d eclancher une exception devra avoir une clause throws, suivie de lexception d eclanchable dans son en-t ete. Dans le corps de la m ethode, on pr ecisera dans quelle condition lexception est d eclanch ee, en invoquant lop erateur throw. On donne ci-apr` es un compl ement du programme pr ec edent d eclanchant une exception, lors du calcul de la moyenne dun tableau, sil ne contient pas d el ements.
31
class ExceptionRien extends Exception { public String toString() { return ("aucune note !"); } } class ExceptionThrow { static int moyenne (String[] liste) throws ExceptionRien { int somme=0, entier, nbNotes=0, i; for (i=0; i<liste.length; i++) try { entier=Integer.parseInt(liste[i]); // conversion cha ne en valeur enti` ere somme += entier; nbNotes++; } catch (NumberFormatException e) { System.out.println("note: "+(i+1)+" invalide"); } if (nbNotes == 0) throw new ExceptionRien(); return somme/nbNotes; } public static void main (String[]argv) { try { System.out.println("moyenne "+moyenne(argv)); } catch (Exception e) { System.out.println(e); } } }
Voici deux ex ecutions successives du programme pr ec edent :

java exceptionThrow q d 1 3 5.2 note: 1 invalide note: 2 invalide note: 5 invalide moyenne 2 java exceptionThrow q d 3.1 a 5.2 note: 1 invalide note: 2 invalide note: 3 invalide note: 4 invalide note: 5 invalide

aucune note !
32
1.7
1.7.1
Entr ees/Sorties
Classes de gestion de ux
Dans le langage Java, deux types dentr ees/sorties sont utilisables : Les entr ees/sorties traditionnelles, cest-` a-dire utilisant les ux de communications par d efaut, a ` savoir le clavier ou l ecran, ou encore les chiers ; Les entr ees/sorties bas ees sur des interactions avec un syst` eme de fen etrage. Celles-ci seront d evelopp ees dans le chapitre sur le graphisme. Nous pr esentons, dans la suite, des notions bas ees sur lAPI 1.1 et qui ont e t e enrichies signicativement par rapport aux versions pr ec edentes. Les raisons de ces enrichissements sont principalement dues a ` des questions defcacit e et a ` la possibilit e dutiliser des codes internationaux (UNICODE) qui enrichissent le code ASCII avec des caract` eres accentu es, entre autres. Les principales classes de gestion de ux sont organis ees suivant la hi erarchie dh eritage d ecrite dans la gure 1.2.
Object Reader (abstract) InputStreamReader BufferedReader FileReader
Writer (abstract)
OutputStreamWriter BufferedWriter PrintWriter
FileWriter
F IG . 1.2: Hi erarchie des classes de gestion de ux Dans cette hi erarchie, les classes suivantes apparaissent : La classe Object qui est la classe de base en Java, dont toutes les autres h eritent e; Les classes abstraites Reader et Writer qui concernent respectivement les ux de caract` eres pour les lectures et les e critures ; Les classes InputStreamReader et OutputStreamWriter qui permettent de faire la traduction des donn ees brutes en caract` eres UNICODE et inversement ;
33
Les classes BufferedReader et BufferedWriter qui permettent lutilisation dune m emoire tampon pour les entr ees-sorties. Cette m emoire est indispensable pour lutilisation des p eriph eriques standards ( ecran et clavier) ; Les classes FileReader et FileWriter qui permettent lutilisation de chiers ; La classe PrintWriter qui permet l ecriture de donn ees formatt ees semblables aux afchages a ` l ecran. Cette liste nest pas exhaustive mais correspond aux principales classes que nous serons amen es a ` utiliser dans la suite.
1.7.2
Saisies au clavier
Pour effectuer une saisie au clavier, on construit successivement : Un ux InputStreamReader avec le ux de lentr ee standard, a ` savoir System.in ; Un ux de lecture bufferis e de type BufferedReader a ` partir du ux pr ec edent. On pr esente, ci-apr` es, un exemple typique de lecture au clavier. Dans cet exemple, on lit dans le ux bufferis e avec la m ethode readLine() permettant la lecture dun cha ne de caract` eres jusqu` a ce que lon rencontre un saut de ligne. La cha ne de caract` ere est alors convertie en entier, avec la m ethode () parseInt, ou en ottant, avec un construction plus complexe qui utilise la m ethode floatValue(), sur lobjet de la classe Float obtenu en appelant valueof(). Cette derni` ere m ethode est statique et a pour param` etre la cha ne lue. Il faut noter qu` a partir du JDK 1.2, on pourra plus simplement appeler la m ethode parseFloat(), similaire a ` parseInt(). On remarquera que, dans cet exemple, il est n ecessaire de g erer le d eclanchement e ventuel dexceptions peuvant se produire, soit par un probl` eme de lecture de ux qui provoque le d eclanchement de lexception IOException ; soit par un probl` eme de conversion de cha ne de caract` eres en valeur num erique qui provoque lexception NumberFormatException .
import java.io.*; class Testio { public static void main(String[] args) { InputStreamReader fluxlu = new InputStreamReader(System.in); BufferedReader lecbuf = new BufferedReader(fluxlu); try {

System.out.print("taper 1 ligne de caracteres : "); String line = lecbuf.readLine(); System.out.println("ligne lue : " + line); System.out.print("taper 1 nombre entier : "); line = lecbuf.readLine(); int i = Integer.parseInt(line); System.out.println("entier lu : " + i); System.out.print("taper 1 nombre reel : "); line = lecbuf.readLine(); float f = Float.valueOf(line).floatValue(); System.out.println("r eel lu : " + f);
34
System.out.println("somme des deux nombres : " + (i+f) ); } catch(IOException e) { System.out.println("erreur de lecture"); } catch(NumberFormatException e) { System.out.println("erreur conversion chaine-entier"); } } }
Lafchage obtenu a ` la suite de lex ecution du programme est le suivant :

java Testio taper 1 ligne de caracteres : java sait lire ligne lue : java sait lire taper 1 nombre entier : 3 entier lu : 3 taper 1 nombre reel : 12.5 r eel lu : 12.5 somme des deux nombres : 15.5
1.7.3
Lecture dun chier
Une lecture dans un chier est effectu e dans le programme suivant. Il est similaire au pr ec edent avec, toutefois, quelques diff erences : FileReader est la classe instanci ee pour construire le ux dentr ee a ` partir du nom du chier. Cette instanciation pourra d eclancher lexception FileNotFoundException , si le chier nest pas trouv e. La m ethode close() ferme le chier.
35
On utilise une boucle qui d etecte la n de chier, suite au r esultat dune lecture qui renvoie la constante null.
import java.io.*; class Testfile { public static void main(String[] args) { FileReader fichier=null; BufferedReader lecbuf; String line; float f, somme=0; int nbnombre=0; try { fichier = new FileReader("donnee.dat"); lecbuf = new BufferedReader(fichier); while ( (line = lecbuf.readLine()) != null ) { f = Float.valueOf(line).floatValue(); somme += f; nbnombre++; System.out.println("nombre lu : " + f); } if ( nbnombre > 0 ) System.out.println("Moyenne : " + (somme/nbnombre)); } catch(FileNotFoundException e) { System.out.println("fichier donnee.dat inexistant !"); } catch(IOException e) { System.out.println("erreur de lecture"); } catch(NumberFormatException e) { System.out.println("erreur conversion chaine-entier"); } finally { if (fichier!=null) try { fichier.close(); } catch(IOException e) {} } } }
On ex ecute le programme pr ec edent avec le chier "donnee.dat" suivant :

2.3 1.2 3.4 2.1 5.2
36
Lafchage, produit par le programme, est alors le suivant :

java Testfile nombre lu : 2.3 nombre lu : 1.2 nombre lu : 3.4 nombre lu : 2.1 nombre lu : 5.2 Moyenne : 2.84
1.7.4
Ecriture dans un chier
Le programme suivant va utiliser un chier dans lequel on e crit. On construit un ux de type FileWriter, utilis e dans un tampon d ecriture (de type BufferedWriter ). Un ux, de type PrinterWriter, permet alors deffectuer des e critures formatt ees avec la m ethode println, comme on le fait couramment sur la sortie standard, cest-` a-dire l ecran.
import java.io.*; class Testfileout { public static void main(String[] args) throws IOException { FileWriter fichier = new FileWriter("out.txt"); BufferedWriter ecrbuf = new BufferedWriter(fichier); PrintWriter out = new PrintWriter(ecrbuf); out.println("coucou"); out.println(5.6); System.out.println("fin decriture dans le fichier out.txt"); out.close(); } }
1.7.5
Compl ements
Il est possible de lire et d ecrire des donn ees brutes (donc non formatt ees) avec les classes DataInputStream et DataOutputStream . Les chiers, ainsi construits, ne sont pas lisibles directement sous un e diteur de texte, par exemple, mais leur taille est plus r eduite.
37
La classe StringTokenizer est une classe qui permet dinstancier un petit analyseur de texte qui peut, par exemple, d ecouper des lignes en sous-cha nes de caract` eres, en reconnaissant un certain nombre de s eparateurs (blancs, virgules, ...). La classe java.io.File permet de faire des manipulations de chiers, similaires aux commandes dun syst` eme dexploitation. Elle permet par exemple, de lister un r epertoire, de renommer ou supprimer un chier, etc.
1.8
Conclusion provisoire
Nous terminons ici cette introduction a ` Java. Des compl ements seront donn es au fur et a ` mesure de leur besoin. On abordera la partie graphisme dans le chapitre 4.
Chapitre 2 quations non R esolution des e ACB lin eraires dans

Dans ce chapitre, on pr esente un r esum e de cours sur quelques m ethodes classiques de r esolution num erique des e quations non lin eaires dans IR, (2.1)
D !"$# EGF "IH
IR
La g en eralisation aux syst` emes d equations non lin eaires a ` plusieurs variables ( IR ) nest pas trait e dans ce volume, (mais une introsduction en est donn ee sous forme dexercice, pr esent e dans le chapitre 3, voir exercice 25) on pourra consulter les r ef erences bibliographiques en n de volume, par exemple, [?], ... .
"8H
Soit IR IR une application continue, on se propose de trouver la (ou les) solution(s) de l equation (2.1). Except e quelques cas tr` es simples, par exemple pour les polyn ome de degr e inf erieur ou e gal a ` trois, les m ethodes analytiques de r esolution d equations ne permettent pas de r esoudre de tels probl` emes. Le recours aux m ethodes num eriques, fournissant des solutions approch ees, devient alors incontournable.
DSR
6UT
2.1
Localisation (ou s eparation) des racines
La plupart des m ethodes num eriques supposent que lon connaisse un intervalle contenant la racine cherch ee et aucune autre. On dit alors quelle est localis ee ou s epar ee, des autres e ventuelles racines. Les deux m ethodes les plus classiques pour localiser ou s eparer les racines sont : 1. L etude des variations de term ediaire.
, puis lutilisation du th eor` eme de la valeur in-
38
39
2. La r ee criture de l equation sous la forme , puis la recherche de(s) point(s) dintersection des courbes repr esentatives de et de . Le probl` eme sera plus simple a ` traiter si lune des deux fonctions et lidentit e. La solution cherch ee correspond alors a ` un point xe de lautre fonction. Voir ci-dessous.
D ("$# V E
D&W ("$# D ("$# DXW
Remarque 1 : On supposera dans la suite que est localis ee dans un intervalle born e [a,b].
est continue et que la racine
"
2.2
M ethode des approximations successives
Y " W !" # b Q F c "Qa d ` choisi (2.2) dans egfhFpirqsF " eme. La limite de cette suite dans lespoir quelle tende vers la solution du probl` " $ " # v erie tb . " R IR 6$T IR, un point xe de b est un r eel solution de D enition 1 . Soit b " ("$# . l equation tb " !"$# . On peut choisir par D !"$# uE peut s L equation ecrire, sous la forme vb
exemple (2.3) Ainsi, r esoudre
Dans cette m ethode, on construit a ` partir de l equation a ` r esoudre, la suite
D ("$# y E
b ("$# D !"$#w)x" P
revient a ` trouver les points xes de
b ("$# .
Exemple 1 . Soit l equation
D ("$# " 6"6xX!"$# yEGF " ("$# avec elle peut s ecrire, sous la forme cb (" $ # " 8 6 & (" $ # " b ")2X!"$# ," (" $ # b , (" $ # " b ydefhgi . " W o` u il faut choisir l ecriture permettant la convergence du processus it eratif Qj` b (" Q # vers la solution cherch ee, lorsque cette convergence est possible.

Exemple 2 . Soit l equation
40
D ("$# 4'kml!"$#'6n"oqp5ka!"$# EGF " 354t)vu r n D ("$# vE , on peut e les valeurs sr etant pas racines de cette (" $ # 7 4 wpxw!"$# " , sur un crire e entre autres, sous la forme : b intervalle quation, qy zqr 3@4'){u rXFmr 3@4')8|ui)}~# re qui isole une racine et sur lequel b ("$# est d enie, D !"$# E sont les points xes de b ("$# . les racines de R IR 6$T IR, sil existe uH egEF } e tel que, pour tous et D enition 2 . Soit b #&6 b # 7 u 6 $ , alors on dit que b est contrace ements de IR, on ait b l tante (ou est une contraction) sur IR. Si lin egalit e est stricte, on dira que b est u
strictement contractante. est appel e rapport de contraction. Proposition 1 . Soit d eriv ee v erie, dans .
b efFripq
b une application d erivable sur lintervalle egfhFpirq , si la " (" $ # u s } f j , alors b est strictement contractante p b b R 6T
Le th eor` eme suivant fournit une condition sufsante de convergence du processus des approximations successives. IR IR v eriant les conditions suiTh eor` eme 1 (du point xe) . Soit vantes : (cest a ) 1. ` dire 2. est une application strictement contractante dans , de rapport de contraction , alors pour tout la suite r ecurrente d enie par,
"H efhFpirqUb ("$#H ge fhFpirqsF befhFpirqwsegfhFpirq b efFripq u "dH egfhFpirq Y "dH efFripq(" # HI " W t Qj` " b Q ("$F " # "IH egfhFpirq . De plus, la formule converge vers lunique solution de tb , avec suivante donne une majoration de lerreur commise a eration , lors du calcul ` lit " de , " 6 " }u 68 Q u " W 6"d P Q
Il est souvent d elicat de d eterminer un intervalle dans lequel les hypoth` eses du th eor` eme du point xe sont v eri ees, cependant on a le r esultat suivant.
efhFpirq
Proposition 2 : Si est d erivable au voisinage dun point xe , et si , alors il existe un voisinage de tel que pour tout dans , les it erations, , convergent vers .
" W v !" # b Qa` Q
"
"
"d
"
" # } b U
41
Proposition 3 : Soit une solution de l equation , si est continue au voisinage de et si , alors pour toute condition initiale , la suite d enie par et ne converge pas vers ICIIIIIIIIIIIIIIIIIIIII n corrections faites le dim 11 nov 01 IIIIIIIIIIIIIIIIIIIci Mettre ici la remarque ecrite dans lexo 5 vieille p :57 Remarque : Attention ... R esum e et Interpr etation graphique :
"
" "#G U } b "d " W c !" # b Qa` Q
" tb !"$# b "dF " d0 " "P
b "$# , "$# } , (gure 1), la suite ne converge pas vers " , cest un point 1. si b "d (ou ceux de " d ) r epulsif, les it er es successifs de la condition initiale " limine alors la m s eloignet de , on e ethode.
On estime , (gures 2 et 3), la m ethode converge, est un point at2. si tractif, les it er es successifs de la condition initiale (ou ceux de ) se rapprochent de plus en plus de , (il faut alors d eterminer un intervalle contenant , dans lequel et ), deux cas se pr esentent :
"# } b U "
(a)
(b)
"$#i} , (gure 2), E0 b "d " la suite !" # est croissante, elle est d si ecroissante sinon (cas " Q " d o` u la condition initiale est ). Dans les deux cas, elle tend vers . 6} b "$# tE , (gure 3), !" # est altern "d donnent un la suite ee, deux it er es successifs de " Q " encadrement de et la suite converge vers .
!"$# } f"j @ p b
"
efFripq # b egfhFpirq efFripq
"d
"
" d
42
y= x
y= x
xo xo
x x
xo
x
xo
x
xo
y= x
f(x)
f(x)
f(x)
Figure 1.
(c) si , cest un cas plus d elicat car la m ethode peut converger (gure 4) ou non (gure 5) :
"# b U }
Figure 2.
Figure 3.
f(x)
f(x)
y=
y=
"d convergent vers " si "d Dans la gure 4, les it er es successifs de " , et divergent dans le cas contraire. Dans le cas de la gure 5, ils "d diveegent quelque soit la position de .
2.3 Ordre dune m ethode
Figure 4.
Figure 5.
Q "Q 6 " "d et " W S !" # est dite dordre p si D e nition 3 : La m e thode d e nie par b |r 5 Qa` Q ) . On dit alors a une limite r eelle strictement positive lorsque n tend vers que la m ethode a ` un taux de convergence e gal a ` .
Une m ethode it erative pouvant converger plus ou moins rapidement (voir les gures 6 et 7), il existe des notions qui mesurent cette rapidit e de convergence, et mesurent donc la diminution de lerreur dune it eration a ` la suivante.

f(x) f(x)
43
y=
y=
converge vers et si est sufsamment d erivable Th eor` eme 2 : Si la suite au voisinage de alors lordre de la suite est le plus petit entier tel que : et . De plus on a
(" # " b " (" # Q " # saadvb j W e U "# E E bU b e "U#tQ W } l a Q ` bh e "$# Qa`h Q w " 6 " o` u Q Q . s Ce th eor` eme donne une estimation de lerreur a ` la it eration. Q Remarque 2 : Une m thode est dite lin eaire lorsquelle est dordre 1, on a alors E . Elle est diteequadratique si elle est dordre 2. b "$#y "
Figure 6.
Figure 7.
Remarque 3 : Pour une m ethode dordre p, lorsquon passe dun it er ea ` lautre, le nombre de chiffres d ecimaux exacts est environ multipli e par p. Tests darr et des it erations. Si le processus it eratif converge, la solution , e tant la limite de la suite, ne peut e tre atteinte quau bout dun nombre inni dit erations. Par cons equent lalgorithme sera arr et e en utilisant lun des tests suivants, o` u d esigne la pr ecision a ` laquelle on souhaite obtenir la solution, (i)
" W d " Q 6 @CQ (ii) d !" # , cest a !" # est presque nulle. (iii) b ` dire b Q Q Le processus sera consid er e comme non convergent, vers la solution cherch ee, si la pr ecision souhait ee nest pas atteinte au dela dun nombre raisonable dit erations, , x ` lavance. C e a " a } E pr` Remarque 4 En pratique, lorsque on cherche la racine es, les ` " " W it erations seront arr et ees lorsque deux it esentent les se r es successifs et ` pr m emes d ecimales, de la premi` ere a . ` la
44
2.4
2.4.1
Exemples de m ethodes it eratives

M ethode de Lagrange (ou de la corde)
Soit a ` r esoudre l equation , o` u lapplication est continue, strictement monotone sur telle que , et soit la racine cherch ee, situ ee dans . Dans cette m ethode on remplace le graphe de restreint a ` par le segment de droite joignant les points et , (cest a dire que lon interpole F par un polynome de degr e 1) ; ce segment coupe laxe en un point dabscisse . Soit le point de coordonn ees , on reit` ere alors le m eme proc ed e quauparavant en joignant et lextremit e xe, ou . Lextremit e xe est celle telle que . Voir la gure 8 ci-dessous.
efFripq
D !"$# D D E # D # " efhFpirq f i E D e fFripq m # # # # D D fhF f iaF i " "W (" W F D !" W #m# W W D !"$# D !"$# E
f(x)
xo x 1 x 2
A
En e crivant l equation de la corde ci-dessous. 1. si lextremit e o` u:
x t #
Figure 8.
on obtient la m ethode de Lagrange
" W (" # "d e, Qa` b Q et donn Y "d yi " W " 6 D (" # vb !" # P Qj` Q Q e( e Q "t PPP Cest une suite d ecroissante et born ee, donc convergente, ( f " PPP " W 2" d ). Q 2. si lextremit e est xe, elle s ecrit : Y "d f " W " 6 D (" # |d cb (" # P Qj` Q Q !e e Q "dy" W PPP y" Cest une suite croissante et born ee, donc convergente ( Q PPPP " i ).
est xe, cette m ethode s ecrit

FIGUREsq 9 a, b , c ,d
45
W } W # 6 5 D C}a# (" $ # " ) " y 6 } D D W g e F q , on aW } D EG}P ~# D et Exemple 3H sur # } donc " D E ("$ }~# E , e F } q . Dautre E part sur e F q , ainsi } F D C}~## qui sera xe, gure 9(c). Par cons cest donc lextremit e equent, en " d } " W commencant le processus par ement : , on trouve ais EP@GPPPF " " } es. EGP , ... etc ..., ainsi, cEGP a ` E pr`
2.4.2 M ethode de Newton
par la droite Lid ee consiste cette fois ci a ` remplacer larc de courbe tangente a ` la courbe aux points A ou B, lintersection de cette derni` ere avec laxe d etermine le second e l ement de la suite cherch ee. On reit` ere en passant la tangente a ` la courbe au point dabscisse . etc...
"
"W
t #
"W
f(x)
x2
x1 xo
Figure 10. Dune mani` ere g en erale les it erations de Newton pour r esoudre sont : , n=0,1,2 ... donn ee dans
toujours facile, mais le th eor` eme suivant donne une condition sufsante.
" W " 6 e "Qa d` Q ge fhFpe irq " " ` condition que D (" #t Cette m ethode est bien d enie pour voisin de a Q Q E. D eterminer un intervalle efFripq sur lequel il ya convergence de Newton nest pas
D ("$# E
46
Th eor` eme 3 (convergence globale de la m ethode de Newton) Si v erie : 1. , 2. (stricte monotonnie de ), 3. (concavit e de dans le m eme sens), Alors en choisissant tel que , les it erations de Newton convergent vers lunique solution de dans [a,b].
rp
si 8hpr7!($ 8hpr7 (!$ 8ghpr
( !(v !$ ha$
Th eor` eme 4 : Si quadratique.
est un z ero simple, la m ethode de Newton est au moins
h Exemple 4 ($ 7v sur qq , on a G et ~ donc 8 jq . exple ... A FINNNNNNNNNNNIIIIIIIIIR Par cons equent, en commencant le processus par , on trouve ais ement : G , ... etc ..., ainsi, G a es. ` a pr`

(Dune it eration a ` la suivante, le nombre de chiffres d ecimaux exacts de la solution cherch ee est multipli e environ par deux, donc pr esentera deux fois plus de d ecimales exactes que ).
2.5
Acc eleration de la convergence
Une m ethode it erative peut e tre acc eler ee en transformant la suite en une suite convergeant plus rapidement, vers la m eme limite, ou en transformant de fac on a ` obtenir une m ethode dordre plus e lev e. Voici quelques m ethodes simples dacc eleration de la convergence.
!h5
2.5.1
M ethode dAitken, ou Proc ed e

dAitken
num eriquement instable, et de l ecrire sous la forme e quivalente suivante, mais plus stable :
(h une suite qui tend vers , le proc ed e dAitken consiste a ` transformer u, !hd @ o` hha a$ Gj5 hj ~ha$8h On d emontre que la suite converge plus rapidement que la suite (h vers la m eme limite . Mais il est conseill e deviter cette formulation de @ qui est
Soit en
!""
ha$

#$&%('
#$)%0
#$&%0
# $
Gj@
!""
47
2.5.2
M ethode de Steffensen, exemple de composition de m ethodes
Lorsquon dispose de deux m ethodes pour r esoudre la m eme e quation, on peut les composer pour obtenir une m ethode plus rapide. 21 avec le La m ethode de Steffensen compose une m ethode it erative proc ed e 3 dAitken : do` u les it erations suivantes :
ha$
!""
(h
ha$
1
h !h@m7 (hd !h@7 !h5w8h

1 1 1 1 4 1 71 5 5
j5
8"0
De m eme, cette e criture nest pas num eriquement stable, do` u la formulation suivante, plus stable :
5
hG p mhj$
5 61 5 5
89'
8"0
8A@
Gj5
BC""
2.5.3
M ethode de Regula-Falsi
peut saverer tr` es co uteux Dans la m ethode de Newton, le calcul de en temps de calcul, tr` es complexe ou m eme impossible, on remplacera alors cette deriv ee par son approximation
!hd

!h578(h !h5 th h

do` u la m ethode de Regula-Falsi :

D EGF
es, et donn @!h C7h !h5 5 hj$ h !h 78!h5 s 5 G G , donc inf On d emontre que cette m ethode est dordre erieur a ` celui de la m ethode de Newton ; cependant Regula-Falsi peut sav erer plus ra !"" IH P "Q
pide que Newton puisque nexigeant quune seule e valuation de fonction (celle de ), ayant e t e calcul e lors de lit eration pr ec edente, alors que New ton en exige deux, et . Ainsi, avec deux e valuations de fonctions, on effectue une it eration de Newton et on multiplie environ par deux le nombre de d ecimales exactes (puisque cette m ethode est quadratique, th eor` eme 4) ; d esignons par R le temps n ecessaire pour cette it eration. Dans la m ethode de Regula-Falsi, durant le m eme temps R , on effectue approximativement deux it erations (puisquune seule e valuation de fonctions est faite par it eration), et on multiplie ainsi a ` chaque it eration, environ par IH P TS , le nombre de d ecimales exactes, ce qui est meilleur et explique la rapidit e de Regula-Falsi par rapport a ` Newton.
(h !h
(h !(h
48
2.6
Enonc es des exercices corrig es
Exercice 1 : Parmi les fonctions suivantes lesquelles sont contractantes et sur quel intervalle si celui-ci nest pas indiqu e: 1 UWVYX` (a) , ba ca ed ; 1 (b) , ha ca ; gf f 1 `&iqp (c) (d)
1
!$ !$ !$ !$
t
sr
t
V
.
Exercice 2 : Voir si chacune des fonctions suivantes admet zero, un ou plusieurs points xes, puis donner pour chacun un intervalle de separation :
1
($ !$
H # 1
vu
!$ (9 5j !$ ( 5 89
1 1
xwy d
Exercice 3 : Montrer que l equation ; IR, et 4
X U
!$ V .
`&ip a
admet une unique racine dans lint ervalle
Exercice 4 : D eterminer a ` laide de la m ethode du point xe les deux racines r eelles de avec une erreur ' u a . Utiliser pour lune de ces racines la # m ethode it erative x , et pour lautre 1 # .
a5 s
($ $
!$ a@t
Exercice 5 : Soit la fonction eelles , on se propose de trouver les racines r de F par la m ethode des approximations successives. Montrer que F poss` ede une seule racine r eelle . Etudier la convergence des trois m ethodes it eratives suivantes : donn e et ; ( ) ' ( ) ; # $
!$ 9
8 ~
v
ha$ ha$ ( ) ha$ . Si lune de ces m ethodes converge lutiliser pour d eterminer a à
# $
pr` es.
Exercice 6 : Soit l equation p dans IR . p Montrer que la m ethode it erative d enie par 1 gente (v erier les hypoth` eses du th eor` eme du point xe). Choisir initiale de lit eration, dans lintervalle de convergence puis trouver suite. Donner lordre de la m ethode.
C 8$ G
!$
C 8$G est conver , condition limite de la

49
Exercice 7 : p On veut r esoudre dans IR l equation 1 o` u, 1 , a) 1) Montrer quelle admet une seule racine , montrer que ed . f 61 2) Montrer que la m ethode it erative : diverge. ih 1 g1 3) on consid` ere alors 1 , (remarquer que 1 existe), 61 montrer que la m ethode it erative : converge. u u En posant v montrer que est de signe oppos ea ` u , quen concluton ? U j Donner le bon test darr et des it erations pour avoir a ` pr` es, puis donner cette racine approch ee. b) Retrouver a ` laide de la m ethode de Newton. Remarquer que Newton est dordre 2.
! $ !$ $ ! h5 ( $ ha !$ ha$ !$ a$ a
jq
Exercice 8 : On applique la m ethode de Newton au calcul de la racine carr ee dun r eel positif . l BC"" permettent dabouMontrer que les it erations # k $ tir. ' # $ $ H u w k , . Montrer que . On pose u $Yn , H & m w k On applique la m ethode de Regula-Falsi au m eme probl` eme, expliciter les it erations obtenues. Donner lexpression de u en fonction de u et u . En deduire que lordre p de Regula-Falsi verie po 6 .
hj$ (h Gj@jjj j$
G j5 a$ s
j5jjq
Exercice 9 : erivable dun intervalle d de 1. D emontrer que si est une fonction continue d IR dans lui m eme de d eriv ee n egative et born ee sur I, alors on peut mettre 1 l equation sous la forme , o` u 1 est une application contractante de d .
!$
!$
2. Utiliser la question pr ec edente pour trouver la racine P avec une erreur a ; prendre . #
Va
! $
de

q
dans
50
2.7
Enonc es des exercices non corrig es
Exercice 10 : D et erminer en utilisant la m ethode de Lagrange la racine de rBs p B(Wt sachant que
I8 X
de l equation
Exercice 11 : D et erminer en utilisant simultan ement les m ethode de Newton et de Lagrange la # # P u u racine situ ee dans [0,1], avec une erreur a de , , . puis de u t Retrouver ces racines gr ace a ` la m ethode des approximations successives.
Exercice 12 : p On cherche les racines r eelles de l equation . p admet deux racines, lune 1. Montrer que la fonction e vidente quon donnera, et lautre que lon note (que lon veut approcher dans la suite). 2. Localiser dans un intervalle de longueur 1/4. 3. Ecrire la m ethode de Newton relative a . Donner un choix de la condition initiale des it erations de Newton qui assure la convergence du processus. 4. Soient les m ethodes dapproximations succesives suivantes : ' # $ vu p (a) et (b) Pr eciser si elles convergent ou divergent. En cas de convergence indiquer un choix de la condition initiale .
!$ i
8$ C i2$
ha$
8h5
hj$
Exercice 13 : # u Soit q u , localiser graphiquement la racine de . P En donner une approximation avec une erreur inf erieure a ` en utilisant simultan ement la m ethode de Newton et de la corde.
!$
!$
Exercice 14 : On cherche les racines r eelles de l equation u

xu #
#
($ n 1. Montrer que l equation !$ admet une unique racine sur IR, que lon notera . Localiser entre deux entiers cons ecutifs ; soit lintervalle obv v d
. On pose
tenu. 2. Soit la m ethode dapproximation successive suivante :
ha$ h
u
# $
x
ed
Cette suite converge t-elle vers v , pourquoi ?

3. Soit la m ethode dapproximation successive suivante :
51
ha$
vu
# $Yw
Cette suite converge t-elle vers v , pourquoi ?.
z
ed
4. Ecrire la m ethode de Newton pour . Donner une valeur explicite de qui assure la convergence de la m ethode de Newton (si cette converegence est possible), justier. 5. Si lune des trois m ethodes propos ees ci-dessus converge, lutiliser pour donner une approximation de v a ` pr` es.
Exercice 15 : On veut r esoudre l equation non lin aire dans IR, 1. Par la m ethode du point xe :
(1) :
($
xu
!' a~
(a) Montrer par une e tude analytique, puis par une e tude graphique, que l equation (1) admet deux racines et que lon localisera chacune dans un intervalle de longueur 1. , la plus (b) Proposer une m thode it etrative utilisant le point xe : 61 simple possible pour l equation (1) ( eviter la fonction log).
!$
(c) En utilsant le th eor` eme du point xe, et la m ethode it erative 1 ci-dessus avec donn e, montrer que lune des deux racines (not ee ) est attractive, lautre r epulsive.
!h@
hj$
(d) Montrer que deux it er es successifs de la suite donnent un encadrement de la racine .
1 , et de u (o` uu (e) donner en fonction de x zy f f nombre dit erations { assurant la pr ecision : }| z f d { .
5 ($
h ), le x sa 5
z j~ o f
(f) montrer que lordre de cette m ethode est plus petit ou e gal a ` 1. Le v erier num eriquement` a la question ci dessous. (g) Donner alors cette racine a ` 2. Par la m ethode de Newton. (a) Ecrire la m ethode de Newton relative` a l equation (1). (b) V erier que cette m ethode converge vers la racine et donner une valeur explicite de la condition initiale qui assure cette convergence. (c) Donner alors cette racine` a Exercice 16 : Soit la fonction d enie par
a
j
pr` es.
a
j
pr es.
u #
($
VYX`
,
a
caWt

1. Montrer que l equation valle Wt .
52 admet une unique racine
gG
!$
VYX`
dans linter-
2. Soit la m ethode it erative suivante :
ha$ !h5 choisi .

u
# $
(h@
61
(a) Montrer quen choisissant un intervalle m ethode peut converger vers .
hpr
g ,
&Wt
cette
(b) Montrer que

f
s f
ax

f
, on explicitera x .
x
(c) Montrer que
8G
jB
. D eterminer
dans ce cas.
(d) Donner le nombre dit erations { .
assurant lin egalit e:

f
j
}| f
3. Ecrire la m ethode de Newton pour . Donner une valeur explicite de assure la convergence de la m ethode de Newton vers .
qui
Exercice 17 : U Soit la fonction , on se propose de trouver les racines r eelles p de par la m ethode des approximations successives (m ethode du point xe que lon appliquera correctement), puis par la m ethode de Newton.
!$ 2
1.
(a) Montrer que poss` ede deux racines r eelles, une e vidente que lon donnera, lautre que lon localisera dans un intervalle d de longueur t .
(b) Etudier la convergence, vers , des trois m ethodes it eratives suivantes : cd donn e et :
(i) (ii) (iii)
hj$ hj$ hj$

U m
# $
8hc ,
4 n 0q # $
(c) Si lune de ces m ethodes converge lutiliser pour d eterminer pr` es. 2. (a) Ecrire la m ethode de Newton pour
a `j

(b) V erier le th eor` eme de convergence globale de cette m ethode sur un intervalle que vous donnerez. (c) Donner une valeur explicite de m ethode de Newton vers .
qui assure la convergence de la

(d) D eterminer alors `j a

53 pr` es.
Exercice 18 : On veut r esoudre l equation non lin eaire dans IR, : , o` u est une application deux fois contin ument d erivable de IR dans IR, on propose les it erations 1 "" ), o` donn ees par et donn e dans IR ( u
1
($ j ha$ !h@ ($!($ @ ! $ 9 !$m !$C !$

e r
@ pour calculer a ` partir de ($ a ` a pr` es . 3. Partant de , donner alors Remarque : On rappelle quune m ethode ha$ !h5 est dordre si $ $ tant la racine cherch ee). $ et $ ( e
2. Quel est le sch ema it eratif r esultant de 4 , ( IR).
r j 61 A "" 1 n m ~ A 1 n o 1 A m ~ A
1. Montrer que lordre de convergence de cette m ethode est au moins e gal a ` 2.
54
2.8
Corrig es des exercices
Exercice 1
ìp (a) 1 IR. P 1 Montrons que est contractante sur IR, on a :
($
@$
1
($
V9X`
$

et
f
($
f
donc, dapr` es la proposition 1, 1 est contractante de rapport de contraction U inf erieur ou e gal a `P . 1 (b) . f f 1 Soient ) , montrons que 1 a . On a
!$ mIx 5jq 98 @jq

1 f 1 f
($7 G
9
f f f f f
!$7 9
f f u f f f f
En effet, dune mani` ere g en erale, on peut montrer que Supposons que alors
f

f f
f f

f f
f
a a
fj2f
f f f

u u u f f a f
4 f f
f f f
dapr` es lin egalit e triangulaire
On fait de m eme si f f 1 1 a Ainsi, f f ) (c) 1 . # On a :

1
. , do` u le r esultat !$ G et le rapport de contraction est ( $ m 8 !$ et donc, 8 | (($ . . Ainsi, est contractante de rapport (d) !$ 0 . est d enie sur V mais ny est pas lipschitzienne.
f u f f f f a u x f f gf f 7 a a B 1 a U 1 f f xa U 1 r t 1

En effet, telle que
1 1
55
d
'( G d , !$ !$7 G , pour x , est born e. . Ce rapport vaut Posons !$ C 5

) ed 1 1 f f f u 1 1 r t q t r
est lipschitzienne sur
sil existe une constante r eelle , , cest a ` dire que le rapport a6

f
# t
))
donc non bornable sur tout intervalle contenant ; ainsi 1 ne peut e tre lipschitzienne sur . En fait, on montre que 1 est lipschitzienne sur tout intervalle avec
V
1
. Sur cet intervalle,
( $
a t r
t

h V
t
proposition 1, 1 est lipschitzienne de constante ta En outre, pour

1
est contractante si

, donc si

. Ainsi, gr ace a ` la .
q
t
, cest a ` dire
En conclusion, 1 est contractante sur
V .
Exercice 2
(a) Points xes de 1
dabscisse v eriant 1 . Par abus de langage, et dans tous les exercices qui suivent, on dira que est le point xe de 1 (au lieu de labscisse du point xe de 1 ). I Ici 1 est d enie sur et on a
!$
!$
r
. Rappelons quun point xe de 1 est un point
est clairement la seule solution sur cons equent le seul point xe de 1 . D emontrons le autrement :
1 r
($
5
I
de cette e quation et est par
et ($ Posons ($ erivable sur IR et V ; est continue sur IR et d (!$ , donc est strictement croissante sur . Dautre part, Gav et 5 , donc sG~C 5v . Ainsi, dapr` es le th eor` eme
r r r
56
de la valeur interm ediaire, il existe un et un seul r eel tel que ; celui-ci est donc le seul point xe de 1 sur . Le lecteur I pourra ais ement d emontrer que cela reste vrai sur tout . # 1 u (b) Points xes de . # u Posons . est continue et d erivable sur IR, et # u , donc est strictement d ecroissante. Dautre part, et . Dapr` es le th eor` eme de la valeur interm ediaire, w il existe un et un seul r eel tel que . Ce r eel est donc 1 lunique point xe de sur . De m eme, on peut ais ement d emontrer que cela reste vrai sur tout IR. 4 (c) Points xes de 1 .
($ !$ t vv Ca t
{ gG5 ~ G5
Gj q Gjq ( $ y! 5C ! $ ! 5
1
(!$ s
Donc 2 est lunique point xe de 1 sur IR ; ce point xe est dit triple a ` cause de la puissance du terme 4 . # (d) Points xes de
! 5 ( $ ! 5
4 1
( $
! 5
u u #
Appliquons le th eor` eme de la valeur interm ediaire a `
!$ ! 9 5
u
est continue et d erivable sur .
($ ! 57
u
Montrons que IR Pour cela, on e tudie le signe de
p(($ . , on a :
#
!$
u

En cons equence, est strictement croissante sur h p , strictement p croissante sur p et . Ainsi, IR , donc est strictement d ecroissante. Dapr` es le th eor` eme de la valeur interm ediaire, il existe un et un seul r eel 1 p tel que . Ce dernier est lunique point xe de . G
t8 q
X v v
C p !$ v
57
Exercice 3
Montrons quil existe un unique r eel
ìp
($ ,
c
I8 X solution de l equation !$ G
f f e u ìp VYX`
V .
a
On a ainsi
9 i donc, es le th eor` eme de la valeur interm ediaire, C c , et dapr` il existe un unique r eel I X tel que .
4 `&iqp 4 4 ìp u u A
!$
est monotone. Or,
, car V5
a f f
exercice 4
!$ va@0t . t a) Posons ($ a5 c . Etudions donc la m ethode it erative hj$ a5 Remarquons tout dabord que si cette m ethode converge, elle converge bien vers une des racines de ($ , si est la limite de la suite !h5 , alors t donc a5 c , cest a ` dire que $ . a5 Localisons la racine de cette e quation. On a s et C~ donc C~0 , et comme est d erivable sur IR et !($ a5nu sur gGqq alors, gr ace au th eor` eme de la valeur interm ediaire, il existe un unique r eel Gjq solution de l equation !$ . . Comme est monotone sur IR On a s u et C~ ), on a donc gjq gGqq . (puisque !$ sur c est contractante sur gjq : D emontrons que !$ a5 t t !$7 G a5 j5 j5 0 a5 @
Soit l equation
1 A Q 1 1 P 1 1 t 1 1 1 1 f f 4 f f u a u f f f f

On aurait pu aussi la proposition 1, puisque 1
1 t 1 y 1
58
!$ et 5 !$ donc contractante de rapport . converge vers , unique solution ! $ Ainsi, Gj , hj$ de vj5 c dans gjq . Calculons cette racine partant de , on a Gj55G q! s5 a5 q! sGj55G~ GGa5@Ga55 @55G q! sGj55Ga@5 @5@G~ q!
& t f f # $ ' 1 1 1 1 1 1 1 U
Si on cherche a ` pr` es, on arr etera les calculs a ` lit eration o telle que a ` pr` es. a . Ainsi la solution ici vaut ~ f z1 b) Lautre solution est obtenue gr ace a ` la m ethode it erative ee en exercice. # $ . Cette question est laiss
a5
GGa55 j
$ ha$ (h
f ~
exercice 5
Soit l equation . Il est clair que est continue et d erivable sur . On a , . Dautre part, , donc sur . Donc, dapr` es le th eor` eme de la valeur interm ediaire, il existe une seule solution telle que A . 1 (a) Etudions la convergence de la suite . Tout dabord, cette suite, si elle converge, conduit bien a ` une racine de car si est la limite de la suite , alors
A s 4
!$ C~ 5 ~ @ !$ 5 8 5 $ ha$ (h !$ (hd donc $ G Par ailleurs, ($ sur 5 . Par cons equent, gr ace au th eor` eme des accroissements nis, il existe q compris entre h et hj$ tel que !hj$m7 !hd 5 hj$'nh
1 1 1 1 f f f f

Donc
1 f
59
!hj$m7 !h
1
. . .

hj$h hh
f f f

f f
ha$ !h5 ~ . Cette m ethode, si elle converge conduit vers la racine de ($ dans 5 , car si est la limite de la suite !hd , alors donc $ v G
A 1
Ainsi, cette suite diverge et la m ethode est a ` rejeter. 1 (b) Etudions la convergence de
!$
Q 1 1
!$
v~ h 7t~ ~ va
Q
+
Qh
En cons equence, on ne peut conclure sur la monotonie de 1 . Cependant on a

1
or
le point xe de
U ~
Q A
9
I
v erie

Donc 1 A , et comme 1 est continue, il existe un voisinage de tel 1 6 . Donc cette m que 2 , et ethode ne peut pas converger f f dapr` es la proposition 3. En effet, gr ace au th eor` eme des accroissements nis, on a . f fj f f
U @ X ($ 7n ha$h

60
h . Si elle converge, ! h 5 (c) Etudions la convergence de ha$ cette m ethode conduit a ` la racine de !$ dans 5 car si est la limite de la suite !hd , alors donc et $ v
x1 A
On a
($
1 1 donc 1 r 1
contractante dapr` es la proposition 1. Dautre part, C~ est strictement , 5 n , or est monotone, donc m 5 ~( 5 . Donc dapr` es le th eor` eme du point xe, la suite
1 1 B
@
#
8 @ ha$ !h5 converge vers lunique racine x 5 de l equation ($ . Calcul num erique de cette racine a ` a pr` es, a ` partir de
61 B 61 j
Donc
h
"
0 1 1 1.144
2 3 4 1.162 1.165 0.165
est solution de l equation a `
a

pr` es.
exercice 6
Soit l equation v p dans . Consid erons la m ethode it erative d enie par :
C 8$wG
61
hj$ (h@
6 p
8h5w2G
Montrons dabord lexistence dune solution pour cette e quation. # p Soit , on a sur IR , donc # l equation admet au plus une racine. Dautre part on a et p Q , donc ; ainsi, dapr` es le th eor` eme de la valeur interm ediaire, il existe une unique racine solution de l equation . p B . Appliquons la M ethode du point xe pour 1
($ 2$ G 8 (!$ s ($ G ~ 0cG 8 s5C~S 8y Gjq ($ !$ 8$ 2G

1
61
est contractante sur d
@ I r !$ x Donc, si ghpr hpr , dapr` es le th eor` eme du point xe, il existe une unique racine 8hpr solution de l equation !$ . Par exemple, on v erie que mG pG gG p . En effet, sG 5 G Gh et sG G Gv . Calcul num erique de cette racine a ` a et j pr` es :
d 1 1 u 1 Q Q 1 ( 1 Q (Q Q j
rp Gjq
car
0 1 0.7 0.730
2 0.748
3 0.758
4 5 6 0.764 0.767 0.769
7 0.770
8 9 0.771 0.771

Ainsi la racine cherch ee est
G
1
a `
j
p
pr` es, et
G a à
pr` es.
exercice 7
u !$ ! $ o` . 1. 1) Posons !$ ($ ($ , S IR . Appliquons le th eor` eme de la valeur interm ediaire a ` sur ghj o` u V . est continue sur hjq , Uwjq . 8hjq , !$ d et !$i , donc est strictement monotone sur ghjq . Dautre part on a ~ , et comme ($ , alors il existe wjq tel que sizv ; par cons equent, C~C , et dapr` es le th eor` eme de la valeur interm ediaire, il existe un unique { qq (dou IwGqq ) tel que $ , et donc tel que . (h5 converge, elle conduit bien a 2) Si hj$ ` la racine de l equation car $ donc cette derni` ere v erie U Mais, vVghjd !$ , et !$ donc la m ethode hj$ !h diverge pour tout 8qd . 3) existe car est continue et strictement croissante donc bijective. (hd est convergente. Montrons que ha$ d Attention a ` la notation utilis ee : esigne la r eciproque de et non . !$ est d . erivable et on a , par cons En effet, dune mani` ere g en erale equent ($ q($q ($ . Soit l equation
1 1 p a # # i % p p A 1 A v p 1 61 A p A p A 1 # 1 p f f 1 1 1 1 1 1 1 1 B 0 5h 5 T 1 1 1 1 1

Or,
1
62
. Or, on a montr e que ghjd , !$ . Mais , donc !$ , car est d ecroissante. Puisque xu , alors t , donc 0 9 et G !$ . Par cons equent (h converge au voisinage de , dapr` Ainsi la m ethode ha$ es la proposition 2. 4) Posons h et !$ . La m ethode ha$ converge (dailleurs, on a G!($ et G(!$ , n ). Dautre part, gr ace au th eor` eme des accroissements nis on sait quau voisinage de , il existe q compris entre h et tel que : j$ hj$ !h57 $ q@q(h $ Ainsi, j$ G 5 . Or, G!$t8 IR . Donc a$ et sont de signes oppos es, par cons equent deux it erations successives donnent un encadrement de . j . 5) Un test darr et des it erations est : j$ ha$h qq avec . On a bien G!($ sur et Prenons
1 1 1 1 u u u # u # f f u u 1 f f 1 f 1 f u s su # u # su # $ zu # f f u A s u u u u u u U a7 d f f f f d d C6d
d
, donc
. On a bien alors !$
1
car :
Ga G C~
xu & u
vu et est monotone sur Calcul num erique de la racine a ` pr` es. Soit donc la m ethode # $ u et 0 1 2 3 4 5 6 7 8 1 0.367 0.692 0.500 0.606 0.545 0.579 0.560 0.571
($
#
G@jq j
hj$
h h

9 10 11 12 13 14 15 0.564 0.568 0.566 0.567 0.566 0.567 0.567
Ainsi la racine cherch ee est 2. M ethode de Newton. u Soit
a `
j

pr` es.
!$
est clairement ind eniment d erivable. La

m ethode de Newton s ecrit,
63
!h5 h h hj$ h !h5 v , donc Cas Dautre part on a s v et ~ et la racine est situ ee dans gGqq , elle est unique puisque est strictem pour tout . On a aussi net monotone, car (!$ es le th eor` eme de conver !$ y pour tout . Ainsi dapr` gence globale de cette m ethode (voir th eor` eme 3), pour tout cgGqq tel que ( ( lit eration de Newton converge. Prenons alors, par exemple, , alors sC ( ethode , donc la m ha$ h h convegera vers lunique racine de l equation.
u # $ u # $ w u # u # t u u # $ u # $
Calcul num erique ===========================
64
2.9
Mise en uvre en Java
On pr esente, dans la suite, la mise en uvre de la m ethode de Lagrange (cf. paragraphe 2.4) ainsi que la m ethode de Steffenson (cf. paragraphe 2.5). Cette derni` ere est e crite sous une forme g en erique, permettant la composition dune m ethode it erative quelconque avec le proc ed e3 dAitken. Nous illustrons ces programmes, par des exemples de calcul qui permettent de comparer ces deux m ethodes.
2.9.1
Une classe abstraite de description de processus it eratifs
Nous allons utiliser dans la suite deux processus it eratifs, a ` savoir les m ethodes de Lagrange et de Steffensen. Ces deux processus sont bas es sur des calculs similaires : calcul dune formule de r ecurrence et processus de r ep etition jusqu` a une e ventuelle convergence, li ee a ` un crit` ere donn e. Beaucoup dautres sch emas num eriques sont susceptibles de suivre de tels processus. Pour cette raison, nous avons commenc e par d enir une classe abstraite de description dun processus it eratif, appel ee IterGene. Cette classe est abstraite car elle contient une m ethode abstraite, non impl ement ee, correspondant a ` la formule de r ecurrence. Celle-ci va d ependre de la formule sp ecique dune classe particuli` ere qui en d erivera. Par contre, un sch ema de construction de suite r ecurrente, susceptible de converger, peut e tre impl ement e dans cette classe abstraite en sappuyant sur sa formule de r ecurrence, elle-m eme abstraite. Il nous faut g erer la convergence dun processus it eratif gr ace a ` une v erication de pseudo-stabilit e sur deux it er es successifs. Dans le cas o` u il ny a pas convergence, un nombre maximum dit erations est pr ed eni et permet de stopper le processus. Dans ce cas, il reste alors a ` renseigner les programmes appelant de la non-convergence. Pour cela, nous utilisons un m ecanisme dexception qui est sp eciquement adapt ea ` un tel traitement ; il sera alors capable de faire remonter, en cascade, linformation de non-convergence, aux diff erents programmes appelants. On d enit alors une classe exception e l ementaire capable d etre e valu ee sous la forme dune cha ne de caract` eres et impl ementant, pour cela, la m ethode toString.
class NonConvergenceException extends Exception { public String toString() { return("Defaut de convergence"); } }
Nous pouvons alors d enir la classe IterGene qui est compos ee : des donn ees xn, epsilon, maxIter qui correspondent respectivement, au terme courant du processus it eratif, a ` la pr ecisison de conver-
65
gence et au nombre maximun dit erations autoris ees. On impl emente des m ethodes permettant de xer leurs valeurs ; dune m ethode abstraite dit eration iter, sans param` etre, qui actualisera le terme courant du processus it eratif. Nous d ecrivons aussi, une autre version de cette m ethode, iter, avec un param` etre qui correspond a ` une mise a ` jour du terme courant, avant lapplication du processus it eratif ; dun calcul de suite recurrente calculSuite sappuyant sur la m ethode dit eration et e crite sous deux versions : sans param` etre ou avec un param` etre bool een qui permet dafcher une trace des termes successifs de la suite calcul ee.
import java.lang.*; import java.io.*; abstract class IterGene { double xn; // terme courant de la suite double epsilon; // precision de convergence int maxIter; // nombre maxi diterations // fixe la valeur du terme initial de la suite : public void set_xn(double x0) { xn = x0; } // fixe la valeur de la precision : public void set_epsilon(double precision) { epsilon = precision; } // fixe le nombre maxi diterations : public void set_maxIter(int m) { maxIter = m; } // methode abstraite du calcul dune iteration // a partir de xn courant : abstract public double iter() ; // methode de calcul dune iteration // a partir dune valeur x donne : public double iter(double x) { set_xn(x); return iter(); } // calcul dune suite recurrente //a partir de iter et jusqua convergence : public double calculSuite(boolean trace) throws NonConvergenceException {
66
double xOld; int nbIter=0; if (trace) { System.out.println("valeurs successives calculees :"); System.out.println(xn); } do { xOld=xn; iter(); nbIter++; if (trace) { System.out.println("iter. "+nbIter+" : "+xn);} } while (Math.abs(xn-xOld) > epsilon && nbIter <= maxIter); if (nbIter > maxIter) throw new NonConvergenceException(); return xn; } public double calculSuite () throws NonConvergenceException { return calculSuite(false); } }
2.9.2
La m ethode de Lagrange
Nous d ecrivons, maintenant, la classe mettant en uvre la m ethode de Lagrange, vue dans le paragraphe 2.4 et qui, a ` partir dune application continue, strictement monotone sur et telle que , construit le processus it eratif suivant :
hpr
CzV
#@ n
ou a de sorte que ( !(i hj$ h x(h

# $ # $9n m m
La classe IterLagrange est telle que son constructeur poss` ede les param` etres suivants : la valeur initiale et une fonction quelconque r eelle dune variable r eelle (les r eels e tant repr esent es par le type double).
Le passage dune fonction, comme param` etre, se fait gr ace a ` une interface qui sera impl ement ee effectivement, par la fonction particuli` ere utilis ee (comme d ecrit en 1.5.7). Cette interface propose une m ethode d evaluation calcul de la fonction pour un param` etre donn e. Elle s ecrit :
interface FoncD2D { double calcul(double x); }
67
La classe IterLagrange, qui d erive de la classe IterGene, s ecrit alors :

import IterGene; import FoncD2D; class IterLagrange extends IterGene { FoncD2D f; // fonction dont on recherche le zero double x0; // bornes de lintervalle de calcul // constructeurs IterLagrange(FoncD2D fonc, double xini) { f=fonc; x0=xini; epsilon=0.001; maxIter=100; } // calcul dune iteration : public double iter() { xn = xn - f.calcul(xn)*(xn-x0)/ (f.calcul(xn)-f.calcul(x0)) ; return xn; } }
Nous pr esentons ci-dessous, un programme de test de la m ethode de Lagrange, ementant linterface en commenc ant par d enir la fonction , dans une classe impl FoncD2D correspondant a `:
!$
uQ
sur lintervalle
5 ~

La valeur initiale de la suite r ecurrente est la borne 5, qui satisfait a ` la condition exprim ee pr ec edemment. Le programme correspondant s ecrit :
import java.io.*; import FoncD2D; import IterLagrange; class MaFonction implements FoncD2D { public double calcul(double x) { return x*x*x-8; } }
68
class TestLagrange { public static void main(String args[]) { MaFonction f = new MaFonction(); IterLagrange rechercheZero = new IterLagrange(f,5); rechercheZero.set_epsilon(1E-6); try { double resultat = rechercheZero.calculSuite(true); System.out.println("le zero trouve vaut : "+resultat); } catch(NonConvergenceException e) { System.out.println(e); } } }
Nous donnons ci-apr` es une trace de lex ecution montrant la convergence de la recherche en 45 it erations :
java TestLagrange valeurs successives calculees : 5.0 iter. 1 : 1.225806451612903 iter. 3 : 1.575783340029592 iter. 5 : 1.7721357917725993 iter. 7 : 1.8801284843229529 iter. 9 : 1.9378012139273417 iter. 11 : 1.9679808942878763 iter. 13 : 1.9835875282989195 iter. 15 : 1.9916061843487987 iter. 17 : 1.995712170773491 iter. 19 : 1.9978109552571226 iter. 21 : 1.998882781401325 iter. 23 : 1.9994298969642061 iter. 25 : 1.9997091067417003 iter. 27 : 1.9998515787290103 iter. 29 : 1.9999242732103275 iter. 31 : 1.9999613634529168 iter. 33 : 1.999980287364067 iter. 35 : 1.9999899425035552 iter. 37 : 1.9999948686166795 iter. 39 : 1.9999973819453114 iter. 41 : 1.999998664257298
iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter. iter.
2 : 2.8774769746022884 4 : 2.3837064484468686 6 : 2.183912111336465 8 : 2.091190544058032 10 : 2.0458883891378012 12 : 2.0232527320893645 14 : 2.011822859470857 16 : 2.006021559594976 18 : 2.0030695016733913 20 : 2.00156536536722 22 : 2.000798472022616 24 : 2.00040733587803 26 : 2.0002078119872224 28 : 2.0001060232863277 30 : 2.00005409267069 32 : 2.0000275980820095 34 : 2.0000140805969857 36 : 2.0000071839631905 38 : 2.000003665283473 40 : 2.000001870041581 42 : 2.0000009541025854
69
iter. 43 : 1.9999993184984877 iter. 44 : 2.000000486786965 iter. 45 : 1.999999652295112 le zero trouve vaut : 1.999999652295112
2.9.3
La m ethode de Steffensen
Nous effectuons, maintenant, une impl ementation de la m ethode dAitken avec une dacc el eration de Steffesen qui compose le proc ed e 3 m ethode it erative, not ee 1 . Nous utilisons la formulation stable d ecrite dans le paragraphe 2.5 :
hG p mhj$
5 61 5 5 71 5 5
89'

8"0
8"0
8A@
Gj5
BC""
La classe suivante, IterSteffensen , permet cette composition avec une m ethode it erative quelconque, qui d erive de la classe g en erale IterGene. Par ailleurs, elle d erive elle-m eme de la classe IterGene, en tant que processus it eratif. Elle s ecrit alors :
import IterGene; class IterSteffensen extends IterGene { IterGene g; // methode iterative a composer avec d2 daitken // constructeur : IterSteffensen(IterGene fonc, double xini) { g=fonc; xn=xini; epsilon=0.001; maxIter=100; } // calcul dune iteration : public double iter() { double u1 = g.iter(xn); double u2 = g.iter(u1); xn = u1 + 1./( (1./(u2-u1)) -(1./(u1-xn)) ); return xn; } }
Nous donnons ci-apr` es un programme permettant de tester cette m ethode et utilisant la m ethode de Lagrange, comme processus it eratif a ` coupler avec le dAitken. La fonction , dont on cherche le z ero, est la m eme que proc ed e3 dans le paragraphe pr ec edent. On part de la m eme valeur initiale et on utilise la m eme pr ecision de calcul.

import import import import java.io.*; FoncD2D; IterLagrange; IterSteffensen;
70
class MaFonction implements FoncD2D { public double calcul(double x) { return x*x*x-8; } } class TestSteffensen { public static void main(String args[]) { MaFonction f = new MaFonction(); IterLagrange methodeLagrange = new IterLagrange(f,1,5,5); IterSteffensen methodeSteffensen = new IterSteffensen(methodeLagrange, 5); methodeSteffensen.set_epsilon(1E-6); try { double resultat = methodeSteffensen.calculSuite(true); System.out.println("le zero trouve vaut : "+resultat); } catch(NonConvergenceException e) { System.out.println(e); } } }
Nous donnons ci-apr` es, une trace de lex ecution montrant de mani` ere spectaculaire lacc el eration de la convergence, par rapport a ` la m ethode de Lagrange, pour les m emes conditions. En effet, on passe de 45 a ` 5 it erations pour obtenir un r esultat nal qui est plus pr ecis.
java TestSteffensen valeurs 5.0 iter. 1 iter. 3 iter. 5 le zero successives calculees : : 2.374697052247919 : 2.000046185893817 : 2.0 trouve vaut : 2.0 iter. 2 : 2.0174585514794128 iter. 4 : 2.0000000003264917
Chapitre 3 R esolution des syst` emes lin eaires

On note IR , lespace vectoriel des matrices carr ees dordre et a ` co efcients r eels. Soit x IR et IR , on cherche le vecteur IR , solution du syst` eme lin eaire . Ce syst` eme admet une solution unique lorsque le d eterminant de A est non nul, ce que nous supposerons dans la suite. Remarquons que la r esolution de ce syst` eme a ` laide des formules de Cramer est impraticable lorsque n est grand, car ces formules n ecessitent approxima tivement op erations arithm etiques e l ementaires ; par exemple si n=15, cela repr esente de lordre de 4 mois de calcul pour un ordinateur moyen effectuant op erations a ` la seconde. Ce temps de calcul e volue de mani` ere exponentielle avec . Nous rappelons dans la suite les principales m ethodes, beaucoup plus rapides, car polynomiales en temps :
. Quelques m ethodes directes : Gauss et sa forme factoris ee . Quelques m ethodes it eratives : Jacobi et Gauss-Seidel. Les m ethodes directes calculent une solution th eorique exacte, en un nombre ni dop erations, mais avec une accumulation derreurs darrondis qui dautant plus grande que la dimension lest. Par cons equent, pour des matrices de dimension importante, il est pr ef erable dutiliser des m ethodes it eratives bas ees sur la construction dune suite convergente vers la solution du syst` eme. Dans ce cas, le contr ole de la convergence de la suite par une condition darr et renvoie une solution plus pr ecise.
71
72
3.1
M ethode d elimination de Gauss
La m ethode de Gauss engendre un algorithme ni exact dont lid ee est de transformer le syst` eme initial en un syst` eme triangulaire (inf erieur ou sup erieur).
3.1.1
R esolution dun syst` eme triangulaire
On donne ici lalgorithme de r esolution dun syst` eme triangulaire inf erieur. Il se fait en remontant les e quations de la derni` ere ligne a ` la premi` ere. Soit donc le syst` eme o` u & est triangulaire inf erieure et inversible. Dans ce cas, "" , puisque uY x . Lalgorithme de r esolution est :
q $
$
D E F
h et s
$ $&$ I ) i
&f
$

pour
5jj
3.1.2
M ethode de Gauss
G t G G q C~ On e limine le terme dans la ligne gr ace a ` la combinaison ce qui et le terme dans gr ace a ` la combinaison donne le quivalent au syst` eme initial : syst` eme , e
D F n n n E m m m g n n m m '0 0 0 n m n n m m 0 0 0 n m n n m m D F n E n n n n n n 7 m n n g m m m m m m m m
Pour la clart e des explications, on applique la m ethode de Gauss dans le cas . o` u n=3. On suppose que
au syst` eme initial :
G 2G q 5 o` u G et et q Ensuite, en supposant que limine le terme dans gr , on e ace e a ` la combinaison eme quivalent , ce qui donne le syst`
n m G 0 0 0 n q ) B m 0 0 0 n n n m ' ' B ' '' B m m n m n n m m

D
73
E F g
o` u
Le syst` eme obtenu est donc triangulaire. On le r esout gr ace a ` lalgorithme du paragraphe pr ec edent.

n n m m
' ' ' '' B
G G et
n n m m n m n n n m m m ' ' ' '' m
q
n m m
6 n

n m m m
n n
3.1.3
Factorisation
L etape de triangularisation de la m ethode pr ec edente revient a ` factoriser la matrice A en un produit de deux matrices triangulaires lune sup erieure lautre inf erieure. En effet, les diff erentes e tapes de la triangularisation peuvent s ecrire n n m sous forme matricielle. Si on pose , la matrice m du second syst` eme n est obtenue en multipliant a ` gauche Tm par
'0 0 0 0 00

n n n n m m m m
on a donc

n m
De m eme la matrice
m
du troisi` eme syst` eme v erie

m
G G G
m

n m

n n m
o` u
' ' ' B '' B
on a donc
m

n n
Ainsi m . Les matrices m B ) ) m m m m m m n et m sont inversibles car leurs d eterminants sont tous e gaux a ` 1 et leurs inverses sont faciles a ` calculer. En effet, on peut v erier quon les obtient en transformant
G =
n n n m m m n n n
G G
n n n m m m n
74
en leur oppos e les termes gurant sous la diagonale, les autres termes restant inchang es. On trouve alors

n n m
'0 0
00 0 0
Si on pose m , qui est triangulaire sup erieure, peut alors s ecrire comme le produit des deux matrices et :
' ' ' '' B
Finalement, on obtient la solution du syst` eme initial successivement les deux syst` emes suivants :

en r esolvant
Ceci se g en eralise a ` une matrice dordre n. Le lecteur pourra le traiter en exercice. Colmpl ement e crit sur brouillon Remarque 5 Lorsque n est grand, le nombre dop erations de lalgorithme de r esolution du syst` eme triangulaire est e quivalent a ` , car il requiert pour chaque I : (n-i) multiplications, (n-i) soustractions et une division, soit au total op erations. Dautre part, le nombre dop erations de lal gorithme de triangularisation est de lordre de . Donc, la r esolution compl` ete n ecessite au total un nombre dop erations e , sur la quivalent a ` . Pour m eme conguration de machine que celle cit ee en d ebut du chapitre, il faudra de lordre dune seconde pour la r esolution totale du syst` eme !
$ hiua
Faire un paragraphe complet sur la m ethode des pivots lignes ... plus remarque sur le pivotage colonnes.
3.1.4
Remarque sur le Pivot
A chaque e tape de calcul le pivot m doit e tre non nul, sinon une permu& tation de lignes ou de colonnes simpose. Sur le plan num erique si le pivot est trop petit (par rapport aux autres coefcients de la matrice ou par rapport a ` la pr ecisison de la machine), le cumul des erreurs num eriques peut e tre important. Ainsi pour des raisons de stabilit e num erique, il faut effectuer des permutations de lignes ou de colonnes de fac on a ` aboutir a ` un pivot plus grand. On dira que lon fait un pivotage total lorsquon permute des lignes et des colonnes,
75
sinon le pivotage est dit partiel. Si on neffectue quun pivotage partiel sur les lignes, cela ne revient qu` a changer lordre d enum eration des lignes du syst` eme qui nest donc pas modi e. Lorsque lon effectue un e change de colonnes, cela revient a ` permuter les e l ements du vecteur inconnu qui sera donc diff erent de la solution du syst` eme initial. Dune mani` ere pratique, dans ce dernier cas, il est donc n ecessaire de m emoriser toutes les permutations de colonnes an de pouvoir reconstruire le vecteur solution en respectant lordre de ses e l ements correspondant au syst` eme initial. (la notion de petitesse d epend de la pr ecision de lordinateur utilis e), lerreur darrondi ou de troncature peut e tre grande, donc, pour des raisons de stabilit e num erique, il faut aussi amener par permutation de ligne ou de colonne de fac on a ` avoir un pivot assez grand en module ; on fait alors un pivotage. Remarqouns que si le pivot est nul apr` es tout pivotage alors la matrice est singuli` ere. Exemple 5 A laide dun ordinateur ctif a ec imaux signicatifs la ` 3 chiffres d r esolution du syst` eme ci-dessous, qui est trait ee dans lexercice 22 :
j 0
U
4
donne sans permutation de lignes, la solution ; avec permutation de lignes, la solution . La solution exacte est , ce qui montre que la premi` ere solution est fausse alors que la deuxi` eme est la meilleure que lon puisse obtenir, compte-tenu de la pr ecision de la machine.
5@5G5p
sGq~ C5ja
COMPLETER ce cours
76
3.2
Exercice 19 : Soit le syst` eme lin eaire suivant :

D
Ca
E F
7 w8 @7
4
8 8
t
a) R esoudre ce syst` eme par la m ethode de Gauss. b) Factoriser la matrice du syst` eme en produit o` u est une matrice triangulaire inf erieure (avec des 1 sur la diagonale principale) et triangulaire sup erieure, puis r esoudre ce syst` eme. Exercice 20 : Soit le syst` eme lin eaire
o` u:
Factoriser la matrice

, et
en produit ! puis r esoudre le syst` eme.
Exercice 21 : Soit le syst` eme lin eaire o` u:
et
1. Factoriser la matrice en produit puis r esoudre le syst` eme. 2. Trouver ( on rappelle que si M et N sont deux matrices (n,n) inversibles alors . { B {
Exercice 22 : Soit le syst` eme lin eaire :
5

Appliquer la m ethode de Gauss a ` ce syst` eme : a) directement, b) en permutant les deux lignes du syst` eme. U Application avec et un ordinateur ctif a ` 3 chiffres d ecimaux signicatifs. Quobtient-on dans les deux cas ? expliquer ces r esultats .

Exercice 23 : R esoudre le syst` eme suivant : a) En repr esentant les nombres en virgule ottante avec 8 chiffres signicatifs, b) puis exactement,
77
ta 0
q
4
ca
Y

Exercice 24 : On applique la m ethode de Gauss au syst` eme tridiagonal suivant :

q a 5 p p r
"" D F E
h h

Y x
5 5
x x x x
Montrer que la triangularisation revient a ` poser :

p d x 8 $
0 0 s ) x ( )
0 0
pour i=2, ... ,n pour i=2, ... ,n .
Evaluer le nombre d op erations n ecessaires, y compris la r esolution du syst` eme triangulaire. Exercice 25 : R esolution dun syst` eme non lin eaire dans IR
u
9n C a n @

78
3.3
Exercice 26 : R esoudre par Gauss direct, puis par factorisation de la matrice le syst` eme :
D E F
0
# # U U P
Exercice 27 : Soit le syst` eme lin eaire en dimension 3,
1. Donner la d ecomposition de o` u est une matrice triangulaire a ` diagonale unit e et une matrice triangulaire sup erieure. Pour quelles valeurs de cette d ecomposition existe. eme admet une solution unique ; don2. Pour quelles valeurs de et ce syst` ner cette solution. 3. En utilisant la d ecomposition trouver

, o` u et sont deux r e els et et
lorsquelle existe.
Exercice 28 : Soit le syst` eme lin eaire en dimension 4,
, o` u:

et
1. La r esolution de ce syst` eme peut e tre ramen ee a ` celle dun syst` eme lin eaire U de dimension trois, linconnue e tant facile a ` d eterminer. Donner cette inconnue et le syst` eme e restant, que lon notera .
2. Factoriser la matrice en produit (o` u est triangulaire inf eieure a ` diagonale unit e et triangulaire sup erieure) puis r esoudre le syst` eme. 3. De
d eduire
Exercice 29 : Soit le syst` eme lin eaire en dimension 4, Y
, o` u : Y

et
79
1. La r esolution de ce syst` eme peut e tre ramen ee a ` celle dun syst` eme lin eaire de dimension trois, linconnue e tant facile a ` d eterminer. Donner cette inconnue et le syst` eme 3X3 restant, que lon notera , ( U ). u est triangulaire inf erieure a ` 2. Factoriser la matrice en produit (o` diagonale unit e et triangulaire sup erieure), puis r esoudre le syst` eme. Exercice 30 : Soit le syst` eme lin eaire en dimension 4, Y
! m

, o` uY :

et
1. La r esolution de ce syst` eme peut e tre ramen ee a ` celle dun syst` eme lin eaire de dimension trois. Quelle est linconnue facile a ` d eterminer. Donner cette inconnue et le syst` eme 3X3 restant, que lon notera .
u est triangulaire inf erieure a ` 2. Factoriser la matrice en produit (o` erieure) puis r esoudre le syst` eme. diagonale unit e et triangulaire sup 3. Trouver T .
80
3.4
exercice 19
D E F
7 w8 @7
4 u
Ce syst` eme s ecrit sous la forme
8 8 ~
t
, o` u

n m
et
Posons
m
, on calcule
, o` u

do` u:

n m
on calcule
m

n n m m
, o` u
m
Donc,
m
La matrice m est ainsi triangulaire sup erieure, cest la matrice recherch ee. n n n n n n Dautre part, on a m , on en d eduit donc que m m m m m
n m m


Ainsi,
81
Tm
, avec

On a ainsi factoris e sous la forme :
Pr esantation de la m ethode didentication R esoudre revient a ` r esoudre . On pose alors , la r esolution du syst` eme initial revient a ` r esoudre successivement les deux syst` emes triangulaires :

Finalement, on r esout :
Y

P

P
Exercice 20
Soit le syst` eme lin eaire
o` u:

et
Factorisons la matrice en produit ! . n n n Posons m , on calcule m m

m
, o` u

do` u:
82

n m
on calcule
m

n n m m

, o` u
m
Donc,
m
La matrice m est ainsi triangulaire sup erieure, cest la matrice recherch ee. n n n n n n m m m m m . On en d eduit donc Dautre part, on a m
n n m m
"Q
Ainsi,

, avec

"Q
se factorise donc sous la forme :
R esolvons le syst` eme . Cela revient a ` r esoudre puis dire a ` r esoudre successivement les syst` emes
, cest a `

Finalement, on r esout :

"Q
83
Exercice 18
Cest un exercie sur le pivot de Gauss. Soit le syst` eme lin eaire :
4
4
m

a)Appliquons la m ethode de Gauss classique a ` ce syst` eme : On e limine alors le premier terme de la seconde ligne du syst` eme (1) gr ace a ` la combinaison lin eaire do` u le syst` eme
5

Si on pose
j

0 a

7 G m
i
t

m '

alors le syst` eme (2) s ecrit
j yC
U
z

im X

SI on traite ce calcule avec un ordinateur ctif approchant les nombres ottants (les r eels sur ordinateur) avec 3 chiffres d ecimaux signicatifs, alors dans (2) on aura U U
et on obtiendrait ainsi
S
sGq~
do` u en reportant dans la premi` ere ligne du syst` eme (2) on trouve
La solution du syst` eme donn ee par cet ordinateur ctif serait alors . b) Permutant maintenant les deux lignes du syst` eme initial (1). on r esout donc

4
4 4
m

La m ethode de Gauss donne :
~ Soit en posant a , yC ~
U

X


Do` u, avec le m eme ordinateur ctif,
S
84
5
S
et en reportant dans la premi` ere ligne du syst` eme (2) on trouve
5 5@5G5p C@j~ a
La solution du syst` eme donn ee par cet ordinateur ctif serait alors , tr` es proche de la solution exacte qui est bien sur . La solution obtenue gr ace au syst` eme (1) sans permutation de lignes est erU ron ee car, lors de l elimination de Gauss, on divise par le pivot , tr` es voisin de la pr ecision de la machine utilis ee, do` u lerreur num erique. En permutant les deux lignes du syst` eme on e vite ce probl` eme puisque le nouveau pivot est alors e gal a ` , valeur tr` es grande par rapport a ` la pr ecision de la machine.
Exercice 19
R esoudre le syst` eme suivant : a) En repr esentant les nombres en virgule ottante avec 8 chiffres signicatifs, b) puis exactement,
ta 0
q
4
ca

SOLUTION a TAPER ...
Exercice 20
q a ..

..
. . .
. . .
. . .

. .
.. .. ..
. . . .. ..

. .
. . . .

Y x x x x
.. . . . . . . . . .
. . ..

. .
.
5 r 5 r

h h
@ @
x
. . .

Triangularisation : On annule
85 en faisant
()(0( !!! #%$ &'$ !!! 12#4365874@BA9 C& 3 DE # E & E !! !!! !!! !
.. . .. . .. .. . .. .. . . .
1
. . .
. . .
. . .
. .. .. . . .. .
. .
" 1
1 1 (0()(
. . . . . .
DGFGH $I# FGDGH F $P& FGH# F $

0 ( i
Q%RRR !! T $ Q%RR RRR !!! TTU3E RRR RRR RRR !!! RRR W RRR !!! RRR RRR !!! S " TVTFFH $ S
0
i
. . .
'
, on a alors :
!!! X 3 5 X $ 7 9 X $ !!! X E @ A ! !!! !!! !

. . .
Q%RRR RRR RRR RRR RR
. . .
$ H " X FG XF S
. . .

Si on pose

'& $ ()(0( !!! #%$ !!! 12#4365 D 3Cbc$ &C# 3 & DE E E !! !!! !!! !
.. . .. .. . . .. .. .. . . .
Cette e tape s ecrit alors
C`
i
a`
0 0
(et pour
) j

1
. . . .. .. . .
1
. . .
1
. . .
. . .
" 1
1 1 (0()(
. . . . . .
F DH F $ & F H# F $ D FGH $ # G
.
..
Q RRR !! T $ Q RR RRR !!! TTU3E RRR RRR RRR !!! RRR W RRR !!! RRR RRR !!! FFH $ S S " TVTU
. . .
!!! 3 X $ 3%d$ !!! X 5 X E D ! !!! !!! !

. . .
Q RRR RRR RRR RRR RR
. . .
F FH $ S " X XG
. . .
? ? ? ? ? ? ? ? ? ? ? ? ? COMPleter ici Et ainsi de suite. . . On retrouve bien les formules propos ees. Nombre dop erations :
fe
u
fe
Gh
yuy
pi
ge ge
vaqC
op eration op eration division soustraction multiplication, division t soustraction t multiplication, soustraction mutliplication
a a

fois fois
86
Exercice 21
R esolution dun syst` eme dans
9n C a n @
u
~ 5

! t

u
1. M ethode du point xe.
ha$ j$
4 u 1
! h 5 !h @
) ) 1
NB : pour que le processus du point xe converge, il suft que
( G 7 et y( , donc, q $ y G $ t q . c.` a.d. que Pour G et G , on a : h G G G @ G 5 G @ G 5 G G

ici,
) s ) u ( ( s s H BQ ) BQ )Q ) BQ B (QQ Q
Grs q utt
s #
vt t
wt t
xt t
1
h( i
Q 4
4 Ce proc ed e diverge-t-il ? Il faut montrer quen , on a s Q . Or, donc . Ainsi, H s r r r Q , et Q implique que , ce qui est impossible H r r )Q . Donc, BQ BQ B . . . La m puisque ethode diverge.
q ha$ G G G tG

2. M ethode de Newton. q3 , avec
87
a$
h

! h 5 y !h @ ( h 5 t t t ! hG @ t y!h @ t t y ! h @ t t t t y t t y t t t t
) ) ) ) ) & ) u
, et
Ici,
( t t y( t y
( )
q(
t t t y t

Par cons equent, Newton s ecrit :
hdq 5wyC 5q z hj$ h ! h5qC @'tC hqC 5 t w!ht q ~hd j$ hv~C hq 7t hd @ Pour G et G , on a : h
4 t( ( u 4 q( 4 ( u 4 t( ( BQ ) BQ BQ ) )Q )j
88
3.5
3.5.1

Les tableaux multidimensionnels en Java
Les tableaux multidimensionnels en Java correspondent a ` des tableaux de tableaux. Ce sont donc des objets et les d eclarer sans les construire avec new consiste a ` r eserver une adresse pour lobjet. Il est alors possible de construire s eparemment les sous-tableaux qui ne sont pas n ecessairement de taille identique. On peut donc, soit cr eer des tableaux de taille homog` enes, comme dans la construction qui suit : int [] [] t = new int[5][10] ; soit construire des sous-tableaux de tailles distinctes, comme ci-dessous : int m [] []; m = new int [3] []; // tableau pouvant contenir les 3 adresses // des sous-tableaux m[0] = new int[2]; m[1] = new int[4]; m[2] = new int[1]; Notons aussi que le calcul de la longueur dun tableau multidimensionnel avec length correspond au domaine de variation de premier indice du tableau : ainsi, dans lexemple pr ec edent, m.length vaut 3.
3.5.2
Une classe matrice
On construit ci-dessous une classe matrice qui permet de d enir les op erateurs matriciels classiques, dune mani` ere non exhaustive. A partir de cette construction, le lecteur pourra facilement ajouter les op erateurs dont il a besoin en sinspirant de ceux d ej` a d enis. Le stockage des coefcients de la matrice se fait gr ace a ` un tableau dobjets du type vecteur que lon a d enit dans le premier chapitre, chacun des vecteurs ayant la m eme taille. Ce tableau est priv e et on d enit les fonctions coef( , ) et toCoef( , , ) qui permettent respectivement daller rechercher un coefcient et den changer la valeur. public class matrice { private vecteur[] composant; matrice (int dim1, int dim2)
89
/** constructeur creant une matrice de coefficients nuls * de dim1 lignes * et dim2 colonnes */ { composant = new vecteur [dim1]; for (int i=0; i<dim1; i++) composant[i] = new vecteur(dim2); } matrice (double tableau [][]) /** constructeur creant une matrice a partir du * parametre tableau */ { composant = new vecteur [tableau.length]; for (int i=0; i<tableau.length; i++) composant[i] = new vecteur (tableau[i]); } public int nbLignes() /** renvoie le nombres de lignes de la matrice */ { return composant.length; } public int nbColonnes() /** renvoie le nombre de colonnes de la matrice */ { return composant[0].dim(); } public double coef(int nl, int nc) /** renvoie le coefficient a la position (nl, nc) */ { return composant[nl].elt(nc); } public void toCoef(int i, int j, double x) /** affecte la valeur de x au coefficient a la * position (nl, nc) */ { composant[i].toElt(j, x); }

void afficher() /** affiche les coefficients de la matrice */ { for (int i=0; i<nbLignes(); i++) { for (int j=0; j<nbColonnes(); j++) System.out.print(coef(i,j)+" "); System.out.println(""); } System.out.println(""); }
90
public static vecteur produit(matrice m, vecteur x) /** renvoie le vecteur obtenu en multipliant * la matrive m par le vecteur x */ { vecteur y = new vecteur(m.nbLignes()); for (int i= 0; i<m.nbLignes(); i++) { double somme = 0.0; for (int j= 0; j<m.nbColonnes(); j++) somme += m.coef(i,j) * x.elt(j); y.toElt(i, somme); } return y; } public static matrice produit(matrice m1, matrice m2) /** renvoie la matrice obtenue en multipliant les deux * matrices m1 et m2 */ { matrice result = new matrice(m1.nbLignes(), m2.nbColonnes()); for (int i=0; i<m1.nbLignes(); i++) for (int j=0; j<m2.nbColonnes(); j++) { double somme = 0.0; for (int k=0; k<m1.nbColonnes(); k++) somme += m1.coef(i,k) * m2.coef(k,j);

result.toCoef(i, j, somme); } return result; }
91
public static matrice addition(matrice m1, matrice m2) /** renvoie la matrice obtenue en additionnant les deux * matrices m1 et m2 */ { matrice result = new matrice(m1.nbLignes(), m2.nbColonnes()); for (int i=0; i<m1.nbLignes(); i++) for (int j=0; j<m2.nbColonnes(); j++) result.toCoef(i, j, m1.coef(i,j) + m2.coef(i,j)); return result; } public static matrice soustraction(matrice m1, matrice m2) /** renvoie la matrice obtenue en soustrayant la matrice m2 * a la matrice m1 */ { matrice result = new matrice(m1.nbLignes(), m2.nbColonnes()); for (int i=0; i<m1.nbLignes(); i++) for (int j=0; j<m2.nbColonnes(); j++) result.toCoef(i, j, m1.coef(i,j) - m2.coef(i,j)); return result; } } Programme de test : class testMatrice { public static void main(String args[]) { double [][] t1 = { {1., 2., 3.}, {4., 5., 6.} }; double [][] t2 = { {2., 4.}, {4., 2.}, {1., 1.} }; double [][] t3 = { {2., 3., 2.}, {5., 6., 5.} }; double [] t = {2., 1., 0.};
92
matrice m1 = new matrice(2, 3); for (int i=0; i<m1.nbLignes(); i++) for (int j=0; j<m1.nbColonnes(); j++) m1.toCoef(i, j, t1[i][j]); System.out.println("matrice m1 :"); m1.afficher(); matrice m2 = new matrice(t2); System.out.println("matrice m2 :"); m2.afficher(); matrice m3 = new matrice(t3); System.out.println("matrice m3 :"); m3.afficher(); vecteur x = new vecteur(t); System.out.println("vecteur x :"); x.afficher(); vecteur y = matrice.produit(m1, x); System.out.println("m1*x :"); y.afficher(); matrice m4 = matrice.produit(m1, m2); System.out.println("m1*m2 : "); m4.afficher(); m4 = matrice.addition(m1, m3); System.out.println("m1+m3 : ");m4.afficher(); m4 = matrice.soustraction(m1, m3); System.out.println("m1-m3 : ");m4.afficher(); } } Lex ecution du programme pr ec edent g en` ere lafchage suivant : java testMatrice matrice m1 : 1.0 2.0 3.0 4.0 5.0 6.0 matrice m2 : 2.0 4.0 4.0 2.0 1.0 1.0
93
matrice m3 : 2.0 3.0 2.0 5.0 6.0 5.0 vecteur x : 2.0 1.0 0.0 m1*x : 4.0 13.0 m1*m2 : 13.0 11.0 34.0 32.0 m1+m3 : 3.0 5.0 5.0 9.0 11.0 11.0 m1-m3 : -1.0 -1.0 1.0 -1.0 -1.0 1.0
3.5.3
Une classe abstraite de syst` eme lin eaire
Nous allons e tre amen e a ` traiter et en particulier a ` r esoudre des syst` emes lin eaires de diff erentes natures, a ` savoir triangulaire sup erieur ou inf erieur, a ` diagonal unit e ou non, ou encore des syst` emes g en eraux. Les grandes biblioth` eques connues de type BLAS (Basic Linear Algebra Subroutine) construisent autant de fonctions de r esolution distinctes quil y a de types diff erents de syst` emes. Sappuyant sur le principe de r eutilisabilit e de la programmation objet, nous allons d enir une classe abstraite g en erale qui sera le d enominateur commun de tous les syt` emes lin eaires et dont h eritera les classes sp ecialis ees. On considerera quun syst` eme lin eaire ne peut e tre construit quapr` es la construction effective de la matrice et du second membre du syst` eme et le constructeur dun syst` eme ne peut donc se faire quavec ses deux e l ements. Par ailleurs, la seule m ethode qui nous int eresse, pour linstant, est celle qui calcule la solution du syst` eme. Cette r esolution peut e ventuellement conduire a ` un e chec si la matrice est singuli` ere et non allons pour cela faire la gestion dune exception SysLinEception succeptible d etre lev ee en cours de calcul. La classe abstraite g en erale et la classe dexception associ ee sont alors les suivantes :

class SysLinException extends Exception{ public String toString(){ return( "Systeme singulier"); } }
94
abstract class sysLin{ int ordre; protected matrice matriceSysteme; protected vecteur secondMembre; sysLin (matrice m, vecteur x){ matriceSysteme = m; secondMembre = x; ordre = x.dim(); } abstract public vecteur resolution() throws SysLinException; }
3.5.4
Les classes syst` emes lin eaires triangulaires
Nous pouvons e crire maintenant une classe de syst` emes lin eaires triangulaires sup erieurs qui va impl ementer la m ethode resolution et g erer lexception SysLinException lorsquun e l ement de la diagonale de la matrice est nul : class sysTriangSup extends sysLin { sysTriangSup(matrice m, vecteur x) { super(m,x); } public vecteur resolution() throws SysLinException { vecteur x = new vecteur(ordre); double somme; for (int i=ordre-1; i>=0; i--){ somme=secondMembre.elt(i); for (int j=i+1; j<ordre; j++) somme -= matriceSysteme.coef(i,j) * x.elt(j); double termDiagonal = matriceSysteme.coef(i,i); if (termDiagonal == 0) throw new SysLinException(); x.toElt(i, somme / matriceSysteme.coef(i,i)); } return x; }

}
95
Pour tester notre classe, il nous faut saisir la matrice et le second membre du syst` eme. Pour cela nous allons passer par linterm ediaire dun chier en reprenant les constructions qui ont e t e pr esent ees au premier chapitre et en y ajoutant lutilisation dun analyseur de type StringTokenizer qui va pouvoir d ecomposer une ligne constitu ee de plusieurs valeurs num eriques et les extraire. Une lecture attentive du listing qui suit permet facilement den comprendre le fonctionnement : tout est bas e sur lutilisation de la fonction nextToken() qui d ecompose la cha ne jusquau prochain s eparateur. import java.io.*; import java.util.*; class bibMatFileIn{ FileReader fichier=null; BufferedReader lecbuf; public bibMatFileIn(String nomfichier) { try{ fichier = new FileReader (nomfichier); lecbuf = new BufferedReader (fichier); } catch (FileNotFoundException e){ System.out.println("fichier inexistant ! "); } } vecteur lectureVecteur(){ String line, word; vecteur vlu=null; try{ // lecture taille du vecteur (sur 1 ligne) : line = lecbuf.readLine(); int nb = Integer.parseInt(line); vlu = new vecteur(nb); // lecture coef. du vecteur (sur 1 ligne) : int n=0; line = lecbuf.readLine(); StringTokenizer st = new StringTokenizer(line); // while ((word=st.nextToken()) != null) for(int i=0; i<nb; i++){ word = st.nextToken();

vlu.toElt(n++, Double.valueOf(word).doubleValue()); } } catch(IOException e){ System.out.println("erreur de lecture"); } catch(NumberFormatException e){ System.out.println("erreur conversion chaine"); } return vlu; }
96
matrice lectureMatrice(){ String line, word; matrice mlu=null; StringTokenizer st; try{ // lecture ordre matrice (sur 1 ligne) : line = lecbuf.readLine(); st = new StringTokenizer(line); word = st.nextToken(); int nbLignes = Integer.parseInt(word); word = st.nextToken(); int nbColonnes = Integer.parseInt(word); mlu = new matrice (nbLignes, nbColonnes); // lecture coef. matrice, ligne par ligne : for (int i=0; i<nbLignes; i++){ line = lecbuf.readLine(); st = new StringTokenizer(line); for (int j=0; j<nbColonnes; j++){ word = st.nextToken(); mlu.toCoef(i,j, Double.valueOf(word).doubleValue()); } } } catch(IOException e){ System.out.println("erreur de lecture"); } catch(NumberFormatException e){ System.out.println("erreur conversion chaine"); }

return mlu; }
97
public void fermer(){ try{ fichier.close(); } catch (IOException e) { System.out.println("Le fichier ne peut pas etre fermer"); } } } Nous e crivons ensuite une classe de test qui va mettre en uvre une programme principal : class testSysTriangSup{ public static void main(String args[]){ bibMatFileIn f = new bibMatFileIn("donnee.dat"); // on lit dans le fichier "donnee.dat" : // lordre de la matrice : nblignes et nbcolonnes sur 1 ligne // les coef. de la matrice ligne par ligne // la taille du second membre sur 1 ligne // les coef. du second membre sur 1 ligne // Attention : les dimensions matrices et vecteurs doivent // etre corrects ... pas de verification ! matrice m = f.lectureMatrice(); vecteur b = f.lectureVecteur(); f.fermer(); System.out.println(" SYSTEME LU"); System.out.println("La matrice lue est : "); m.afficher(); System.out.println("Le sd membre lu est : "); b.afficher(); sysTriangSup sts = new sysTriangSup(m, b); try{ vecteur x = sts.resolution(); System.out.println("La solution trouvee est : "); x.afficher(); vecteur v = matrice.produit(m, x); System.out.println("Verification - le produit de la matrice "+ "par la solution vaut :"); v.afficher(); } catch (SysLinException e){ System.out.println(e); }

} } On pr esente maintenant deux tests dex ecution. Le chier de donn ees du premier test contient sur la premi` ere ligne, les dimensions de la matrice (5,5) ; sur les 5 lignes qui suivent, chacune des lignes de la matrice ; sur la ligne suivante, la taille du vecteur second membre ; sur la derni` ere ligne, les coefcients du second membre. Le chier est donc le suivant : 5 1 0 0 0 0 5 5 5 2 7 0 0 0 3 8 6 0 0 4 9 7 5 0 5 8 3 6 1
98
4 3 2 1 Lafchage g en er e par le programme, a ` partir de ce chier, est le suivant :
java testSysTriangSup SYSTEME LU La matrice lue est : 1.0 2.0 3.0 4.0 5.0 0.0 7.0 8.0 9.0 8.0 0.0 0.0 6.0 7.0 3.0 0.0 0.0 0.0 5.0 6.0 0.0 0.0 0.0 0.0 1.0 Le sd membre lu est : 5.0 4.0 3.0 2.0 1.0 La solution trouvee est : 1.6190476190476195 -0.6095238095238098 0.9333333333333336 -0.8 1.0 Verification - le produit de la matrice par la solution vaut : 5.0 4.0 3.000000000000001 2.0 1.0 Le deuxi` eme test sert a ` v erier le bon fonctionnement de lexception qui d etecte un syst` eme singulier. Le chier de donn ees est le suivant : 5 5 1 2 3 4 5

0 0 0 0 5 5 7 0 0 0 8 6 0 0 9 7 5 0 8 3 6 0
99
4 3 2 1 Lafchage g en er e par le programme, a ` partir de ce chier, est le suivant :
java testSysTriangSup SYSTEME LU La matrice lue est : 1.0 2.0 3.0 4.0 5.0 0.0 7.0 8.0 9.0 8.0 0.0 0.0 6.0 7.0 3.0 0.0 0.0 0.0 5.0 6.0 0.0 0.0 0.0 0.0 0.0 Le sd membre lu est : 5.0 4.0 3.0 2.0 1.0 Systeme singulier Nous construisons ensuite une classe syst` eme triangulaire inf erieure sur le m eme mod` ele, mais en ne sint eressant quau cas o` u la matrice est, de plus, a ` diagonale unit ee. En effet, cest ce cas qui sera rencontr e lorsque lon mettra en uvre la m ethode de factorisation LU. class sysTriangInfUnite extends sysLin{ sysTriangInfUnite (matrice m, vecteur x) { super(m, x); } public vecteur resolution() { vecteur x = new vecteur(ordre); double somme; for (int i=0; i<ordre; i++){ somme = secondMembre.elt(i); for (int j=0; j<i; j++) somme -= matriceSysteme.coef(i,j) * x.elt(j); x.toElt(i, somme); } return x; } }
100
3.5.5
La classe syst` emes lin eaires g en erals impl ementant la factorisation LU
Rappels sur lalgorithme de calcul des coefcients de L et de U Nous pr esentons ici un algorithme de calcul effectif des coefcients des matrices et qui factorise une matrice dordre . est une matrice triangulaire inf erieure a ` diagonale unit e et est une matrice triangulaire sup erieure. Nous proc edons par identication a ` partir du produit
avec G si t , G si et WG La formule du produit matriciel s ecrit :

G
si

On consid` ere alors les deux cas suivants : t ... a ` nir ...
Compl ements de la classe matrice avec la m ethode de factorisation LU Lalgorithme de factorisation LU dune matrice ne concerne que la matrice et doit donc trouver sa place dans la classe matrice. Cest pour cette raison que nous compl` etons celle-ci avec la m ethode suivante, qui reprends lalgorithme pr ec edent : public void factorLU() throws SysLinException /** calcul de la factorisation LU de la matrice courante * les coefficients de L et de U sont stockes en lieu et place * des coefficients de memes rangs de la matrice dorigine */ { int i, j, k; double somme, coefDiagonal; for (i=0; i<nbLignes(); i++) { for (j=0; j<i; j++) { somme=coef(i,j); for (k=0; k<j; k++) somme -= coef(i,k)*coef(k,j);

coefDiagonal = coef(j,j); if (coefDiagonal == 0) throw new SysLinException(); toCoef(i, j, somme/coefDiagonal); } for (j=i; j<nbColonnes(); j++) { somme=coef(i,j); for (k=0; k<i; k++) somme -= coef(i,k)*coef(k,j); toCoef(i, j, somme); } } } La classe syst` eme g en eral r esolu par factorisation LU
101
Nous pouvons alors d enir une classe syst` eme g en eral r esolu par une m ethode de factorisation LU. Cest la classe qui suit dans laquelle on notera que lon a ajout e une m ethode resolutionPartielle() qui permet de r esoudre le syst` eme lorsque la matrice est d ej` a sous la forme factoris ee. Il faut, en effet, se rappeler que lun des int er ets de cette m ethode de factorisation est quelle ne n ecessite pas de refactoriser la matrice (op eration la plus co uteuse) lorsque lon doit r esoudre plusieurs syst` emes avec la m eme matrice. Par exemple, le calcul de linverse dune matrice dordre n se fait en r esolvant n syst` emes ayant tous la m eme matrice : cest la matrice a ` inverser. Les seconds membres sont, quant a ` eux, les n vecteurs de la base canonique. La classe syst` eme g en eral avec m ethode de factorisation LU est donc la suivante : class sysGeneLU extends sysLin { sysGeneLU (matrice m, vecteur x) { super(m,x); }
public vecteur resolution() throws SysLinException { vecteur x = null; try{ matriceSysteme.factorLU(); sysTriangInfUnite sysTIU = new sysTriangInfUnite( matriceSysteme, secondMembre); x = sysTIU.resolution(); sysTriangSup sysTS = new sysTriangSup( matriceSysteme, x);
102
x = sysTS.resolution(); } catch (SysLinException e) { System.out.println(e); } return x; } public vecteur resolutionPartielle() throws SysLinException { sysTriangInfUnite sysTIU = new sysTriangInfUnite( matriceSysteme, secondMembre); vecteur x = sysTIU.resolution(); sysTriangSup sysTS = new sysTriangSup( matriceSysteme, x); try{ x = sysTS.resolution(); } catch (SysLinException e) { System.out.println(e); } return x; } } Exemple dex ecution avec chier de donn ees et traitement dexception Nous avons e crit un programme de test tout a ` fait similaire a ` celui qui a servit a ` tester la r esolution dun syst` eme triangulaire sup erieur : class testSysGeneLU{ public static void main(String args[]){ bibMatFileIn f = new bibMatFileIn("donneeSGLU.dat"); matrice m = f.lectureMatrice(); vecteur b = f.lectureVecteur(); f.fermer(); System.out.println(" SYSTEME LU"); System.out.println("La matrice lue est : "); m.afficher(); System.out.println("Le sd membre lu est : "); b.afficher(); matrice mcopy = new matrice(m.nbLignes(), m.nbColonnes()); mcopy.recopier(m); sysGeneLU sglu = new sysGeneLU(m, b); try{ vecteur x = sglu.resolution(); System.out.println("La solution trouvee est : "); x.afficher(); vecteur v = matrice.produit(mcopy, x); System.out.println("Verification - le produit de la matrice "+ "par la solution vaut :"); v.afficher();

} catch (SysLinException e){ System.out.println(e); } } }
103
Pour faire la v erication, on peut remarquer quil a e t e n ecessaire de recopier la matrice dorigine dans une autre matrice, puisque la matrice dorigine se verra transformer lors de lappel de sa factorisation sous la forme LU. Il faut donc compl eter la classe matrice de la mani` ere suivante pour y ajouter la m ethode recopier : public void recopier(matrice m) /** recopie la matrice m dans la matrice courante */ { for (int i=0; i<nbLignes(); i++) for (int j=0; j<nbColonnes(); j++) toCoef(i, j, m.coef(i,j)); } Voici le chier test qui a e t e utilis e: 5 1 2 2 5 2 5 5 5 2 5 6 6 5 3 1 1 4 5 4 6 8 7 2 5 7 6 7 2
4 3 2 1 Voici le r esultat de lafchage du programme :
java testSysGeneLU SYSTEME LU La matrice lue est : 1.0 2.0 3.0 4.0 5.0 2.0 5.0 1.0 6.0 7.0 2.0 6.0 1.0 8.0 6.0 5.0 6.0 4.0 7.0 7.0 2.0 5.0 5.0 2.0 2.0
104
Le sd membre lu est : 5.0 4.0 3.0 2.0 1.0 La solution trouvee est : -1.1396574440052718 -0.29776021080368853 0.5335968379446643 0.11594202898550718 0.9341238471673253 Verification - le produit de la matrice par la solution vaut : 5.0 3.9999999999999982 2.999999999999999 1.9999999999999947 1.0
Chapitre 4 Graphisme scientique avec Java

4.1 Applets
Une applet est un programme qui est inclus dans une page HTML et qui va donc e tre ex ecuter par le navigateur lisant cette page, a ` condition quil poss` ede les fonctionnalit es pour le faire. Il doit donc contenir une machine virtuelle Java compress ee (cest le cas des navigateurs usuels qui contiennent aujourdhui un noyau Java correspondant a ` un JDK 1.1). La classe java.applet.Applet doit e tre la classe m` ere de toute applet incluse dans un document.
4.1.1
Un premier exemple
Le programme HelloWorld.java suivant d enit une applet HelloWorld qui utilise un objet Graphics qui constitue un e l ement de base de la biblioth` eque awt qui est repris avec plus de pr ecision dans le paragraphe 4.2. Cette applet utilise la m ethode drawString sur cet objet, ce qui lui permet dafcher une cha ne de caract` eres a ` une position donn ee sur la fen etre courante du navigateur.
import java.applet.Applet ; import java.awt.Graphics ; public class HelloWorld extends Applet { public void paint(Graphics g) { g.drawString("Hello world", 50, 25); } }
Il faut noter d` es a ` pr esent que cette applet ne poss` ede pas de point dentr ee main(), celui-ci se trouve g erer implicitement par le navigateur. 105

Voici maintenant un exemple de page HTML qui appelle lapplet :
<html> <head> <title> Un exemple dapplet </title> </head> <body> <applet code="HelloWorld.class" width=150 </applet> </body> </html>
106
height=25>
En appelant cette page HTML dans un navigateur int egrant Java, on verra appara tre dans le navigateur le message Hello world.
4.1.2
Passage de param` etres
La m ethode suivante permet de r ecup erer des param` etres pass es a ` une applet dans une page HTML :
public String getParameter(String name)
Cette m ethode ne peut e tre appel ee que dans les m ethodes init() ou start() dune applet (ces m ethodes sont d ecrites plus loin). Voici donc une nouvelle version HelloWorld2.java
import java.applet.Applet; import java.awt.Graphics; public class HelloWorld2 extends Applet { String e; public void init() { e=getParameter("message"); } public void paint(Graphics g) { g.drawString(e, 50, 25); } }
Voici un exemple de page HTML qui appelle lapplet :

<html> <head> <title> Un exemple dapplet avec param` etres</title> </head> <body> <applet code="HelloWord2.class" width=150 height=25> <param name="message" value="Bonjour"> </applet> </body> </html>
107
4.1.3
Cycle de vie
Le navigateur utilis e pour ex ecuter lapplet contr ole la vie et lactivation de lapplet gr ace aux quatres m ethodes suivantes : public void init() est appel ee apr` es le chargement de lapplet dans la page html ; public void stop() est appel ee chaque fois que le navigateur arr et lex ecution de lapplet, soit parce que lutilisateur change de page web, soit parce quil iconie le navigateur ; public void start() est appel ee chaque fois que lapplet doit d emarrer, apr` es init() ou apres un stop() lorsque lutilisateur revient sur la page web contenant lapplet ou lorsquil d esiconie le navigateur ; public void destroy() est appel ee a ` la fermeture du navigateur. Elle d etruit les ressources allou ees pour lapplet.
4.1.4
Compl ements
Nous donnons bri` evement et de mani` ere non exhaustive quelques points dentr ee pour les lecteurs d esirant utiliser les aspects multim edia de Java mais que nous nutiliserons pas dans le cadre des applications pr esent ees dans cet ouvrage. Des m ethodes sont disponibles pour r ecup erer des images et des sons : public Image getImage(URL url) ; public Image getImage(URL url, String name) ; public AudioClip getAudioClip(URL url) ; public AudioClip getAudioClip(URL url, String name) ; Des m ethodes de la classe java.applet.AudioClip permettent de manipuler les sons ainsi r ecup er es : public abstract void play() ; public abstract void loop() ; public abstract void stop(). Des m ethodes sont e galement disponibles pour jouer directement les sons : public void play(URL url) ; public void play(URL url, String name).
4.2
4.2.1
Gestion de fen etres avec AWT

Trac es dans des applets
Nous d ecrivons comment effectuer des trac es g eom etriques dans la zone graphique dune applet. Nous utilisons pour cela des m ethodes de la classe
108
java.awt.Graphics . Elles sont r esum ees ci-dessous. (une description plus pr ecise sera trouv e dans la documentation des API). public void draw3DRect(int x, int y, int width, int height, boolean raised) trace un rectangle en relief ; public abstract void drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) trace un arc de cercle ; public abstract void drawLine(int x1, int y1, int x2, int y2) trace un segment de droite ; public abstract void drawOval(int x, int y, int width, int heignt) trace une ellipse ; public abstract void drawPolygon(int xPoints[], int yPoints[], int nPoints) trace un polygone ; public void drawRect(int x, int y, int width, int height) trace un rectangle vide ; public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) trace un rectangle vide a ` bords arrondis ; public void fill3Drect(int x, int y, int width, int height, boolean raised) trace un rectangle plein en relief ; public abstract void fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) trace un arc de cercle plein ; public abstract void fillOval(int x, int y, int width, int heignt) trace une ellipse pleine ; public abstract void fillPolygon(int xPoints[], int yPoints[], int nPoints) trace un polygone plein ; public abstract void fillRect(int x, int y, int width, int height) trace un rectangle plein ; public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight) trace un rectangle plein a ` bords arrondis. Voici un exemple dapplet contenant des graphiques :
import java.awt.*; public class Test extends java.applet.Applet { public void paint(Graphics g) { int i; g.setColor(Color.yellow); for (i= 0; i<14; i++) g.drawLine(10, 10+16*i, 10+16*i, 218);

for (i= 0; i<14; i++) g.drawLine(10+ 16*i, 10, 218, 10+16*i); for (i= 0; i<14; i++) g.drawLine(10, 218-16*i, 10+16*i, 10); for (i= 0; i<14; i++) g.drawLine(10+16*i, 218, 218, 218-16*i); } }
109
Pour terminer, nous signalons que, dans la suite de cet ouvrage, nous pr esenterons principalement des applications graphiques autonomes et non sous forme dapplets, car elles sont, de fait, plus g en erales. Les indications donn ees pr ec edemment sont sufsantes pour permettre une transformation assez facile de ces applications autonomes en applets.
4.2.2
Construire des interfaces fen etr ees
Une premi` ere fen etre Dans lexemple qui suit, on construit une simple fen etre dune dimension initiale, avec un titre. La fen etre construite d erive de la classe Frame qui permet de d enir des fen etres avec barre de titre, menu, bords, etc ... On utilise WindowListener pour pouvoir g erer la fermeture de la fen etre qui seffectue lorsque lutilisateur clique sur lic one sup erieure droite du bandeau de fen etre : il faut alors d ecrire qui g` ere des e v` enements de ce type. Dans Java 1.1 et sup erieur, cette gestion se fait par des ecouteurs d ev` enements (listener). Ici, pour un objet h eritant de WindowListener , on se mettra ` a l ecoute des e v` enements gr ace a ` la m ethode addWindowListener . WindowListener est une interface (cest une classe abstraite particuli` ere, sans variable dinstance et o` u toutes les m ethodes sont abstraites : on repr esente ainsi un ensemble de comportements qui doivent e tre impl ement es dans les classes qui impl ementent cette interface). Elle contient un certain nombre de m ethodes abstraites quil faut red enir. Ici, on red enit non trivialement la seule m ethode windowClosing qui permettra de g erer la fermeture de la fen etre.
import java.awt.*; import java.awt.event.*; public class Fenetre extends Frame implements WindowListener { public Fenetre() { setSize(400, 300); } public void windowClosing(WindowEvent event) { System.exit(0);

} public public public public public public
110
void void void void void void
windowClosed(WindowEvent event) {} windowDeiconified(WindowEvent event) {} windowIconified(WindowEvent event) {} windowActivated(WindowEvent event) {} windowDeactivated(WindowEvent event) {} windowOpened(WindowEvent event) {}
public static void main(String arg[]) { Fenetre Test = new Fenetre(); Test.setTitle("ma fenetre JAVA"); Test.show(); Test.addWindowListener(Test); } }
Dans la suite de ce chapitre(4.3.2), nous donnerons une alternative plus all eg ee a ` cette gestion d ev` enements attach es a ` des fen etres, en sappuyant sur un exemple. Les diff erentes parties dune fen etre Une fen etre g er ee par lAWT peut comorter plusieurs e l ements caract eristiques : Une page de fond ou canevas, dans laquelle on pourra tracer des gures g eom etriques comme celles qui ont e t e d ecrites au paragraphe 4.2.1 ; Une e tiquette (Label) qui permet dafcher un texte ; Une zone de texte (TextArea) pour un afchage pouvant e tre modi e; Une liste d eroulante permettant de faire un choix (List) ; Une zone de saisie de texte (TextField) ; Un bouton (Button) ; Une case doption (Checkbox) ; Un menu d eroulant (Menu et MenuBar). Un exemple : un compteur Dans lexemple comment e suivant, on met en uvre une petite interface graphique incluant diff erents boutons et g erant des e v` enements.
import java.awt.* ; import java.awt.event.* ; class FenetreCompteur extends Frame {

int compteur ; // d efinition de boutons // en param` etre : le texte des boutons Button boutonIncr = new Button("+"); Button boutonDecr = new Button("-"); Button boutonQuit = new Button("quit");
111
// un champ qui permettra dafficher la valeur du compteur // en param` etre : la taille des caract` eres TextField affichageCompteur = new TextField(7); //gestion des ev` enements provoqu es //par les clics sur les boutons class ActionIncr implements ActionListener { public synchronized void actionPerformed(ActionEvent e) { compteur ++; afficherCompteur(); } }; class ActionDecr implements ActionListener { public synchronized void actionPerformed(ActionEvent e) { compteur --; afficherCompteur(); } }; class ActionQuit implements ActionListener { public synchronized void actionPerformed(ActionEvent e) { System.exit(0); } }; void afficherCompteur() { affichageCompteur.setText(String.valueOf(compteur)); } // constructeur public FenetreCompteur(String nom) { super(nom); compteur = 0; setSize(240, 80); setLayout(new FlowLayout()); add(boutonIncr); add(boutonDecr); add(boutonQuit); add(affichageCompteur); boutonIncr.addActionListener( new ActionIncr());

boutonDecr.addActionListener( new ActionDecr()); boutonQuit.addActionListener( new ActionQuit()); } } public class TestAWT { static public void main(String argv[]) { FenetreCompteur x = new FenetreCompteur("compteur"); x.show(); } }
112
F IG . 4.1: Fen etre g en er ee par le programme TestAWT
v` Gestion des e enements Sur lexemple pr ec edent, on a vu comment utiliser des e v` enements de type ActionEvent a ` partir des composants Button et TextField. Dautres types d ev` enements existent : MouseEvent pour les mouvements et cliquage de souris ; FocusEvent pour savoir si la souris est au-dessus de la zone consid er ee ; KeyEvent pour lenfoncement dune touche ; TextEvent pour la modication de texte pour un composant int egrant une zone de texte. Il faut alors cr eer, relativement a ` un e v enement de type xxxEvent, une classe qui impl emente xxxListener o` u lon d enira le traitement a ` faire lorsque l ev enement a lieu (m ethode actionPerformed ). Dans la classe fen etre, on lancera l ecoute des e v` enements avec addListener. Placement des composants Les diff erents composants dune fen etre peuvent e tre plac es de plusieurs mani` eres avec un gestionnaire de placements (layout manager) :
113
FlowLayout range les composants ligne par ligne et de gauche a ` droite ; BorderLayout place les composants dans 5 zones : le centre et les 4 c ot es ; GridLayout place les composants sur une grille 2D ; GridBagLayout place les composants sur une grille 2D, avec des coordonn ees. Les zones nont pas toutes n ecessairement la m eme dimension.
4.3
Construction de courbes de trac es scientiques
Nous allons maintenant pr esenter quelques classes qui permettent deffectuer des trac es simples de courbes scientiques bidimensionnelles. Nous proposons une organisation en plusieurs classes par soucis de g en ericit e et de r eutilisabilit e. Pour ne pas alourdir les programmes qui se veulent avant tout p edagogiques, nous pr esentons des constructions qui peuvent e tre grandement am elior ees sur leurs aspects esth etiques.
4.3.1
Les domaines bidimensionnels de lutilisateur et du dispositif dafchage
Le graphisme scientique n ecessite de repr esenter des courbes dont les domaines de d enition des coordonn ees peuvent e tre tr` es variables dune utilisation a ` lautre. On souhaite malgr e cela afcher a ` l ecran ou sur un autre dispositif dafchage des graphiques qui vont tous occup es une place a peu pr` es similaire. Il faut donc d enir : un domaine correspondant a ` la variation des coordonn ees des diff erents points de la gure a ` repr esenter ; un domaine correspondant a ` lespace utilis e sur le dispositif dafchage. Pour cela, nous d enissons deux classes e l ementaires qui vont respectivement repr esenter ces deux domaines :
class DomaineDouble { public double xmin, ymin, xmax, ymax; DomaineDouble(double x0, double y0, double x1, double y1) { xmin=x0; ymin=y0; xmax=x1; ymax=y1; } } class DomaineInt { public int xmin, ymin, xmax, ymax;

DomaineInt(int x0, int y0, int x1, int y1) { xmin=x0; ymin=y0; xmax=x1; ymax=y1; } }
114
Il faut aussi d enir un processus de passage dun domaine a ` lautre, ce qui est d ecrit dans les paragraphes suivants.
4.3.2
Un gestionnaire de fen etres de base
Nous d ecrivons dabord une classe d eriv ee de la classe Frame qui va g erer un environnement fen etr e rudimentaire qui est constitu e de deux composants situ es lun en-dessous de lautre (cest-` a-dire dans les parties North et Center du gestionnaire de mise en page BorderLayout) : un Canvas o` u seront trac ees la ou les courbes ; un Label qui donne un titre a ` la fonction trac ee. cette information sera souvent r ecup er ee dune m ethode appel ee libelle que nous avons ajout ee a ` linterface FoncD2D, d ej` a utilis e pr ec edemment et qui s ecrit maintenant :
interface FoncD2D { public double calcul(double x); public String libelle(); }
Par ailleurs, nous ne faisons quune gestion minimale de la fen etre que lancera notre programme nal, en ne soccupant que de sa fermeture, gr ace a ` lic one sup erieure droite de la barre de titre. Nous avons choisit une m ethode alternative a ` ce que nous avons pr esent e pr ec edemment (4.2.2) : On utilise une classe d eriv ee de la classe pr ed enie WindowAdapter. Ceci nous permet de ne red enir explicitement que la m ethode windowClosing, comme on le voit dans le listing qui suit :
import java.awt.*; import java.awt.event.*; import DomaineInt; class MiniWinAdapter extends WindowAdapter { public void windowClosing(WindowEvent e) {System.exit(0);} } class FenetreGraphe extends Frame { FenetreGraphe(DomaineInt de, Canvas c, String texte) { setTitle(new String("graphe dune fonction")); setSize((int)(de.xmax - de.xmin), (int)(de.ymax - de.ymin)+50); setLayout(new BorderLayout());

addWindowListener(new MiniWinAdapter()); add("North",c); add("Center", new Label(texte, Label.CENTER)); } }
115
4.3.3
Une classe dutilitaires pour le trac e de graphismes scientiques
Dans la classe qui suit, nous avons r eunit un ensemble de proc edures utiles pour faire des trac es de courbes : mapX et mapY soccupent de faire le changement de coordonn ees a ` partir du domaine que lon doit repr esenter, vers le domaine du dispositif dafchage et ceci, respectivement, pour chacune des coordonn ees. Line et Carre effectuent les trac es g eom etriques e l ementaires correspondant a ` leur d enomination. coloreFond colore le fond du Canvas dafchage. tracePoints et tracePolyline afchent un ensemble de points dont les coordonn ees sont donn ees en param` etres. Pour la deuxi` eme m ethode, les points sont reli es par des segments. traceAxes afchent des axes de coordonn ees passant par lorigine en afchant les valeurs des coordonn ees des extr emit es des axces. Ces axes ne sont effectivement afch es que sils sont situ es dans la vue repr esent ee qui est d enie par le domaine a ` repr esenter. Pour cette raison, on d enit lalternative suivante. traceAxesCentres effectuent le m eme travail a ` la diff erence que les axes sont centr es par rapport au milieu du domaine dafchage et ne passent donc pas, en g en eral, par lorigine. traceFonction effectue le trac e graphique dune fonction de type FoncD2D, pass ee en param` etre.
import import import import java.awt.*; FoncD2D; DomaineDouble; DomaineInt;
class ManipGraphe { DomaineInt ce; // coordonnees ecran DomaineDouble crv; // coordonnees reelles visualisees DomaineDouble cr; double dx; // pas sur x
116
ManipGraphe(DomaineDouble domReel, DomaineInt domEcran) { ce=domEcran; cr=domReel; // calcul dune marge autour du domaine utilisateur double deltax = (domReel.xmax - domReel.xmin)/10; double deltay = (domReel.ymax - domReel.ymin)/10; crv = new DomaineDouble (domReel.xmin - deltax, domReel.ymin - deltay, domReel.xmax + deltax, domReel.ymax + deltay); dx = (cr.xmax - cr.xmin)/30; } public int mapX (double x) { return ce.xmin + (int) ((x-crv.xmin)/(crv.xmax-crv.xmin)* (ce.xmax-ce.xmin)); } public int mapY (double y) { return ce.ymin + (int) ((crv.ymax-y)/(crv.ymax-crv.ymin)* (ce.ymax-ce.ymin)); } public void Line(Graphics g, double x1, double y1, double x2, double y2) { g.drawLine(mapX(x1), mapY(y1), mapX(x2), mapY(y2)); } public void Carre(Graphics g, double x, double y) { g.drawRect(mapX(x)-2, mapY(y)-2,4,4); } public void coloreFond(Graphics g, Color c) { g.setColor(c); g.fillRect(ce.xmin, ce.ymin, ce.xmax-ce.xmin, ce.ymax-ce.ymin); } public void tracePoints(Graphics g, Color c, double[] x, double[] y) { g.setColor(c); for (int i=0; i<x.length; i++) Carre(g, x[i], y[i]); }
117
public void tracePolyLine(Graphics g, Color c, double[] x, double[] y) { g.setColor(c); for (int i=1; i<x.length; i++) Line(g, x[i-1], y[i-1], x[i], y[i]); } public void traceAxes(Graphics g, Color c) { g.setColor(c); Line(g, 0, cr.ymin, 0, cr.ymax); Line(g, cr.xmin, 0, cr.xmax, 0); g.drawString(new String(String.valueOf(cr.ymin)), mapX(dx/2), mapY(cr.ymin)); g.drawString(new String(String.valueOf(cr.ymax)), mapX(dx/2), mapY(cr.ymax)+10); g.drawString(new String(String.valueOf(cr.xmin)), mapX(cr.xmin), mapY(dx/2)); g.drawString(new String(String.valueOf(cr.xmax)), mapX(cr.xmax)-30, mapY(dx/2)); } public void traceAxesCentres(Graphics g, Color c) { g.setColor(c); double crymid = (cr.ymax + cr.ymin)/2; double crxmid = (cr.xmax + cr.xmin)/2; Line(g, crxmid, cr.ymin, crxmid, cr.ymax); Line(g, cr.xmin, crymid, cr.xmax, crymid); g.drawString(new String(String.valueOf(cr.ymin)), mapX(crxmid+dx/2), mapY(cr.ymin)); g.drawString(new String(String.valueOf(cr.ymax)), mapX(crxmid+dx/2), mapY(cr.ymax)+10); g.drawString(new String(String.valueOf(cr.xmin)), mapX(cr.xmin), mapY(crymid+dx/2)); g.drawString(new String(String.valueOf(cr.xmax)), mapX(cr.xmax)-30, mapY(crymid+dx/2)); } public void traceFonction(Graphics g, Color c, FoncD2D f, double mini, double maxi) { double x1, y1, x2, y2; g.setColor(c); x2=mini; y2 = f.calcul(x2); for (x1=mini; x1<= maxi; x1 += dx) {

y1= f.calcul(x1); Line(g, x1, y1, x2, y2); x2=x1; y2=y1; } } }
118
4.3.4
Un exemple dutilisation
Lutilisateur nal de cette biblioth` eque graphique rudimentaire aura a è crire un programme similaire a ` celui qui est donn e dans la suite. Il contient une classe impl ementant linterface FoncD2D car il effectue le trac e dune fonction qui est transmise sous ce type a ` la biblioth` eque graphique. Il contient e galement deux autres classes qui devront toujours appara tre lorsque lon sera amen ea ` utiliser la biblioth` eque : une classe qui d erive de la classe pr ed enie Canvas qui repr esente la partie de fen etre o` u doit e tre trac e le graphique. Cette classe poss` ede un constructeur qui a pour param` etres les domaines - de lutilisateur et du dispositif graphique - concern es et les composantes graphiques qui doivent e tre afch ees, ici une fonction. Cette classe contient une m ethode essentielle qui est la m ethode paint : cest ici que lon doit d ecrire pr ecis ement tout ce qui devra e tre trac e au nal, a ` lex ecution du programme. une classe contenant le programme principal et qui construit les domaines, le Canvas et la fen etre dafchage.
import import import import import import java.awt.*; FoncD2D; ManipGraphe; FenetreGraphe; DomaineDouble; DomaineInt;
class CanvasGraphe extends Canvas { ManipGraphe mp = null; FoncD2D f; DomaineDouble cr; DomaineInt ce; CanvasGraphe(FoncD2D fonc, DomaineDouble domReel, DomaineInt domEcran) { cr=domReel; ce=domEcran;f = fonc;
119
setSize(new Dimension(ce.xmax-ce.xmin, ce.ymax-ce.ymin)); mp = new ManipGraphe(domReel, domEcran); } public void paint(Graphics g) { mp.coloreFond(g,Color.white); mp.traceAxes(g,Color.black); mp.traceFonction(g, Color.blue, f, cr.xmin, cr.xmax); mp.Carre(g,0,0); } } class MaFonction implements FoncD2D { public double calcul(double x) {return x*x;} public String libelle() {return "f(x)=x*x";} } class GraphFonc { static public void main(String argv[]) { MaFonction fct = new MaFonction(); DomaineDouble dr = new DomaineDouble(-2, -0.5, 2, 5); DomaineInt de = new DomaineInt(0, 0, 600, 450); CanvasGraphe cg = new CanvasGraphe(fct, dr, de); FenetreGraphe x = new FenetreGraphe(de, cg, fct.libelle()); x.show(); } }
120
F IG . 4.2: Fen etre g en er ee par le programme de trac e de courbe donn e en exemple
Chapitre 5 Interpolation Polyn omiale

5.1 Introduction. Existence et unicit e du polyn ome dinterpolation
, Soit une application de IR dans IR, dont on connait n+1 points pour . Le but du probl` eme dinterpolation est de d eterminer une fonction simple a ` calculer, telle que :
f8g i h Gjjjkml n
ed'd
Les points sont appel es points dinterpolation ou dappui. Les fonctions les plus couramment utilis ees sont des polyn omes des fractions rationnelles, des sommes dexponentielles etc . Dans ce volume on ne traitera que le cas o` u est un polyn ome. Th eor` eme 5 Une condition n ecessaire et sufsante pour quil existe un polyn ome unique interpolant est que les points dinterpolation soient tous distincts.
evedmd n
noedvgpedqrfsgphiGjjjtul n jjj
wcx
5.2
Interpolation de Lagrange
Interpolation lin eaire Connaissant deux points dappui et , on approche la valeur de , pour tout dans par lordonn ee du point de m eme abscisse se trouvant sur la droite joignant les deux points dappui. Dans ce cas le polyn ome dinterpolation est du premier degr e et s ecrit :
ezzdmd
td
kyqezpdmd {|kyqmz'}
w y~etdvgeky'd z zd ky kyz zxky

121
122
Interpolation quadratique Connaissant trois points dappui , et , on approche la valeur de , pour tout x dans par lordonn ee du point de m eme abscisse se trouvant sur la parabole passant par les trois points dappui. Dans ce cas le polyn ome dinterpolation est du second degr e et s ecrit :
ezzdmd eped'd
etd
ekyqezd'd { kyqmzm}
w y~etdvgky'd ezpdeqd kyzpdekyqd eky%deqd zd zky%dezxqd kymd~ezqd d kymd~evzqd evedmd
Interpolation de Lagrange, cas g en eral de degr e n bas es sur les points dappui polyn omes de degr en:
x ) u tdxg V fsghijjjkul u u tels que dg et edgh pour fg . Le polynome dinterpolation de Lagrange est donn e par x w6x tdvg u u etd'e d
On appellera polyn ome de Lagrange , pour les n+1
fghGjjjkul
Remarque 6 La formule ci-dessus n ec essite un grand nombre dop erations pour sa mise en oeuvre informatique ( au total ). En regroupant astucieusement les termes de , on peut e erations, do` u, si on pose : conomiser le nombre dop et ; alors et
Ul z Vl v x m d d xG y~etdvg x ete d e t v d g ' d d u etdvg'm)q x )q wcx tdxg xG y~etd p d etd x y Th eor` eme 6 (erreur de linterpolation de Lagrange) Soit 22 {pu} , et 6 w x soit td le polynome dinterpolation de sur les points 4ed'd , pour tout {pu} , il existe }fvle6mduse6md~{ tel que fghijjjkul . Pour c w x lerreur td etd soit x etdvg uxG y 0q y e d x yugummGel d~etd , on alors etd 'uxG y 0q x y . Si on pose
123
5.3
Interpolation dHermite
w e duged 4Udg w eedvgpeeedq8fsgphGjjjkul Th eor` eme 7 Si les points dappui sont tous distincts, alors il existe un po-
En plus de la valeur de aux n+1 abscisses on xe la valeur de sa derivee en ces m emes abscisses, on cherche donc un polynome tel que :
x x w etdug x C tdmd w Cetd' d o` u dvg{ied dC} z etd CCet v z x t v d g e d e t d Ctdxg G avec x z z {pu} , et soit Th eor` eme 8 (erreur de linterpolation dHermite) Soit wcx etd le polynome dinterpolation de Hermite de sur les points e edmd , pour fghijjjkul . Pour tout {pu} , il existe }fvle6mduse6md~{ tel que wcx etd est : lerreur td xG y~etd'd z z x z tdvg Vl Udq e d x xG y~etdvg e d . o` u
lyn ome P et un seul de degr e au plus 2n+1 tel que les e ees. galites (*) soient veri Ce polyn ome P s ecrit
124
5.4
Enonc es des Exercices Corrig es
Exercice 31 : D eterminer le polyn ome dinterpolation de Lagrange satisfaisant au tableau cidessous
Exercice 32 : . Soit D eterminer le polyn ome dinterpolation de Lagrange pour les points dappui dabscisses : -2, -1, 0, 1, 2 . Discuter lerreur dinterpolation. Exercice 33 : Avec quelle pr ecision peut-on calculer grange, si on prend les points : Exercice 34 : ; estimer la valeur de Soit
etdvg y y q
h etd
a` laide de linterpolation de La ghUhimkygUmzgG .
etdvg hi)hd avec : hi)h hiVh hiVh hi0Uh etd hi0Ui h0UiG hi0U hViG
Comparer avec la valeur exacte obtenue gr ace a ` votre calculatrice. Exercice 35 : a) Re ecrire la formule dinterpolation de Lagrange dans le cas o` u les points dappui sont e quidistants. b) Utiliser le m eme tableau qu` a lexercice pr ec edent compl et e par la vraie valeur de et estimer la valeur de .
hi)h
hi
Exercice 36 : a) Utiliser la formule dinterpolation de Lagrange pour trouver la cubique passant par 0.4, 0.5, 0.7, 0.8 pour b) M eme question pour . Exercice 37 : Soit
etdvg . w 1. Determiner le polyn ome etd de Lagrange bas e sur les points dabscisses 0, 1 et 2. w w 2. Calculer hiad et h0d , et comparer aux valeurs exactes. Evaluer lerreur dinterpolation en ces deux points. Commentaires ?
tdvgym6 tdug B

Exercice 38 : Soit
125
etdvg
1. Determiner le polyn ome -2, 0 et 2.
yy .
, et comparer a ` la valeur exacte. Evaluer lerreur dinterpola2. Calculer tion en ce point. Commentaires ? Exercice 39 : Calculer le polyn ome dHermite Q tel que : Q(0)=f(0), Q(0) =f(0), Q(5)=f(5), Q(5)=f(5), pour En d eduire la valeur de Q(4), comparer f(4) a ` Q(4).
w %d
w etd de Lagrange base sur les points dabscisses
etdvg
y y .
126
5.5
Exercice 40 : D emontrer le th eor` eme 5, qui donne condition n ecessaire et sufsante pour quil existe un polyn ome unique interpolant une fonction , a ` savoir que les points dinterpolation soient tous distincts.
w6x
Exercice 41 : Soit
etdvg . w 1. Determiner le polyn ome etd de Lagrange bas e sur les points dabscisses 0, 1 et 2. w w 2. Calculer hiad et h0d , et comparer aux valeurs exactes. Evaluer lerreur dinterpolation en ces deux points. Commentaires ?
Exercice 42 : On se donne les trois points dinterpolation suivants : , , . Avec quelle pr ecision peut-on calculer a ` laide de linterpolation de Lagrange appliqu ee a ` une fonction que vous donnerez ?
g kyg zg
Exercice 43 : . Soit
etdvg y y w 1. Determiner le polyn ome etd de Lagrange bas e sur les points dabscisses 0, 1 et 2. w y 2. Calculer z d , et comparer a ` la valeur exacte. Evaluer lerreur dinterpolation en ce point. Commentaires ?
Exercice 44 : Approcher par interpolation de Lagrange, sachant que et . Donner une majoration de lerreur th eorique de cette interpolation et la comparer a ` lerreur effectivement commise (utiliser . une dalculatrice pour avoir la valeur exacte de
vUUi)d iUUh 6vUUhdgi0V
kvVdpg
vU0Ud
127
5.6
exercice 22
Rappelons que le polyn ome de Lagrange bas e sur les points dappui dabscisses ecrit : est dordre N et s
mkya'
wcx etdvg p e d u tdq u tdvg m
avec
ici les points dappui donn es par :
g kyrg z2g 2g
d ky'd zd d
g g g g
d etermineront donc un polyn ome de Lagrange dordre 3, celui-ci s ecrit :
v w etdvg p d etd
avec
u etd g kymd~e zqde qd e kymd~e zqde qd d~ed d g e hUdh dh d g h e d~ed d
yetd g d~ezqdeqd e ky d~ekyzqdekysqd hd~ed d g ev hdv dv d g sd~e d
zetd g d~ekymdeqd e zx d~ezxkymdezvqd hd~e d d g e hdUd d g se dUd etd g d~ekymdezqd e x d~exkymdevzqd g h se Uded
128
Finalement,
w etdrg e d u etd ekymd ytd zqd z td epd etd U z V g h Uh tdvg z . Les points dappui sont : g drg kyfg kymdrg zg h zqdrg g qdrg g ~drg
w tdxg p e d u td
exercice 23
Soit
zy y
z y
Le polyn ome de Lagrange est donc dordre 4. Il s ecrit

avec
129
u etd yetd zetd etd Vetd

& &
e d de d g V s g se d~e dUd g d d d~e d g se d~e d~e d g V se d d dq
Finalement,
!"$#%'&(0)12#3)"4&57682#6%4&579@$#9%A&(!B$#%A C G& C HPI C HPI D 4IQC R& D HPI C HPI D C@DFE CBD CS G& D HG& C HTI C HTI D 4I C G& D HR& C HR& D CBD C G& D HR& C HPI C C@DFE C IVUWX 6 & C`Y C8E
y c w x x tdvgetd etdvg y etd l dq ) d g f . Elle verife, o` u, 2awBacbedwdxg etd x y~td l dq x y o` u x x yqtd g p e d x y x yrg ac b!q d sr'd hpi
Comme ici on a points dappui, cette erreur est major ee par :
Calculons lerreur th eorique sur cette interpolation. celle-ci est donn ee ou point par :
etd etd
130
z z ` calculer g On a clairement etdvg p w dugse d~e d . Il reste a z V d V h s V h ac b!q d $r'd Un calcul assez long donne : tdg hpi % z d1t (Ceci peut e obtenu en d ecomposant de la facon suivante, etdug y parzy exemple y y y y g zy y tre . On calcule alors la d eriv ee dordre u y v d wq , ce qui est y simple, x plus x g y z % td y y z y z g %% d ty d y . . x . wq g % d1 y w u y % y y td w td g fR f f UhUf g % UfhU td t z % ftd t hz V d g hVsC dHt z { t h UV z V} .) de m eme, on trouve t etdvg y g hh , (pour trouver Ainsi l etude de donne les extremas de , cest a ` dire les racines de l equation z z t UXh% d8c{a Gh V }g h , on a recours au chapitre 2 sur la r esolution des e quations non lin eaire dans ). Finalement, td td v d g se z d z d h h etd etd v d g se z d~e z d w y Application P y y a ` g z . On a z dughi0 , z dvghi0U , donc lerreur effective w y y zy dVgphi)h . Or est z dvg| z d d d dq gphi0Ui
do` u
Par cons quent , linterpolation de Lagrange, dans ce cas, donne une bonne approximation de .
zy d zy d y zd
131
exercice 25
Soit Estimons la valeur de gr ace a ` une interpolation de Lagrange bas ee sur les points dappui don es dans lexercice. Le polyn ome de Lagrange s ecrit
etd g
6hi)d
w etdvg p etd 6
(Il est de d egr e 3 car on a 4 points dappui), avec
u tdvg m On cherche donc v w hpdug p d hiudq u Calculons tout dabord les nombres hipd , on a u hiud g ky'd~e zqde qd e kymd zqde d hiGd~%hiGd~%hid g % hiGd%hipd%hiud g
De m eme, on trouve :
y hipdfg zhipdfg hipdfg w v hipd hipd y~hipd hid zhiud g i h u d Ainsi, hiud hiud hipd soit w hipdughUh .

Estimation de lerreur th eorique dans ce cas. Elle est major ee par
132
x xu y ga(b! d | y etd , donc etd e dkymd~ezqdeqd Cherchons . On a etdug etd , etdvg y m, tdxg y . Donc etdvg z et etdvg F t . Ainsi, g hiudg t g z t td h . F Donc, etd h)d~ehi0dhi0d~e hi)d V V h . Or, la valeur exacte y Ainsi, hipdw z . En fait, on a i h ) d R t U hU de hi)dvghi hU . Lerreur effectivement commise lors de lapproximation w w . G h de h0d par hi0d est donc h0dp%hi0hVdgi0 V Donc, dans ce cas, linterpolation de Lagrange donne un bon r esultat.
o` u
x y~td G td el dq x y
exercice 26
a) On cherche la formule de Lagrange dans le cas o` u les e points sont e quidistants. Dans ce cas on a f hg Bei kj , (o` uj u `l ), do` mj . Dautre part, pour tout , il existe un r eel n tel que
sg f
tf hGa y kg m
g k
133
x d e mx e nejde jd e jd jd mx nej j g m j j x n g m jjj~jjj n l avec gp g n n n l darn lkd g n q n dqarnt % d x d qen l dq hi) , donc cinq points b) On a ghi , kygh , zghi) , ghi0 , nejgh g n hia , alors, ng . e quidistants. Comme ghi0Vg u Calculons les etd pour ghi x pu . % d q n d~r n dq nd~r nd o CVdfg hilhd g % d q n d~r n dq n dr n d g V hi)d%hi)dCU0d~%)d g h0hUix y % d nr nd~r ndr n d oyhVdfg l d %dC dC) d%U) d g g hii0U V
On trouve de m eme
g nej . Par consequent, v etdvg u nejdvgpoqndrg g
~zhidfg i h 0UV o~hidfg hiU o`hidfg hi) hVi

o

Finalement, s . Alors que la valeur exacte est
134
hi)iG
w hVd g
u e d u td g s p do rnd g hi0i .
exercice 29
Soit
x ecrit, tdvg y y . Le polyn ome dHermite t s x x x t etdvg p tdm d p tdm e d avec d d1v z etd etd g uu etd g d z tdq u et , sachant que les abscisses des points Calculons les polyn omes , dappui sont gph et kyvgp . u td g ky g k y y~td g g ky w r td g y td g etdrg umx e d x td8v z etd z g hd 3 kx zy g z
wr
yetd g umx ekymd x y td8v zy etd z g Ud {kx y g U z

Dautre part,
135
etdvg d z tdvgehd x yetdvgkymd zy etdvge d
L ecart peut sembler important, mais un calcul de lerreur th eorique sur linterpolation dHermite montre que lerreur effectivement commise est plus petite que cette erreur th eorique, (laiss e en exercice). En outre, la valeur est relativement proche du bord de lintervalle dinterpolation qui est , et en g en eral, pour linterpolation de Lagrange ainsi que celle dHermite, lerreur samplie au bord de lintervalle dinterpolation (ce ph enom` ene est dit de Runge), voir la partie travux pratiques.
tdrg p etd'e d u etdm e d g tdm d ymky'd etd' d yqetdm ekymd z d d z d~% hz d g U z d % V U h U z g U U d }hiaG et pour comparaison d}h0hV . Ainsi on a t e~
Ainsi,
zg z y zg z x |y U
{hip}
g
5.7
On pr esente dans la suite une mise en uvre dun calcul dinterpolation polyn omiale, bas e sur la formule de Lagrange d ecrite dans le paragraphe 5.2, sous sa forme e nonc ee dans la remarque 5 de ce paragraphe. Soient B pour tion. Le calcul de linterpol e en
ed
h fx l , les n points dappui du calcul dinterpola secritx : x y wcx y~etdvg x etd p

avec
136
x y g m e d x x e td g e d
Pour effectuer ce calcul, on utilise un chier pour r ecup erer les coordonn ees des points de support. On e crit pour cela une classe TableauFileIn, similaire a ` celle e crite dans le paragraphe 3.4.4 et qui effectue ce travail. Les deux tableaux des abscisses et des ordonn ees sont lus lun apr` es lautre. Cette classe correspond a `:
import java.io.*; import java.util.*; class TableauFileIn { FileReader fichier=null; BufferedReader lecbuf; String line; public TableauFileIn(String nomfichier) { try{ fichier = new FileReader (nomfichier); lecbuf = new BufferedReader (fichier); } catch (FileNotFoundException e) { System.out.println("fichier inexistant !"); } } public double[] lectureTableau() { String line, word; double [] tlu = null; StringTokenizer st; try { // lecture de la taille du tableau sur la ligne 1 : line = lecbuf.readLine(); int nb = Integer.parseInt(line); tlu = new double[nb]; // lecture des coef. du tableau sur 1 seule ligne : line = lecbuf.readLine();
137
st = new StringTokenizer(line); for (int j=0; j<nb; j++) { word = st.nextToken(); tlu[j] = Double.valueOf(word).doubleValue(); } } catch (IOException e) { System.out.println("erreur de lecture"); } catch (NumberFormatException e) { System.out.println("erreur de conversion chaine vers double"); } return tlu; } public void fermer() { try { fichier.close(); } catch (IOException e) { System.out.println("Le fichier ne peut pas etre fermer"); } } }
x . Une m ethode priv ee se charge du calcul de et nalement la m ethode publique interP effectue le calcul effectif de linterpolation.
coefcients
On pr esente ensuite la classe InterPoly qui permet de repr esenter une interpolation polyn omiale dont le constructeur se chargera de m emoriser les tableaux des coordonn ees des points dappui qui lui sont transmis en param` etres. Ce constructeur commence e galement le calcul des coefcients qui ne d ependent x pas de labscisse a ` laquelle se fera la calcul dinterpolation : il sagit des
import import import import
java.lang.*; java.io.*; java.util.*; TableauFileIn;
class InterPoly { int n; double [] xk; double [] yk; double [] ydp;
// // // //
nombre de points dinterpolation abscisses des points dinterpolation ordonnes des points dinterpolation coefficients de la formule dinterpolation

static double epsilon = 1e-10; // epsilon-machine InterPoly(double [] xdata, double [] ydata) { n = xdata.length; xk = xdata; yk = ydata; ydp = new double[n]; calCoef(); } // calcul de gamma_n(x) private double gamma(double x) { double prod = x-xk[0]; for (int i=1; i<n; i++) { prod *= x-xk[i]; } return prod; }
138
private void calCoef() { double prod; int k,j; for (k=0; k<n; k++) { prod=1; for (j=0; j<k; j++) { prod *= xk[k]-xk[j]; } for (j=k+1; j<n; j++) { prod *= xk[k]-xk[j]; } ydp[k] = yk[k]/prod; } } public double interP(double x) { double diff; diff = x- xk[0]; if (Math.abs(diff) < epsilon) return yk[0]; double som = ydp[0]/diff; for (int k=1; k<n; k++) { diff = x-xk[k]; if (Math.abs(diff) < epsilon) return yk[k]; som += ydp[k]/diff; } return som*gamma(x); } }
Nous pr esentons ensuite une classe qui contient un programme de test qui lit un chier contenant les coordonn ees des points dappui et qui afche dans une fen etre un graphique qui contient les points de supports (sous la forme de
139
petits carr es) et une courbe de la fonction dinterpolation construite a ` partir de ces points. Ces trac es graphiques utilisent la biblioth` eque d ecrite dans la chapitre pr ec edent et sont d ecrits dans la m ethode paint de la classe CanvasGraphe dont le constructeur initialise les composants graphiques qui seront utilis es et qui sont transmis en param` etres. Le domaine de repr esentation de ce graphique est obtenu en recherchant les coordonn ees extr` emes des points de support. Ceci se fait gr ace a ` la classe MaxminTabDouble construite a ` cet effet et d ecrite dans le listing qui suit :
import import import import import import import import import import
java.lang.*; java.io.*; java.util.*; java.awt.*; TableauFileIn; InterPoly; DomaineDouble; DomaineInt; ManipGraphe; FenetreGraphe;
class CanvasGraphe extends Canvas { ManipGraphe mp = null; DomaineDouble cr; DomaineInt ce; FoncD2D f; double[]xdata; double[]ydata; CanvasGraphe(DomaineDouble domReel, DomaineInt domEcran, double[] x, double[] y, FoncD2D fonc) { cr = domReel; ce = domEcran; xdata = x; ydata = y; f = fonc; setSize(new Dimension(ce.xmax-ce.xmin, ce.ymax-ce.ymin)); mp = new ManipGraphe (domReel, domEcran); } public void paint(Graphics g) { mp.coloreFond(g, Color.white); mp.traceAxesCentres(g, Color.black); mp.tracePoints(g, Color.red, xdata, ydata); mp.traceFonction(g, Color.blue, f, cr.xmin, cr.xmax);

} } class MaxminTabDouble { double maxi, mini; MaxminTabDouble(double[] t) { maxi=t[0]; mini=t[0]; for (int i=1; i<t.length; i++) { if (t[i] < mini) mini=t[i]; if (t[i] > maxi) maxi=t[i]; } } public double getmaxi() {return maxi;} public double getmini() {return mini;} }
140
class PrgInterPolyGra { public static void main(String args[]) { // lecture du fichier de donn ees TableauFileIn f = new TableauFileIn("donnees.dat"); double[] xlu = f.lectureTableau(); double[] ylu = f.lectureTableau(); f.fermer(); // calcul des extrema des tableaux : MaxminTabDouble mxlu = new MaxminTabDouble(xlu); double maxxlu = mxlu.getmaxi(); double minxlu = mxlu.getmini(); MaxminTabDouble mylu = new MaxminTabDouble(ylu); double maxylu = mylu.getmaxi(); double minylu = mylu.getmini(); // construction de linterpolation polynomiale : InterPoly pp = new InterPoly(xlu, ylu); // representation graphique du calcul : DomaineDouble dr = new DomaineDouble(minxlu, minylu, maxxlu, maxylu); DomaineInt de = new DomaineInt(0, 0, 600, 450); CanvasGraphe cg = new CanvasGraphe(dr, de, xlu, ylu, pp); FenetreGraphe x = new FenetreGraphe(de, cg, pp.libelle());

x.show(); } }
141
Nous montrons les r esultats obtenus pour deux exemples :
Premier exemple Le chier dentr ee qui a e t e utilis e pour les coordonn ees des points dappui est compos e de 4 points et permet dobtenir un r esultat pr evisible et satisfaisant. Il correspond aux donn ees suivantes :
4 0.4 0.5 0.7 0.8 4 -0.91 -0.69 -0.85 -0.22
La fen etre graphique obtenue comme r esultat de ce programme, a ` partir de ces donn ees, correspond a ` la gure 5.1.
F IG . 5.1: Fen etre g en er ee par 1er exemple de calcul dinterpolation polyn omiale
Deuxi` eme exemple
142
Nous prenons maintenant lexemple du a ` Runge et qui consiste a ` calculer une interpolation polyn omiale a ` partir de points dappui extraits de la courbe suivante :
Runge a montr e que lerreur commise entre cette fonction et son interpolation polyn omiale tendait vers linni lorsque le degr e dinterpolation tendait lui-aussi vers linni. Le chier de donn ees utilis e est alors le suivant :
11 -5 -4 -3 -2 -1 0 1 2 3 4 5 11 0.038 0.059 0.1 0.2 0.5 1 0.5 0.2 0.1 0.059 0.038
tdvg z
Comme le laisse pr evoir la propri et ee nonc ee pr ec edemment, la courbe dinterpolation va pr esenter des oscillations, ces derni` eres se situent pour les valeurs dabscisses ayant les plus grandes valeurs absolues. Cest effectivement ce que donne la repr esentation graphique obtenue par le programme et qui est repr esent ee sur la gure 5.2.
143
F IG . 5.2: Exemple de calcul dinterpolation polyn omiale correspondant au ph enom` ene de Runge
Chapitre 6 Approximation par moindres carr es

6.1 Principe dapproximation moindres carr es et crit` ere de
, de f . Dans le chaOn consid` ere les n+1 points " , pour pitre pr ec edent, on sest int eress ea ` la recherche et au calcul de la fonction dinterpolation qui passe exactement par ces points. Dans ce chapitre, on cherche a ` construire une courbe qui, dans un sens a ` pr eciser, sapproche des points " , ces points pouvant provenir de mesures, par exemple, et donc contenir des erreurs exp erimentales.
4 ped
f gPhGaaul
e4 pBd
ci
p(x) xi x
F IG . 6.1: Approximation de donn ees par une fonction p(x) On recherche donc une fonction dapproximation, encore appel ee mod` ele et not ee u qui va r epondre a ` cette question. Ce mod` ele d epend de param` etres : 144
cetd
145
par exemple, sil correspond a ` une fonction polyn ome dun degr e donn e, les param` etres sont les coefcients du polyn ome. Le probl` eme que lon se pose consiste donc a ` rechercher le meilleur jeux de param` etres de fac on a ` ce que la courbe repr esentative du mod` ele passe au plus pr et des points de donn ees. La notion de meilleure proximit e retenue ici est le crit` ere des moindres carr es. Il consiste a ` rechercher le minimum de la fonction :
x ucedd z
Le minimum est r ealis e pour des valeurs particuli` eres des param` etres qui correspondent donc a ` lajustement du mod` ele par rapport aux points de donn ees.
6.2
R egression lin eaire

y y=ax+b
ci
xi
F IG . 6.2: R egression lin eaire On recherche la droite d equation la plus proche de lensemble " , des points , au sens des moindres carr es. Si on note w l ecart entre la droite de r egression et le point consid er e, on cherche le minimum de
g e d f8g hiGaaul qd x x tpqdvg w z g 2 qd z an dobtenir les meilleures valeurs des param` etres et .
Le minimum est obtenue si
gh
wr
gph

y
146
y=ax+b
ci ax+b i ei
x xi
F IG . 6.3: Ecart entre un point et une droite de r egression
Il faut donc r esoudre le syst` eme lin eaire suivant dordre 2 :
Cest a ` dire
x %2 qdvgph t g x t g 2 qdvgph x x z x kg x $ x l d'g p
de la derni` ere e quation, on en d eduit que
g z x o` u lon note , la moyenne des , a ` savoir l . En substituant dans la premi` x ere equation, x on obtient x z 8 w o d og $p

En utilisant la variance
147
x x et z z g d z" g l l x on obtient : l d g spt l de Et donc la valeur de vaut : x s p l d!| g l d Il reste alors a ` d eterminer la pertinence du calcul de r egression lin eaire par rapport aux donn ees. Pour cela, on d x enit le coefcient de correlation lineaire : s pt l e d g l d On montre que g Si est voisin de 0 alors il ny a pas de liaison lineaire entre les 2 coor
donn ees des points de donn ees et le calcul de r egression lin eaire nest pas repr esentatif de ces donn ees ; ees sont proches dun aligne Si est voisin de 1 alors les points de donn ment et le calcul de r egression se justie.
6.2.1
Nous pr esentons maintenant une mise en uvre du calcul de r egression lin eaire en utilisant les formules pr ec edentes. Nous calculons les coefcients de la droite de r egression et le coefcient de corr elation a ` partir du calcul des diff erentes sommes intervenant dans les formules. La classe Reglin effectue ces calculs dans la m ethode calculCoef. Elle poss` ede un constructeur qui a deux param` etres correspondants aux deux tableaux contenant les coordonn ees des points dappui. Ces deux tableaux sont m emoris es dans des donn ees membres. Le calcul des coefcients est alors lanc e en n de construction. On acc` ede aux r esultats, stock es dans des donn ees membres, gr ace a ` des op erateurs dacc` es du type getxxx.

import java.lang.*; import FoncD2D; class Reglin implements FoncD2D{ int n; // nombre de points de support double[] x; // abscisses des points de support double[] y; // ordonnees des points de support double a, b; // resultats de la regression : ax+b double r; // coef. de correlation Reglin(double[] xdata, double[] ydata) { x = xdata; y = ydata; n = x.length; calculCoef(); } private void calculCoef() { double sx=0, sx2=0, sy=0, sy2=0, sxy=0; for (int i=0; i<n; i++) { sx += x[i]; sx2 += x[i]*x[i]; sy += y[i]; sy2 += y[i]*y[i]; sxy += x[i]*y[i]; } double num = sxy - sx * sy /n; double denx = sx2 - sx * sx /n; double deny = sy2 - sy * sy /n; a = num/denx; r = num/Math.sqrt(denx*deny); b = (sy - a*sx) / n; } public double geta() {return a;} public double getb() {return b;} public double getr() {return r;}
148
public double calcul(double z) {return a*z+b;} public String libelle() {return "regression lineaire";} }
Nous pr esentons maintenant un programme utilisant la classe Reglin pour calculer la droite de r egression a ` partir de donn ees stock ees dans un chier. Ce programme est, en fait, tr` es similaire au programme dexemple du chapitre pr ec edent sur linterpolation polyn omiale. On utilise la m eme classe CanvasGraphe qui nest pas r ee crite ci-dessous.
149
import import import import import import import import import import import
java.lang.*; java.io.*; java.util.*; java.awt.*; TableauFileIn; Reglin; DomaineDouble; DomaineInt; ManipGraphe; FenetreGraphe; MaxminTabDouble;
class PrgReglin { public static void main(String args[]) { // lecture du fichier de donn ees TableauFileIn f = new TableauFileIn("donnees.dat"); double[] xlu = f.lectureTableau(); double[] ylu = f.lectureTableau(); f.fermer(); // calcul des extrema des tableaux : MaxminTabDouble mxlu = new MaxminTabDouble(xlu); double maxxlu = mxlu.getmaxi(); double minxlu = mxlu.getmini(); MaxminTabDouble mylu = new MaxminTabDouble(ylu); double maxylu = mylu.getmaxi(); double minylu = mylu.getmini(); // construction de linterpolation polynomiale : Reglin rl = new Reglin(xlu, ylu); System.out.println("Resultats du calcul de regression lineaire :"); System.out.println("Fonction de regression : " +rl.geta()+ " x + " +rl.getb()); System.out.println("coefficient de correlation : "+rl.getr());
// representation graphique du calcul : DomaineDouble dr = new DomaineDouble(minxlu, minylu, maxxlu, maxylu) DomaineInt de = new DomaineInt(0, 0, 600, 450); CanvasGraphe cg = new CanvasGraphe(dr, de, xlu, ylu, rl); FenetreGraphe x = new FenetreGraphe(de, cg, rl.libelle()); x.show(); }

}
150
Ce programme est test ea ` partir des donn ees du chier donnees.dat suivant :
13 0.8 4.9 5.1 6.7 27 34 38 65 72 85 95 97 98 13 0.8 1.6 3.1 6.0 15 26 41 66 78 86 93 96 96
Le programme renvoie des r esultats sous forme texte qui sont les suivants :
java PrgReglin Resultats du calcul de regression lineaire : Fonction de regression : 1.0312158159925882 x + -3.047626180872437 coefficient de correlation : 0.9939141140402419
Le programme lance e galement louverture de la fen etre graphique suivante repr esent ee par la gure 6.4.
6.3
G en eralisation aux mod` eles lin eaires
a ` ajuster par rapport aux donn ees. Un tel mod` ele est appel e lin eaire en raison de son expression qui est effectivement lin eaire par rapport aux param` etres . y eaire en posant On retrouve le mod` ele de r egression lin , et . . Lexpression du mod` ele est donc u
6etdvg y td a ` partir des donn ees e4Bdqph fv l Les fonction sont connues alors que les coefcients y
u
Nous allons e tendre le calcul de r egression lin eaire a ` un mod` ele plus g en eral du type :
sont les param` etres
yetdvg
tdg g ctdvg y4
151
F IG . 6.4: Fen etre g en er ee par le programme de test du calcul de r egression lin eaire
Comme pour le calcul de r egresxion lin eaire, on applique le crit` ere des moindres carr es qui consiste a ` rechercher le minimum de la fonction
x y y ypGGG~ y d g 2 u6eed'd z x z g p y ` d Ce minimum est atteind lorsque les d eriv ees partielles de chaque coefcient , ghGm , sont nulles :
y
par rapport a `
152
y GG y d g h x y y % ed % eed'd g h x x % ed ed g ed x y x ed ed g ed1 y Cest une e quation lin eaire a ` inconnues : , ghiGGm qui se d ecline y pour chaque valeur de , ghiGGGqu . On doit donc r esoudre un syst` eme dordre .

6.3.1
Ecriture matricielle du probl` eme
On pose matrice dordre
et on pose On peut montrer que le syst` eme pr ec edent s ecrit :
l U u d dont les coefcients valent : c g ed GGG~" x d . le vecteur de composantes q

h u vz
La solution
e d coefcients y cherches. En effet x x h h u v g u v og ed1 x h h d ed u v g u!u vzv g y On a donc bien, pour h : h u!um v v gq h d
correspond aux
h u v
153
6.3.2
Nous pr esentons maintenant une mise en uvre de ce calcul matriciel permettant une identication dun mod` ele lin eaire, a ` partir dun ensemble de points dappui. Nous utilisons les diff erentes classes construites dans les chapitres pr ec edents, a ` savoir : vecteur : la classe de vecteurs d enit en 1.3.4 ; matrice : la classe de matrices d enit en 3.4.2 ; sysGeneLU : la classe de syst` emes lin eaires g en eraux d enit en 3.4.5. Nous utilisons aussi une classe dexception SysLinException d enie dans le m eme chapitre et appel ee lorsque la r esolution dun syst` eme lin eaire e choue (matrice num eriquement singuli` ere, par exemple). Le constructeur de la classe Modlin qui suit se charge uniquement de r ecup erer le tableau de fonctions pass es en param` etres et laffecte a ` une donn ee propre du m eme type. La m ethode identifie se charge de faire le calcul didentication sous forme matriciel comme d ecrit pr ec edemment : les matrices et vecteurs n ecessaires sont construits et on appelle la m ethode de r esolution de syst` eme de la classe sysGeneLU. Une m ethode getcoef permet de renvoyer un des coefcients identi es. On d enit aussi les deux m ethodes de linterface FoncD2D que notre classe impl emente. Ces m ethodes seront utilis ees, par exemple, pour permettre une repr esentation graphique gr ace a ` la biblioth` eque d enie au chapitre 4.
import import import import import vecteur; matrice; sysGeneLU; SysLinException; FoncD2D;
class Modlin implements FoncD2D{ int m; // nombre de fonctions de base du modele vecteur coef; // coef. du modele a identifier FoncD2D [] phi; // fonctions de base Modlin(FoncD2D [] foncbase) { m = foncbase.length; phi = foncbase; } public void identifie(double[] xdata, double[] ydata) throws SysLinException { // 1. construction des matrices et vecteurs :
154
vecteur y = new vecteur(ydata); int n = ydata.length; matrice f = new matrice(n,m); matrice ft = new matrice(m,n); for (int i=0; i<n; i++) for (int j=0; j<m; j++) { double coefij = phi[j].calcul(xdata[i]); f.toCoef(i, j, coefij); ft.toCoef(j, i, coefij); } // 2. Construction et r esolution du systeme lineaire : matrice a = matrice.produit(ft,f); vecteur b = matrice.produit(ft,y); sysGeneLU syst = new sysGeneLU(a,b); coef = syst.resolution(); } public double calcul(double x) { double result=0; for(int i=0; i<m; i++) result += coef.elt(i) * phi[i].calcul(x); return result; } public String libelle() {return "modele lineaire de moindres carres";} public double getcoef(int i) {return coef.elt(i);} }
Le programe suivant donne un exemple dutilisation de cette classe. Il a pour but de trouver une approximation par un polyn ome de degr e 3 dun ensemble de points lus dans un chier. Il est en grande partie similaire a ` celui du paragraphe pr ec edent, sauf pour la construction dune instance de la classe Modlin. Lappel a ` la m ethode didentication qui suit se fait en g erant lexception e ventuellement d eclanch ee si la r esolution du syst` eme e choue. On remarquera le processus de construction des diff erentes fonctions de base du mod` ele et du tableau qui les contient.
java.lang.*; java.io.*; java.util.*; java.awt.*;

import import import import import import import TableauFileIn; Modlin; DomaineDouble; DomaineInt; ManipGraphe; FenetreGraphe; MaxminTabDouble;
155
class Fbase1 implements FoncD2D{ public double calcul(double x) {return 1;} public String libelle() {return "f(x)=1";} } class Fbase2 implements FoncD2D{ public double calcul(double x) {return x;} public String libelle() {return "f(x)=x";} } class Fbase3 implements FoncD2D{ public double calcul(double x) {return x*x;} public String libelle() {return "f(x)=x2";} } class Fbase4 implements FoncD2D{ public double calcul(double x) {return x*x*x;} public String libelle() {return "f(x)=x3";} } class PrgModlinPoly { public static void main(String args[]) { // lecture du fichier de donn ees TableauFileIn f = new TableauFileIn("donnees.dat"); double[] xlu = f.lectureTableau(); double[] ylu = f.lectureTableau(); f.fermer(); // calcul des extrema des tableaux : MaxminTabDouble mxlu = new MaxminTabDouble(xlu); double maxxlu = mxlu.getmaxi(); double minxlu = mxlu.getmini(); MaxminTabDouble mylu = new MaxminTabDouble(ylu); double maxylu = mylu.getmaxi(); double minylu = mylu.getmini();
156
// construction de linterpolation polynomiale : Fbase1 f1 = new Fbase1(); Fbase2 f2 = new Fbase2(); Fbase3 f3 = new Fbase3(); Fbase4 f4 = new Fbase4(); FoncD2D [] fbase = {f1, f2, f3, f4}; Modlin ml = new Modlin(fbase); try { ml.identifie(xlu, ylu); System.out.println("Resultats de lidentifiaction des coef. :"); for (int i=0; i<fbase.length; i++) System.out.println("coef. "+i+" : "+ml.getcoef(i)); // representation graphique du calcul : DomaineDouble dr = new DomaineDouble(minxlu, minylu, maxxlu, maxylu); DomaineInt de = new DomaineInt(0, 0, 600, 450); CanvasGraphe cg = new CanvasGraphe(dr, de, xlu, ylu, ml); FenetreGraphe x = new FenetreGraphe(de, cg, ml.libelle()); x.show(); } catch(SysLinException e) { System.out.println("erreur au cours de lidentification"); } } }
Le programme pr ec edent est test e sur le jeu de donn ees qui suit :
13 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 13 -12 -13 -9 -7 -9 0 5 13 11 6 9 5 0
Le programme renvoie les r esultats sous forme texte qui suivent :
java PrgModlinPoly Resultats de lidentifiaction des coef. : coef. 0 : 4.160839160839161 coef. 1 : 3.772560772560772

coef. 2 : -0.3026973026973027 coef. 3 : -0.07925407925407925
157
Il provoque e galement louverture de la fen etre qui est d ecrite dans la gure 6.5.
F IG . 6.5: Fen etre g en er ee par le programme de calcul dun mod` ele lin eaire en utilisant un polyn ome de degr e3
Le r esultat obtenue reste assez e loign e des points de support car le degr e du polyn ome est relativement peu e lev e par rapport aux variations des points de donn ees. On montre ci-dessous comment il est tr` es simple de construire un nouveau mod` ele, ici un polyn ome de degr e 9, et de lint egrer au programme de test. Toutes les classes utilis ees sont sufsamment g en eriques pour ne pas avoir besoin d etre modi ee. Le programme de test devra d enir toutes les classes qui vont permettre de construire les fonctions de base n ecessaires, appel ees ici Fbasexxx. Il ne restera plus qu` a les instancier effectivement et utiliser ces instances pour construire le tableaux des fonctions de base. Tout le reste reste inchang e. Voici ci-dessous la partie de programme a ` modier :
...

class Fbase1 implements FoncD2D{ public double calcul(double x) {return 1;} public String libelle() {return "f(x)=1";} } class Fbase2 implements FoncD2D{ public double calcul(double x) {return x;} public String libelle() {return "f(x)=x";} } class Fbase3 implements FoncD2D{ public double calcul(double x) {return x*x;} public String libelle() {return "f(x)=x2";} } ...
158
class Fbase9 implements FoncD2D{ public double calcul(double x) {return x*x*x*x*x*x*x*x;} public String libelle() {return "f(x)=x8";} } class Fbase10 implements FoncD2D{ public double calcul(double x) {return x*x*x*x*x*x*x*x*x;} public String libelle() {return "f(x)=x9";} } class PrgModlinPoly { public static void main(String args[]) { // lecture du fichier de donn ees TableauFileIn f = new TableauFileIn("donnees.dat"); double[] xlu = f.lectureTableau(); double[] ylu = f.lectureTableau(); f.fermer(); // calcul des extrema des tableaux : MaxminTabDouble mxlu = new MaxminTabDouble(xlu); double maxxlu = mxlu.getmaxi(); double minxlu = mxlu.getmini(); MaxminTabDouble mylu = new MaxminTabDouble(ylu); double maxylu = mylu.getmaxi(); double minylu = mylu.getmini();
159
// construction de linterpolation polynomiale : Fbase1 f1 = new Fbase1(); Fbase2 f2 = new Fbase2(); Fbase3 f3 = new Fbase3(); Fbase4 f4 = new Fbase4(); Fbase5 f5 = new Fbase5(); Fbase6 f6 = new Fbase6(); Fbase7 f7 = new Fbase7(); Fbase8 f8 = new Fbase8(); Fbase9 f9 = new Fbase9(); Fbase10 f10 = new Fbase10(); FoncD2D [] fbase = {f1, f2, f3, f4, f5, f6, f7, f8, f9, f10}; Modlin ml = new Modlin(fbase); ...
Les r esultats obtenus sont donn es ci-apr` es, ainsi que la fen etre graphique g en er ee dans la gure 6.6.
java PrgModlinPoly Resultats coef. 0 : coef. 1 : coef. 2 : coef. 3 : coef. 4 : coef. 5 : coef. 6 : coef. 7 : coef. 8 : coef. 9 : de lidentifiaction des coef. : 7.005477494642518 8.749201812979114 -2.1606780667741687 -1.4914188653043547 0.22366539817694758 0.1196340396538589 -0.00928900068800065 -0.003989574631021212 1.2400793650802364E-4 4.5863252708478754E-5
Nous montrons maintenant un nouveau calcul, a ` partir des m emes donn ees, et qui utilise un mod` ele constitu e dune somme de 4 fonctions trigonom etriques :
ctdugpiyAhi0td zm6hi0td %A%Utd A'6C0td

u
La partie de programme a ` modier est la suivante :
...
160
F IG . 6.6: Fen etre g en er ee par me programme de calcul dun mod` ele lin eaire en utilisant un polyn ome de degr e9
class Fbase1 implements FoncD2D{ public double calcul(double x) {return Math.cos(x/2);} public String libelle() {return "f(x)=cox(x/2)";} } class Fbase2 implements FoncD2D{ public double calcul(double x) {return Math.sin(x/2);} public String libelle() {return "f(x)=sin(x/2)";} } class Fbase3 implements FoncD2D{ public double calcul(double x) {return Math.cos(1.5*x);} public String libelle() {return "f(x)=cos(1.5*x)";} } class Fbase4 implements FoncD2D{ public double calcul(double x) {return Math.sin(1.5*x);} public String libelle() {return "f(x)=sin(1.5*x)";} }
161
class PrgModlinTrigo { public static void main(String args[]) { // lecture du fichier de donn ees TableauFileIn f = new TableauFileIn("donnees.dat"); double[] xlu = f.lectureTableau(); double[] ylu = f.lectureTableau(); f.fermer(); // calcul des extrema des tableaux : MaxminTabDouble mxlu = new MaxminTabDouble(xlu); double maxxlu = mxlu.getmaxi(); double minxlu = mxlu.getmini(); MaxminTabDouble mylu = new MaxminTabDouble(ylu); double maxylu = mylu.getmaxi(); double minylu = mylu.getmini(); // construction de linterpolation polynomiale : Fbase1 f1 = new Fbase1(); Fbase2 f2 = new Fbase2(); Fbase3 f3 = new Fbase3(); Fbase4 f4 = new Fbase4(); FoncD2D [] fbase = {f1, f2, f3, f4}; Modlin ml = new Modlin(fbase); ...
Les r esultats num eriques et graphiques (cf. gure 6.7) sont donn es ci-apr` es.
java PrgModlin Resultats coef. 0 : coef. 1 : coef. 2 : coef. 3 : de lidentifiaction des coef. : 5.208201909446939 10.348725340528471 1.4466187029503472 3.250853663738151
Nous remarquons une assez bonne solution gr ace a ` ce polyn ome trigonom etrique alors que, seuls, quatre coefcients sont a ` calculer, comparativement aux 10 coefcients de lapproximation polyn omiale pr ec edente. Toutefois, il est n ecessaire que les fr equences des fonctions trigonom etriques entrant en jeu soient correctement ajust ees aux donn ees dentr ee. En effet, ces fr equences ne sont pas
162
F IG . 6.7: Fen etre g en er ee par me programme de calcul dun mod` ele lin eaire en utilisant un polyn ome trigonom etrique a ` 4 termes
calcul ees par la m ethode dajustement. Pour quelles soient d etermin ees par un processus de moindres carr es, il serait n ecessaire dintroduire des coefcients a ` identier a ` lint erieur des fonctions trigonom etriques : le mod` ele nest alors plus lin eaire et la m ethode d ecrite, ici, nest plus sufsante. Il faut e laborer une m ethode dajustement de mod` eles non lin eaires. Pour cela, un proc ed e classique serait de plonger la m ethode pr ec edente dans un processus it eratif o` u lon remplace les fonctions non lin eaires par leur d eveloppement limit e au premier ordre. La convergence du processus it eratif permet alors dobtenir la solution de notre probl` eme non lin eaire. Nous nirons pas plus loin, dans le cadre de cet ouvrage, sur cette m ethode sugg er ee ici, m eme si les classes que nous avons d ej` a pr esent ees, notamment la classe IterGene du chapitre 2, nous fournissent des outils int eressants de d emarrage pour une mise en uvre.
163
6.4
Exercice 45 : ....... Exercice 46 : ....... Exercice 47 : ....... Exercice 48 : ....... Exercice 49 : .......
164
6.5 6.6
Enonc es des exercices non corrig es Corrig es des exercices
............... A FAIRE ...............
exercice 22 exercice 23 exercice 25 exercice 26 exercice 29
Chapitre 7 Int egration Num erique

Les m ethodes dint egration num erique, interviennent essentiellement lorsque ee ou inconnue, ou lorsque une primitive de est dexpression assez compliqu nest connue que par points, par exemple si elle r esulte de mesures physiques, on peut lapprocher alors par interpolation ( chap. pr ec edent), puis on int` egre num eriquement linterpol ee. On traitera seulement les int egrales du type :
o` u
{pu} est un intervalle ni de IR et
f k
td8
est continue sur
{pu} .
7.1
7.1.1
M ethodes des Rectangles

M ethode des Rectangles sup erieurs et inf erieurs
f(x) f(x)
5 5 55 55 55 55
5 5 5 5 55 5 5 5 5 5 5 5 5 5 5 5 5 55 5 55 5 5 5 55 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 55 5 5 5 55 5 5 5 5 5 5 5 5 5 5 5 5 5 55 5 5 5 55 5 5 5 5 5 5 5 5 5 5 5 5 5
x
55 5 55 5 55 5 5 5 5 5 5 5 5 5 5 5 5 5 5 55
5 5 5 55 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 55 5 5 5
5 5 55 55 55 55 55 55 55 55 5 5 55
x
cg f
On consid` ere une subdivision de ), mj , (
u sous intervalles e gaux {|vm yC} o` {up} en x fvghiGjjjoul g pgp et jg x . On suppose les valeurs
165
Figure 8
Figure 9
166
rectangles inf erieurs (g 9).
ed connues pour fwghijjjkul . Puis sur chaque sous-intervalle {|vm yC} , (fg hiGjjjkul8p ) on remplace la fonction td par ed dans le cas de la methode des rectangles sup erieurs (g 8) et par y'd dans le cas de la m ethode des
7.1.2 M ethode des r ectangles points-milieux
f(x)
x1
x2
Figure 10 Cette fois-ci on prend pour chaque sous-intervalle comme hauteur du rectangle, on a alors
y td8}j d x y x y do` u y dvg je f td8} j jd On d emontre que lerreur de cette m ethode est : x d z acbed | td e @ %
7.2 M ethodes des trap` ezes
{ 4m y4} , z d
On consid` ere une subdivision de [a,b] en sous intervalles e gaux de mj , ( bornes ), et j . On suppose connues les valeurs pour . Sur chaque intervalle on
y4} { 4 m gP f f gIhiGjjjoul g pg x g x eed fgghiGjjjkul { 4m yC} e ymd eed . e e d remplace la fonction etd par la droite : ged y

Laire exacte est donc remplac ee par laire mant les aires des n trap` ezes de base approximation de lint egrale f ; comme
167
du trapèze. Par consequent en som{|vm yC} , (fg hGjjjkul ), on obtient une tog z e ymd edmd , alors x y g etd1} j {)e d e x d y edC}tg3
Pour justier ce proc ed e il faut montrer que 3 peut e tre rendu aussi proche que lon veut de f pourvu que le pas j soit assez petit et que soit assez r eguli` ere ( voir les r ef erences donn ees en n de ce polycope). On d emontre que lerreur f h commise par application de cette m ethode est donn ee par :
w 8j z d g edr {pu} Donc si zga(b!d | $r'd , alors yH z z

7.3 M ethode de Simpson
Dans cette m ethode on suppose que n est pair (soit n=2s), puis on subdivise en s sous intervalles e gaux de longueur j , ( "n ), puis on remplace sur chaque intervalle non pas par une droite comme wr dans les trap` ezes, mais par une parabole ayant aux abscisses les m emes valeurs que ; cest a ` dire par une interpolation quadratique sur ces trois wr points. Le polyn ome dinterpolation en est (voir chapitre 4) :
{pu}
td
y yqm w y y'ded w y~etd g e e ymd Aj z ymd ymd g eed e z j e e d m y d g e ymd Aj z Dautre part la surface d elimit ee par cette parabole, les droites g y , g y et laxe des abscisses sobtient en calculant : w yetd1 doù ; tg j e y%d ed e y'd'd
{ yqm yC} { yqm yC}
fgvjjj x yqm w y

Ceci donne lapproximation de Simpson de f , en sommant les aires a ` . Finalement :
168
fg l
pour
g j {e d ezH'd {)ky'd d j jj zH y'd4} i{)zqd qd jjj zH zd4}}

j
y g { e d e H'd p z y'd p z d4} z y y On d emontre que lerreur g f commise par application de Simpson est donn ee par : w d @ j g edf {up} G h g a(b!d | s r'd , alors Donc si w d he Remarque 7 En g en eral la m ethode de Simpson donne une meilleure approximation que celle des trap` ezes, ( sous certaines conditions de r egularit e de , voir r ef erences ...), car lerreur commise lorsquon applique les trap` ezes est proporz tionnelle a ` j , et comme par ` j , alors que pour Simpson elle est proportionnelle a une transformation de la variable dint egration on peut toujours se ramener de {pu} a` {hiG~} et qualors j {hiG} , on a donc j j z .
Remarque 8 Comparaison des erreurs :
cest a ` dire :
Rectangles Trap` ezes Simpson
x dmzy@j `z j yz y %j 2
7.4
M ethode de Romberg
Cest un proc ed e dacc el eration de la convergence dautres m ethodes comme f 8 , on xe un pas les trap` ezes. En g en eral pour calculer f et on approxime f par f qj u rj est lerreur commise, j rj , o` eguli` ere. avec lhypoth` ese que cette erreur tend vers 0 avec j pour sufsamment r
g x
thd
g thd8g td o d d d
169
x gfthd i @j z z`j jjj j z w j z we rjd y w donc lerreur est rjdvg iy@j z z`j jjj w j z w j z we rjd'd z qui est une s erie convergente (et }j ). Dautre part : z j z j zw j w x j tz gfthd iy d z d jjj w d d rjd q B y q , (cest a` dire y ), les termes en j z sont elimines, donc Si on fait lerreur commise est e quivalente a ` j , ce qui est bien s ur meilleur. En continuant ce raisonnement avec Gjjj on obtient lalgorithme de Romberg dans lequel, pour clarier les notations, les valeurs obtenues directement par les x x x trap` ezes seront not ees 6y 8 cy z @ 6y Gjjj , au lieu de x @ tz x @ x Gjjj De meme ~ x ~ x @ z jjj le resultat de la combinaison de Romberg, voir le on notera
: tableau ci-dessous qui r esume cet algorithme
Lid ee de lalgorithme de Romberg est de prendre une combinaison lin eaire de , puis de recomf qj et de f qui donnera une meilleure approximation de f mencer avec f , etc . Prenons par exemple la m ethode des trap` ezes on a f u rj o` esigne lapproximation pour n subdivisions de de longueur f rj d j . Dans le cas o` u lon peut faire un d eveloppement limit e en j on a :
o d t z d t d x g g t d
jjj
thd thd g x d {pu}
. .
.
6y x yx t z yx t x y
6y z x x tz z y x t z y jjj

6y x tz x y V jjj

6y x jjj
jjj
On construit la premi` ere ligne qui correspond aux trap` ezes avec subdivisions, subdivisions, etc... et on d esigne par les eches et les diff erentes combinaisons v v y m a ` lorigine de la eche , donc la deuxi` eme a `: v gr ce a ligne v est obtenue la troisi` eme ligne est obtenue gr ace : r ecurrence qui donne le passage de la
y g z z ' y , etc... doù la règle de ligne a` la v d ligne :

l g z z y
170
% C~ x q x ~ x Une fois calcul es , z , jjj , on a p x z y g z y donne des approximations de lintegrale la ligne du tableau de Romberg q x est plus precis que x pour , et z pour lesquels lerreur est en j ; donc ~ x est moins precis que ~ z x qui lest moins que ~ x , jjj . dautre part
La pr ecision augmente de haut en bas et de gauche a ` droite du tableau, mais attention, pas n ec essairement sur les diagonales. Remarque 9 . On remarque que dans la deuxi` eme ligne du tableau de Romberg, est exactement le r esultat de la m ethode de Simpson.
oz x
171
7.5
Exercice 50 : 1 . a) Donner les formules des rectangles approchant f b) Trouver lerreur commise en appliquant la m ethode des rectangles, ainsi que le nombre minimum de subdivisions de pour avoir w a ` 1/100 pr` es c) Donner la m ethode des rectangles a ` point milieu. d) Trouver lerreur commise en appliquant la m ethode des rectangles a ` point milieu. M eme application qu` a la question b).
{hG}
etd y
Exercice 51 : D eterminer par le m ethode des trap` ezes puis par celle de Simpson la base du tableau suivant :
etd8
sur
h |U | !|U |U etd h hi)UU hUhh hi)UUh Ces points dappui sont ceux donnant ' , comparer alors les r esultats obtenus
avec la valeur exacte. Exercice 52 : On lance une fus ee verticalement du sol et lon mesure pendant les premi` eres 80 secondes lacc eleration :
l d h h V h h h V h h U h h ~o l z d h iU0 i hi) i V i0 Uh Uhi)

r w n w An
Calculer la vitesse V de la fus ee a ` linstant t=80 s, par les Trap` ezes puis par Simpson. Exercice 53 : Calculer a ` laide de la m ethode des Trap` ezes lint egrale f N=5 puis N=10 points dappui).
g 'ke z d8
(avec
Exercice 54 : Trouver le nombre N de subdivisions n ecessaires de lintervalle dint egration P @ , pour evaluer a ` pr` es, gr ace a ` Simpson, lint egrale : f ~ %A .
{ u k}
hi0h
Exercice 55 : Evaluer a laide de la m ethode des Trap` ezes, lint egrale : . erreur inf erieure a `
h
, avec une
172
Exercice 56 : Evaluer a laide de la m ethode des trap` ezes puis celle de Romberg bas ee sur les trap` ezes, lint egrale : erieure a ` . , avec une erreur inf Comparer les vitesses de convergence. Comparer a ` la valeur exacte .
y y y
h
Exercice 57 : h r w 0r . Combien faut-il de subdivisions de [0,1] pour evaluer Soit pr` a es en utilisant 1. la m ethode des trap` ezes 2. la m ethode de Simpson
etd g Cd Gh
173
7.6
Exercice 58 : h r w 0r . Combien faut-il de subdivisions de [0,1] pour evaluer Soit a pres en utilisant 1. la m ethode des trap` ezes 2. la m ethode de Simpson Exercice 59 : Utiliser la m ethode de Simpson pour approcher c A8 en e parties e gales. lintervalle
tdg z Cd Gh
{hi} gh Cd
cvtd1 . en subdivisant
Exercice 60 : $r 8Ar , on Pour e valuer , o` u la fonction est donn ee par egre h int h ... le d eveloppement de Taylor de $r ( qui commence comme suit : r ).
mk 'd
tdug m 'd
1. Donner lerreur commise sur le r esultat si on se contente du d eveloppement a ` lordre 6 de . tenue par votre calculette.
etd 2. Estimer alors Cd a ` cette erreur pr` es, et comparer a ` la valeur exacte ob-
etdvg 1. En utilisant la m ethode des trap` ezes, combien faut-il de subdivisions de z {hG} pour evaluer Cd a` Gh près ? z 2. D eterminer alors %d par les trap` ezes a ` Gh pr` es . Exercice 62 : z Soit etdvg %A sr'd8Ar . 1. En utilisant la m ethode de Simpson, combien faut-il de subdivisions de {hiG} es ? pour e valuer %d a ` h pr` es . 2. D eterminer alors %d par la m ethode de Simpson a ` h pr` Exercice 63 : Soit etdvg '6!r'd8Ar . 1. En utilisant la m ethode de Simpson, combien faut-il de subdivisions de {h@|} pour evaluer s|d a` h z près ? 2. D eterminer alors $ zd .
Exercice 61 : h w Ar . Soit

Exercice 64 : Soit
174
etdvg '6sr'd4AG$r'd8Ar . 1. En utilisant la m ethode de Simpson, combien faut-il de subdivisions de {hiG} es ? pour e valuer %d a ` h pr` es . ethode de Simpson a ` Gh pr` 2. D eterminer alors %d par la m Exercice 65 : bU6$r'd1Ar . Soit etdvg 1. En utilisant la m ethode de Simpson, combien faut-il de subdivisions de {h } pour evaluer d a` Gh près ? 2. D eterminer alors d . Comparer a ` la solution exacte. Exercice 66 : z Soit etdvg y $r d1Ar . 1. En utilisant la m ethode de Simpson, combien faut-il de subdivisions de { w } z es ? pour e valuer w d a ` h pr` 2. D eterminer alors w d . Exercice 67 : y Soit etdvg y h Ar . ethode des trapèzezs, combien faut-il de subdivisions de 1. En utilisant la m {hG} pour evaluer %d a` h près ? es . 2. D eterminer alors %d par la m ethode des trap` ezezs a ` h pr`
Exercice 68 : Soit f
sr'd8Ar . On considère une subdivision de {pu} en l sous intervalles g r x et jg . e gaux de bornes r4ogp m u fsghGjjjkul , g f j , o` g r , g l j d commise par la m ethode des trap` ezes sur un sous 1. Retrouver lerreur Cq r4 yC} . Montrer que la formule generale de lerreur gf intervalle { r4@ commise par application de cette m ethode, sur tout {pu} , est donn ee par : w @j z d g edf {pu} r'd , alors yHz z . g acbe d | es En d eduire que si zw w h 2. Soit $ r'dug r z et fg y s r'8d Ar .

8g

(a) Montrer que f
175
y giy où iyg no2td80 et où no2tdg w , (penser a ` un bon changement de variable). ethode (b) En utilisant le fait que a w gh , approximer y par la m donner la valeur approchee de iy par cette des trap` ezes. Si j g hi0" m ethode. es (c) Combien faut-il de subdivisions de [0,1] pour e valuer iy a ` Gh pr`
Exercice 69 : Pour approcher num eriquement lint egrale f forme f u et o` F ment positif).
g y F , on lecrit sous la g y g y F ( reel stricte g 1. Montrer que lon peut d eterminer un r eel strictement positif tel que yz h . y par y d . (Indication : majorer y F F ethode des trapèzes : 2. Pour calculer , on utilise la m
(a) Rappeler la formule des trap` ezes ainsi que lerreur commise par son application. Donner une d emonstration de lerreur. (b) Exprimer en fonction de le nombre N de points dint egration n ecessaire pour calculer avec une erreur inf erieure a ` . (c) Trouver
en utilisant la m ethode des trap` ezes.
zy h
gp m td
et en d eduire N.
176
7.7
exercice 31
a) Soit lapproximation de f par la m ethode des trap` ezes, le pas j est donn e par, j . `l
g k g g g

g etd8
d k ' y d d y u4h hipU hi0Uhh hi)UUd8v hG0

j
b) Soit
lapproximation de f par la m ethode de Simpson. Celle-ci s ecrit,
g j 2 7 2 y Ud 7 Uzd h hi0Ujjj h 0jjjmd jhi0Uhdm g g U0hhUhi
Les points dappui donn es dans cet exercice correspondent a ` la fonction . Et . On constate donc que lapproximation de f par Simpson f est meilleure que celle par les trap` ezes, puisque f et f .
g m g hi0hUU
' ghi0hUhhi Vg
, donc,
exercice 32
On sait que lacceleration
est la d eriv ee de la vitesse
sr'dxg hd rnd'n hdugh qndn q
177
a) Calculons f par la m ethode des trap` ezes. Ici, dapr` es le tableau des valeurs, . j
gh
x y g j e d e x d y e d g Ghu4h Uhp iiu a ipUhd8v g Uhun y
b) Calculons f par la m ethode de Simpson.
hdfg g g
d e x d ekymd qd jjjpd zd e~d jjjpd v h u h Uyhip p u a0d iu U a0d v h n

j u f k
exercice 34
g m z a) e g donc le pas dint egration est j g . Calculons f par la m ethode des trap` ezes. x y d e x d eed j f g y d z '6 d z m d z d8v g h u0m$ z d m6hd 2 'k d z m6 ! g hiVhUi
Soit
gh donc le pas dintegration est jg h . ! 7 ! u m6$ z d '6hd $m d z '6 d z m6 d z jjj m6 d z d v f g U0h UU Gh h h Gh g hi alors que la valeur exacte est approximativement hUU . Avec ce pas plus
a) e petit lapproximation num erique est meilleure.
178
exercice 35
e tre pair.
g A ! . Dautre part lerreur theorique sur la g Le pas dint egration est jg e e m ethode de Simpson est donn ee par wx d j ed r jdrg h e ! jdrg r h e o` u {pu} , par cons equent, x ! ! q jd h e Ainsi pour que q jd hi0 h il suft que e verie y t h Gh , 7 . Ainsi e verie e Gi0 . On prendra eIgVh , donc, e hi0 leh nombre h de subdivisions de lintervalle {pu} doit toujours car pour Simpson,
f
Soit
Soit
exercice 36
n
Lerreur de la m ethode des trap` ezes est :
j z ed qjdug z d z z où zg hpa( donc, rjd w r'd . Ainsi, pour avoir i b! d $ l e subdivisions de lin qjdk , où est lerreur permise, il suft de prendre tervalle dint egration telles que d zz e
Gfvl etd

Donc, il suft que e v erie,
179
e
Cherchons
. On a
w d z % d ! et m A m

Pour d terminer les extremas de Un calcul simple donne
, on cherche alors les racines de
"! #$&%
! " '
( 12 @ BA 3 7698 0) %A 43 %A 45 7 698 H3 CIDGF 45 F 698 @ F PQ%RA 3 9 68
On cherche donc les racines de l equation,
2 CEDGF
1 CIDGF S T F VA 5 H3 3 5 6U8 CEDGF X W % Y W a`Gb bdc W % 5 ( En supposant et 3 , cest a ` dire ,( e %Rf fg`hA9AiAip qs W rut ` ( ), et , on obtient @y vxw 8 S 3 A 3 5 `Gb r t ` ( ou Ain,si les racines cherch ees sont ou celles de l equation y a`GBA vw 8 P 3 3 5 G ` Etudions alors cette e en tracant les courbes %Rf quation : Graphiquement, x v w repr esentatives dans de 8 et de g , on voit rapidement (` a faire) que le 7 B P% v w seul point dintersection de 8 et de est dabscisse . %Rf 4% Ht ` 7 On en d eduit que atteint ses extremas sur en ou ou P . P% # , le d eveloppement limit e en de donne : Cherchons U69d i fe"g i i ) i r ( h j k A9AiAmlnqò AiA9Aml ` l %t# r ul s q ` pRq q 3 5 i ( %0 r l A 5
Do` u

Donc, U69d x et y|{
180
'wPx x t `G { . Par ailleurs, on v erie facilement que, zyT{ x g{ Bxv } e" , et par cons . On a donc ~ equent de l equation (1) on obtient, y % ( ` ( 5 ( R % A y (
Application. } % ( , do` Prenons alors, u h x , et donnons une approximation de e lint egrale par la m ethode des trap` ezes :
} F
698
` %
(
%
F B} 0} F } 698 x 6 8 x ll 68 x U A A9A 9 i } e } e } e x x x e e e f p s (
i F
exercice 38
Soit
@ # ` ( h ` d i wo U { r { . Ainsi, pour avoir donc, { { u ~ ~ o` x ( % { { , o` ( h , il suft de prendre subdivisions de lintervalle u dint egration telles que qh ~ ` (
Donc, il suft que v erie,
On a ( r1 r e a) Cherchons le nombre de subdivisions de pr` es en utilisant la m ethode des trap` ezes. Lerreur de la m ethode des trap` ezes est :
# e
x
r1 r
A ( %Rf
pour evaluer
% ( h
Cherchons ~ { Donc ~
a% . { On s` a r
.
y '
q h ( ` ~ ( | 4`G r , r 1 r
et
! | " 5 r . r
181
y e , soit y 5 . Avec 5 Ainsi, lin equation (1) devient subdivisions, lerreur commise lors de lapproximation de cette int egrale par la % m ethode des trap` ezes serea plus petite que ( h .
b) Cherchons le nombre de subdivisions de pr` es en utilisant la m ethode de Simpson. Lerreur th eorique de cette m ethode est :
p %G
p %G
%Rf
pour evaluer
% ( h
) ) ! w # % G ( h"r ) ! { { { { % ) ~ ) o` donc, u~ ) d i wo U { r . Ainsi, pour avoir { ( % g , o` ( h , il suft de prendre subdivisions de lintervalle dint u egration telles que h r A % ) ~ ) ( qh r `G ) y % ~ ) G ( ) ! p r ! T s Cherchons ~ ) ! ) . On a r , et 1 r r r r r . { % { p ) Donc ~ . ) Rf ) y Ainsi, lin equation (2) devient x x , soit y 5 3 . On prendra p% eB ethode e7 de Simpson, le nombre de alors puisque, dans les cas de la m
subdivisions de lintervalle dintegration doit toujours e tre pair. Donc, il suft que v erie,
182
7.8
Nous pr esentons des mises en uvre des m ethodes des Trap` ezes, de Simpson et de Romberg.
7.8.1
Des classes abstraites dint egration num erique
Les deux premi` eres m ethodes impl ement ees, celle des Trap` ezes et de Romberg, n ecessitent des interfaces analogues, tout en mettant en uvre des calculs diff erents. Nous avons d ecrit des classes abstraites pouvant e tre d eriv ees avec lune ou lautre m ethode. Ce proc ed e permettra dutiliser ces classes abstraites pour la m ethode de Romberg qui pourra alors e tre utilis ee avec lune ou lautre m ethode. Deux approches sont mises en uvre qui d ependent de la situation pratique dans laquelle se trouve lutilisateur : Lutilisateur dispose dune repr esentation analytique ou informatique de 0f la fonction dont il cherche lint egrale sur un intervalle . La classe abstarite suivante va permettre de d ecrire cette situation. Elle utilise la classe FoncD2D d ecrite et utilis ee de nombreuses fois dans les chapitres pr ec edents :
abstract class IntNumFct { double a,b; FoncD2D f; IntNumFct(double b1, double b2, FoncD2D fonc) { a = b1; b = b2; f = fonc; } abstract public double calcul(int nbSub) throws NbSubException; }
Lutilisateur peut ne conna tre une fonction qu` a partir dun tableau de valeurs en des points r eguli` erement espac es. Dans ce cas, sil ignore la forme analytique de la fonction, il ne pourra utiliser que ce tableau de valeurs qui eparant chaque point d evaluation de la fonction. La classe xe le pas s abstraite suivante va permettre de d ecrire cette situation. Elle utilise une description de la fonction dans un tableau de valeurs :
abstract class IntNumTab { double pas; double[] valf; IntNumTab(double longIntervalle, double[] t) { valf = t; pas = longIntervalle/(t.length - 1); }
183
abstract public double calcul() throws NbSubException; }
Par ailleurs, il a e t e remarqu e dans les paragraphes suivants que le nombre de subdivisions devait respecter des propri et es de parit e pour pouvoir utiliser la m ethode de Simpson. Cest pour cette raison, que nous allons utiliser un traitement dexception pour g erer une situation ne v eriant pas la condition ad equate. Nous cr eons donc la classe dexception qui suit :
class NbSubException extends Exception { public String toString() { return ("Nombre de subdivisions impropre"); } }
7.8.2
Des classes dimpl ementation de la m ethode des trap` ezes
Nous pr esentons ci-apr` es deux classes impl ementant de mani` ere e l ementaire la formule des trap` ezes telle que d ecrite dans les paragraphes pr ec edents. Chacune des classes d erive dune des deux classes abstraites pr ec edentes.
class ITrapFct extends IntNumFct { ITrapFct(double b1, double b2, FoncD2D fonc) { super(b1,b2,fonc); } public double calcul(int nbSub) throws NbSubException { double pas = (b-a)/nbSub; double x = a; double s = f.calcul(a) + f.calcul(b); for (int i=1; i<nbSub; i++) { x += pas; s += 2*f.calcul(x); } return s*pas/2; } } class ITrapTab extends IntNumTab { ITrapTab(double longIntervalle, double[] t) { super(longIntervalle,t); } public double calcul() throws NbSubException{ int nbSub = valf.length-1;

double s = valf[0] + valf[nbSub]; for (int i=1; i<nbSub; i++) s += 2*valf[i]; return s*pas/2; } }
184
7.8.3
Des classes dimpl ementation de la m ethode de Simpson
Nous pr esentons ci-apr` es deux classes impl ementant de mani` ere e l ementaire la formule de Simpson telle que d ecrite dans les paragraphes pr ec edents. Chacune des classes d erive dune des deux classes abstraites pr ec edentes. Ces classes sont succeptibles de lancer des exceptions si la parit e du nombre de subdivisions nest pas satisfaite.
class ISimpsonFct extends IntNumFct { ISimpsonFct(double b1, double b2, FoncD2D fonc) { super(b1,b2,fonc); } public double calcul(int nbSub) throws NbSubException { if ((nbSub % 2) != 0) throw new NbSubException(); double pas = (b-a)/nbSub; double x = a; double s = f.calcul(a) + 4*f.calcul(a+pas) + f.calcul(b); for (int i=3; i<nbSub; i++,i++) { x += 2*pas; s += 2*f.calcul(x) + 4*f.calcul(x+pas); } return s*pas/3; } } class ISimpsonTab extends IntNumTab { ISimpsonTab(double longIntervalle, double[] t) { super(longIntervalle,t); } public double calcul() throws NbSubException { int nbSub = valf.length-1; if ((nbSub % 2) != 0) throw new NbSubException(); double s = valf[0] + 4*valf[1] + valf[nbSub]; for (int i=2; i<nbSub; i++,i++) s += 2*valf[i] + 4*valf[i+1];

return s*pas/3; } }
185
7.8.4
Un programme de test des m ethodes des trap` ezes et de Simpson
Nous pr esentons maintenant un programme ec edentes F de test des 4 classes %RfxG` pr et qui calcule lint egrale de la fonction 6U8 sur lintervalle . La valeur exacte e tant e gale a ` 1.
import import import import import import import import import
java.lang.*; java.io.*; FoncD2D; TableauFileIn; NbSubException; ITrapFct; ISimpsonFct; ITrapTab; ISimpsonTab;
class SinF implements FoncD2D { public double calcul(double x) { return Math.sin(x); } public String libelle() { return "f(x)=sin(x)"; } } class TestIntNum { public static void main(String args[]) { SinF f = new SinF(); double a=0, b=Math.PI/2; double longueur=b-a; int nbSub=4; // lecture du fichier de donn ees TableauFileIn fic = new TableauFileIn("donnees.dat"); double[] flu = fic.lectureTableau(); fic.fermer(); ITrapFct itf = new ITrapFct(a, b, f); ISimpsonFct isf = new ISimpsonFct(a, b, f); ITrapTab itt = new ITrapTab(longueur, flu); ISimpsonTab ist = new ISimpsonTab(longueur, flu);
186
try { System.out.println("Integration numerique de sin(x)"+ "entre 0 et Pi/2, avec "+ nbSub+"subdivisions"); System.out.println("Met. Trapezes version fct : "+ itf.calcul(nbSub)); System.out.println("Met. Trapezes version tab : "+ itt.calcul()); System.out.println("Met. Simpson version fct : "+ isf.calcul(nbSub)); System.out.println("Met. Simpson version tab : "+ ist.calcul()); } catch(NbSubException e) { System.out.println(e); } } }
Nous donnons ci-apr` es le chier dentr ee utilis e par les m ethodes travaillant sur des tableaux. Les valeurs suivantes correspondent a ` une tabulation de la F %RfG` sur . fonction 6U8 , avec un pas de
5 0 0.382683 0.707107 0.923880 1
Les r esultats obtenus sont les suiavnts. Ils respectent parfaitement les calculs derreurs e nonc es dans les paragraphes pr ec edents.
java TestIntNum Integration numerique de sin(x)entre 0 et Pi/2, avec 4subdivisions Met. Trapezes version fct : 0.9871158009727754 Met. Trapezes version tab : 0.987115900693632 Met. Simpson version fct : 1.0001345849741938 Met. Simpson version tab : 1.000134660650108
7.8.5
Mise en uvre de la m ethode de Romberg
Nous pr esentons maintenant une classe impl ementant de mani` ere r ecursive la formule de calcul de la m ethode de Romberg, telle quelle est d ecrite dans les paragraphes pr ec edents :
187
class Romberg { IntNumFct methInt; Romberg(IntNumFct mi) {methInt = mi;} public double calcul(int ordre, int nbSub) throws NbSubException { int k=ordre-1; if (ordre==1) return methInt.calcul(nbSub); else { double ddk = Math.pow(2,2*k); return (ddk*calcul(k, 2*nbSub)-calcul(k, nbSub))/(ddk-1); } } }
Le programme qui suit teste la m ethode de Romberg en donnant les r esultats de cette formulation pour diff erentes valeurs de lordre et du nombre de subdivisions. Par ligne dafchage, lordre est constant : il commence a ` 1, puis a ` 2 et enn a ` 3. Sue chaque ligne, on calcule la formule pour des nombres de subdivisions respectivement e gaux a ` 2, puis 4 et enn 8.
import import import import import
java.io.*; FoncD2D; NbSubException; ITrapFct; Romberg;
class SinF implements FoncD2D { public double calcul(double x) { return Math.sin(x); } public String libelle() { return "f(x)=sin(x)"; } } class TestRomberg { public static void main(String args[]) { SinF f = new SinF(); double a=0, b=Math.PI/2; ITrapFct itf = new ITrapFct(a, b, f); Romberg rmb = new Romberg(itf); System.out.println("tableau des valeurs approchees"+ "de lintegrale de sin(x) entre 0 et pi/2"); System.out.println("sur la ligne k : Tk,2 Tk,4 Tk,8"); try {

for (int k=1; k<4; k++) { int n=1; for (int j=1; j<4; j++) { n *= 2; System.out.print(rmb.calcul(k,n)+" } System.out.println(); }
188
");
} catch (NbSubException e) {System.out.println(e); } } }
Nous pr esentons ci-apr` es la trace de lex ecution du programme pr ec edent :
java TestRomberg tableau des valeurs approcheesde lintegrale de sin(x) entre 0 et pi/2 sur la ligne k : Tk,2 Tk,4 Tk,8 0.9480594489685199 0.9871158009727754 0.9967851718861696 1.0001345849741938 1.0000082955239675 1.0000005166847064 0.9999998762272857 0.9999999980954223 0.9999999999703542
Chapitre 8 quations R esolution Num erique des e diff erentielles

8.1 Introduction, le probl` eme math ematique
0f
un intervalle ferm de IR et une application donn ee ft e f7t r r . IR IR, Et soit une application diff erentiable de IR IR. On appelle e erentielle du premier ordre, la relation quation diff (8.1)
Soit
f 7gA r r r 0f
On dit que est la solution quation diff erentielle sur si v erie la c 0f de cette e . relation (1) pour tout r On appelle probl` eme de Cauchy ou probl` eme de condition initiale l ahS equation diff erentielle a ` laquelle on adjoint la condition initiale o` u est un e e nombre donn ee : (8.2)
r ah
Remarque 10 1. Si est une fonction du temps, il est dusage de noter la eme la d eriv ee seconde d eriv ee " par et de lappeler vitesse. De m i sera not ee et appel ee acc eleration. 2. Si on consid` ere une e erentielle dordre sup erieure quation diff
r e
f u
r
! ff ff x ! r
on peut ramener le probl` eme a erentielles ` celui dun f syst` fe me f d equations H x diff du premier ordre, en posant x et on obtient le 189

syst` eme :
190
(8.3)
x ... x
r
= = . . .
f x f f f
r r
= = r
Exemple 6 Soit l equation diff erentielle du second ordre :
posons
et
x

alors cette e ene au syst` eme : quation se ram`
x
= =5
x r1 x
Revenons au probl` eme de Cauchy (2), un r esultat fondamental est donn e par le th eor` eme ci-dessous, mais rappelons tout dabord la d enition dune application lipschitzienne. D enition 4 Soit f une application d enie sur i IR ; sil existe une constante f f f { { S { Vf c % ind ependante de r et telle que { r r c 0 f 0f IR, et r , alors est dite Lipschitzienne de rapport L sur i IR (ou simplement L-lipschitzienne). Th eor` eme 9 Si f est une application d enie sur k IR continue et Llipschitzienne par rapport a eme de cauchy (2) admet une solution ` , alors le probl` c unique sur [a,b] et ceci pour toute condition initiale , ( IR).
f
0f
Proposition 4 Une condition sufsante pour que les hypoth` eses du th eor` eme soient v eri ees est que soit d erivable par rapport a eriv ee soit ` et que sa d born ee. ( dem en exercice ...) (Le th eor` eme est en g en eral faux sans la condition de Lipschitz.)
8.2
La M ethode dEuler

Soit a ` int egrer num eriquement le probl` eme de Cauchy (2), et soit r la valeur exacte de la solution de ce probl` eme a ` labscisse r . Une m ethode danalyse num erique pour int quation diff consistera a ` fournir des ap egrer cette e ff erentielle ( proximations de r pour , entier donn e.
191
Les diff ethodes dint egration se distinguent par la mani` ere dobtenir erentes m ces . La m ethode dEuler, est la plus simple et consiste a ` substituer la d eriv ee h r par lexpression
(8.4)
h est le pas dint o` u egration num 0ef rique. f Consid erons alors une subdivision de en N sous intervalles r r x de lons%Rff s n gueur , et r , avec r et r . Q fR r e r do` r r Lexpression (4) entraine r u r . f Par cons equent, partant de la condition intiale r , et prenant un pas r egulier e e de r x r , on obtient, en posant approximation r :
(8.5)
y r r
n f x r
Lalgorithme dEuler s ecrit alors :
h donn e x n f e r
ff (
Interpr etation g eom` etrique x approximation de r x est calcul ee a ` partir f de r calcul es pr ec edemment gr ace a ` la formule de r eccurence (5) et a d ` la condition initiale r calcule une approximation de la solution en f x e e . On r r r r passant par tout point en remplacant dans la courbe int e grale e par sa tangente en r .
Solution Euler
Solution exacte inconnue
t0
t1
t2
t3
t4
t5
Figure 11 Remarque 11 On dit que la m ethode dEuler est une m ethode a epar es ou ` pas s x a ` un pas, parceque le calcul de ne fait intervenir que .
192
8.2.1
Etude de lerreur dEuler
D enition 5 Une m ethode num erique approchant Q q x r v erie est dite dordre p, (
par
telle que lerreur
bPc
IR ).
{ x { b
Th eor` eme 10 Supposons que lapplication r soit continue par rapport aux deux variables, et lipschitzienne par rapport a ement par rapport a ` r , et ` uniform c f PG i U { { que . On pose ~ r , alors on a la majoration
f7t
x ! { I { h ( ~ ` Q q f r est lerreur commise au point r o` uI c f c x 0f i
Remarque 12 1. Ce r esultat sexprime sous la forme que la m ethode dEuler est dordre 1. 2. Pour que il suft que
{ I { b
, cest a ` dire
IR .
On donne dans la suite des m ethodes dordre plus e lev e que celui de la m ethode dEuler, donc plus rapides et plus pr ecises.
8.3
M ethodes de Taylor dordre deux

f f7t fR r r fR r r r
equation Lid ee consiste a ` remplacer sur r r x la courbe r solution de l diff erentielle non plus par une droite mais par une parabole. En effet
et en n egligeant les termes dordre sup erieur, on obtient alors lalgorithme de Taylor dordre deux :
Q , , donn e, r x r h Q f f e e r w r gB B x ,
%ff (
).
Cependant cette m ethode pr esente un inconvenient certain qui r eside dans le calcul B B de qui peut e tre difcile ; pour e viter ce probl` eme on utilise souvent la de Runge-Kutta-2 donn m ethode ee plus bas.
193
i IR , -lipschitzienne et Th eor` eme 11 Supposons que r e E B x -lipschitzienne par rapport a ement par rapport a ` uniform ` r . Po QPG i U { "! { sons ~ r , alors on a la majoration ! ! ~ { I { ( h I h 3 Q q f e o` uI r est lerreur commise au point r . g
f7tc f
8.4
8.4.1
M ethodes de Runge-Kutta
Runge-Kutta dordre 2 : RK2
On reprend lalgorithme de Taylor dordre 2 en remarquant qu` a des termes en pr` es on a gr ace a ` un developpement de Taylor :
f f u ! r a r # r
do` u
n f f 7 f x ` a r r r
o` u
ainsi on obtient lalgorithme de RK2 :
s%Rff ( x f a x , x r , et r f x
8.4.2
Runge-Kutta dordre 4 : RK4
Dans la pratique on utilise la m ethode plus performante de Runge-Kutta dordre 4 (RK4), pour des fonctions sufsamment r eguli` eres on a alors { I { ) :
a x w x r f , f r
%Rff x ` ` ), ( f x , r f , et ) r
o` u
8.5
` un pas G en eralit es sur les m ethodes a

Q f7 f x r
Les m ethodes a ` un pas, aussi appel ees m ethodes a ` pas s epar es, sont toutes de la forme :
194
o` u est une application continue de i IRH dans IR ; ( est le rayon e e de stabilit e de la m ethode, souvent on prendra ici ). e Les notions th eoriques que doit v erier la fonction an que soit effectivement une approximation de r sont la consistance, la stabilit e th eorique et la convergence. D enition 6 Une m ethode a equation diff erentielle ` un pas est consistante avec l si pour toute solution continue
0f
%Rf
U6Ud v e
PG { ( x y f Bf { % r r r r
Th eor` eme 12 Une condition n ec essaire et sufsante pour quune m ethode a ` un c f c f x f % f r . pas soit consistante est que pour tout r et tout IR r D enition 7 Stabilit e th eorique : Q %Rf f ) les solutions r espectives de Soient et I (
et de
cx e
= IR
f7 f r
donn e
On dit que la m ethode a epar es est stable sil existe deux constantes ` pas s ind ependantes de telles que :
I c x e
= I IR
f f r I 4
donn e
et
w { I {n x { { PG { { d o e e
Th eor` eme 13 Si v erie une condition de Lipshitz par rapport a ` la seconde variable pour sufsamment petit, alors la m ethode a ` un pas est stable. D enition 8 On dit quune m ethode a ` un pas est convergente si :
c e
IR
{ s% 96Ud d wo { r v e
Th eor` eme 14 Si une m ethode a ` un pas est stable et consistante alors elle est convergente.
195
8.6
R esolution de syst` emes diff erentiels dans IR

ff n r ff r' r r
Dans IR soit le syst` eme diff erentiel :
Lapplication de lalgorithme ` ce syst` eme se fait composante par compo dEuler a sante do` u: f f
r f7 f I x x I I r I
Cet algorithme sapplique aux e quations diff erentielles dordre 2 (ou plus ...) a ` condition de les r eduire au pr ealable a ` des syst` emes diff erentiels du premier ordre, comme vu pr ec edemment. Lapplication dautres algorithmes par exemple RK2 se fait moins simplement, voir exercices corrig es.
196
8.7
Exercice 70 : Ph % (. r r Soit l equation diff erentielle a ` condition initiale r et ( a Approcher la solution de cette e quation en r ` laide de la m ethode dEuler en subdivisant lintervalle de travail en 10 parties e gales. Comparer a ` la solution exacte. Exercice 71 : 1. Soit une suite iq de nombres r eels positifs telle que et sont des constantes positives ; montrer que
2. Montrer que
et
IR ,
(
x x c , u x , . e g
3. Utiliser les deux questions pr ec edentes pour d emontrer le th eor` eme 10 du cours. 4. De m eme pour le th eor` eme 11. Exercice 72 : Approcher la solution de l e quation diff erentielle ci-dessous en r %R A` sant RK2, avec un pas
x %A`
en utili-
` r r r
r
% (
Comparer a ` la solution exacte. Exercice 73 : En donnant les solutions de l erentielle ci-dessous avec la condition %2 %Gj equation diff ( puis ( , r initiale eel non nul, v erier quelle conduit a ` des sch emas instables. ' A
5G3 r
5G
Exercice 74 : Soit le probl` eme de Cauchy suivant y(t) y(0) = t + y(t), r =1
c R % f ( %RA (
1. Trouver la solution exacte de ce probl` eme. 2. Appliquer la m ethode dEuler a ` ce probl` eme, avec s %A 5 . Comparer a solution en r ` la solution exacte.
, puis evaluer la

Exercice 75 : Soit le probl` eme de Cauchy suivant y(t) y(0) = 2t - y(t), r =1
197
c R % f ( %RA (
1. Trouver la solution exacte de ce probl` eme. 2. Appliquer la m ethode dEuler a ` ce probl` eme, avec s %A 5 . Comparer a solution en r ` la solution exacte.
, puis evaluer la
Exercice 76 : Ecrire lequation diff erentielle mod elisant le mouvement du pendule simple. Appliquer la m ethode dEuler puis celle de Taylor dordre 2. Exercice 77 : Soit l equation diff erentielle du second ordre a ` conditions initiales :
( y
o ` sò c 0f r r r , r h's` h ( et
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations diff erentielles dordre un. 2. Appliquer la m ethode de RK2 a ` ce syst` eme . Exercice 78 : On consid` ere le probl` erentiel eme diff
(
On divise q
0f en m intervalles x de ò longueur x x x ` et r par `G
hr
= =
f Bf7 u c 0f r , r r r n et
, dans (1) on remplace
par
1. Montrer que le probl` eme (1) se transforme en
2. 3.
f x x = 7 HQ = et e u f f ( ( et r g . Donner . avec Ecrire (2) sous forme matricielle. f7f | 0 On suppose maintenant que r ; quel syst` eme ff7 . obtient-on pour e
lin eaire

Exercice 79 : f7t Pour r esoudre l equation diff erentielle : u r , o` 0f ethode a ` un pas suivante : i IR dans IR, on propose la m
198
est continue de
f f x n f r f fR f ftu f fR7 r r r r r r f7 %f ( , et sont des r eels de ( ). ff ) retrouve t-on la m 1. Pour quelles valeurs du triplet ( ethode dEuler ?.
M eme question pour la m ethode RK2 ?. ftcw f i IR et L2. On suppose dans la suite de lexercice que r lipschitzienne en y : ff la m (a) Pour quelles valeurs ethode propos ee est stable ? f7'f ) pour que la m (b) Quelle relation doit satisfaire ( ethode soit consistante ? (c) Quon conclure pour la convergence ? Exercice 80 : On consid` ere l equation erentielle diff
o` u eses . (Ces hypoth` assurent lexistence et lunicit e de la solution.) 0f 1. Montrer que si est quatre fois continument d erivable dans alors
1 c , y(a) = et y(b)= 0f y % pour tout c et sont continues sur et ( y
0f f
2.
3.
)! ( ò ` ( c @ f7 V . avec 0f On subdivise en N+1 intervalles de longueur h x et on pose | T%ff , ( , on appelle une approximation de x ` et on remplace par x eme x dans (1). Ecrire le syst` d equations lin eaires ainsi obtenu. On appelle A la matrice de ce syst` eme. o` Montrer que u est une matrice tridiagonale et une
matrice diagonale, donner et .
Exercice 81 : Soit l equation diff erentielle du second ordre a ` conditions initiales :
( y
u` c 0 f H 5 , hs` ( et
199
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations diff erentielles dordre un. 2. Appliquer la m ethodede RK2 a ` ce syst` eme . 3. Appliquer la m ethodede de Taylor dordre 2 a ` ce syst` eme .
200
8.8
Exercice 82 : 0f c , et soit IR . Soit une application de IR dans IR o` u IR, 1. Donner le th eor` eme assurant lexistence et lunicit e de la solution du probl` eme de Cauchy :
f u c r r r r , h , donn e dans IR
2. Donner une condition n ec essaire et sufsante sur pour quelle soit lip schitzienne en uniform ement par rapport a `r 3. Quels sont parmi les probl` emes ci dessous, ceux qui admettent une solution unique :
x c fs , r r ! #" #" %r f
`G
t % r s%
r c %Rf (
Exercice 83 : Soit le probl` eme de Cauchy suivant =r =(
c R % f ( %RA (
1. Trouver la solution exacte de ce probl` eme. 2. Appliquer la m ethode dEuler a ` ce probl` eme, avec s %f 5 . Comparer a solution en r ` la solution exacte. Exercice 84 : Soit le probl` elme de Cauchy suivant :
, puis evaluer la
` c %f r, r ( % r (
1. Donner la solution g en erale de ce probl` eme. %RA` , puis donner la 2. Appliquer la m ethode dEuler a ` ce probl` eme avec s%RA p % solution num erique en r ,a ` ( pr` es. 3. Donner lerreur th eorique de la m ehode dEuler dans ce cas et la comparer a ` lerreur effectivement commise. Commentaires ? Exercice 85 : Soit le probl` eme de Cauchy suivant :
j G % r x ,
r c %Rf (

1. Montrer que la solution g en erale de ce probl` eme est 2. Appliquer la m ethode dEuler a ` ce probl` eme avec (a) (b)
201
x r1 . r %RA p %RA p % ( % ,a `(
,a ` pr` es. pr` es.
%A` %A
, puis donner la solution num erique en r , puis donner la solution num erique en r
3. Donner lerreur th eorique de la m ehode deuler dans chacun de ces cas et la comparer a ` lerreur effectivement commise. Commentaires. Exercice 86 : Soit le probl` eme de Cauchy suivant :
1.
H` f7t c R % f r r , r ( % r ( fR Montrer que r est lipshitzienne par rapport a ` uniform ement par rap (
port a ` r , et donner une constante de Lipshitz.
2. Montrer que ce probl` eme admet une solution unique. 3. Donner la solution exacte de (1), ainsi que
R % A` .
4. Appliquer la m ethode dEuler a ` ce probl` eme, e crire lalgorithme corres pondant et donner lapproximation de y(0.2) obtenue a ` laide dun pas de s%RA (. discr etisation num erique 5. Rappeler lerreur th eorique de la m ` lerreur %RA`G ethode dEuler et la comparer a commise sur le calcul de ; commentaires ? . Exercice 87 : fR 0f r , o` Pour r esoudre l equation diff erentielle : u est continue de dans ethode a ` un pas suivante : IR, on propose la m
IR
f f x n f rf R f f ftu f fR7 r r r r r r f7 %f ( , et sont des r eels de ( ). ff ) retrouve t-on la m 1. Pour quelles valeurs du triplet ( ethode dEuler ?.
M eme question pour la m ethode RK2 ?. 2. On suppose dans la suite de lexercice que lipschitzienne en y : (b) Quelle relation doit satisfaire ( tante ? (a) Pour quelles valeurs
f r ftcw i
IR et L-
ff
la m ethode propos ee est stable ?
f7'f
) pour que la m ethode soit consis-

(c) et pour la convergence ? Exercice 88 : Soit le probl` eme de Cauchy suivant
202
y(t) y(0)
= f(t,y(t)), r , a r eel strictement positif, = donn e dans IR,
c %Rfx
o` u est deux fois contin ument d erivable dans 9 IR, on suppose que B est : born ee. On approche eriquement la solution de (1) par le sch ema a ` un pas num
%fx
o` u est une application de eel positif ), %f IR e dans IR ( e est un r r r r et . e e On donne le th eor` eme suivant qui pourra e tre utilis e sans d emonstration : %Rfx f %$ Th eor` eme : si est deux fois continument d erivable dans IR et si %Rfx %Rf g existent et sont continues dans ema (2) est dordre V IR e alors le sch 2 si et seulement si
x e
= =
f f Q%Rf fAIAA A ( r ,
donn e dans IR
%Rfx
%Rf
! %$ e x BB B A ! r fRc %fx V IR A g f7f Soit donc a ` approcher les solutions de (1) par la m ehode (2), avec r x o` u f7fx%G r ft r
et
x r fRBf r f x gf r ` f ` 5 5 5 5 1. Quelle relation doit lier et pour que le sch ema (2) soit consistant. ? 2. Est - il stable, pour quels et . ? 3. D eterminer et pour que ce sch ema soit dordre 2.
4. En conclure sur la convergence de (2). Exercice 89 : Soit l equation diff erentielle du second ordre a ` conditions initiales :
H` j c %f r % r , r ( %Gr ( et (
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations dordre un.
203
3. Donner la solution exacte de (1), ainsi que r et r pour r . Comparer ces deux r esultats a ` ceux num eriquement obtenus gr ace au sch ema s%RA ( . dEuler de la question pr ec edente en prenant Exercice 90 : Soit l equation diff erentielle du second ordre a ` conditions initiales :
2. On applique la m ethode dEuler a ` ce syst` eme, e crire lalgorithme correspondant. M eme question pour la m ethode de RK2. ( on notera le pas num erique).
s%RA`
` c %Rf 4 5 , r r r r ( % %` ( et
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations diff erentielles dordre un. 2. On applique la m ethodede dEuler a ` ce syst` eme, edrire lalgorithme correspondant. M eme question pour la m ethode de RK2. (on notera h le pas num eique). . Com3. Donner la solution exacte de (1), ainsi que r et r pour r parer ces deux r esultats a ` ceux num eriquement obtenus gr ace au sch ema s%RA ( . dEuler de la question pr ec edente en prenant
%A`
H` j c % f ( , r r r r %Gw % 5 ( et
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations dordre un. 2. On applique la m ethode dEuler a ` ce syst` eme, e crire lalgorithme correspondant. M eme question pour la m ethode de RK2, ( on notera le pas num erique).
. Com3. Donner la solution exacte de (1), ainsi que r et r pour r parer ces deux r esultats a ` ceux num eriquement obtenus gr ace au sch ema s%RA ( . dEuler de la question pr ec edente en prenant Exercice 92 : Soit l equation diff erentielle ` conditions initiales : du second ordre a
%A`
p ` c %Rf r r r r , % %` ( ( et
204
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations dordre un. 2. On applique la m ethode dEuler a ` ce syst` eme, e crire lalgorithme correspondant. M eme question pour la m ethode de RK2, ( on notera le pas num erique). 3. Question Facultative : Donner la solution exacte de (1), ainsi que r et %RA` r pour r . Comparer ces deux r esultats a ` ceux num eriquement obtenus gr ace au sch ema dEuler de la question pr ec edente en prenant %RA ( . Exercice 93 : Soit une application de IR dans IR o` u IR,
0f c , et soit
IR .
1. Donner le th eor` eme assurant lexistence et lunicit e de la solution du probl` eme de Cauchy :
f u c r h r r , r e dans IR , donn
2. Donner une condition n ec essaire et sufsante sur schitzienne en uniform ement par rapport a `r
pour quelle soit lip-
3. Quels sont parmi les probl` emes ci dessous, ceux qui admettent une solution unique :
x c fs r , r ! #" #"
`G
t % r s%
r c %Rf (
y(x) +2y(x) =2y(x), % y(0) = 1 et
c R % f (
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de deux e quations diff erentielles dordre un. 2. Appliquer la m ethodede RK2 a ` ce syst` eme . Exercice 95 : Soit l equation diff erentielle du troisi` eme ordre et a ` conditions initiales :
c %Rf % r Q% 5 r ,%r w ` (
et
% (
205
1. Ecrire cette e quation diff erentielle sous la forme dun syst` eme diff erentiel de trois e quations diff erentielles chacune dordre un. 2. On applique la m ethode dEuler a ` ce syst` eme, e crire lalgorithme correspondant. (On notera le pas dint egration.) Exercice 96 : Soit le probl` eme de Cauchy suivant :
1.
F q fR c %Rf ( r 9 6 8 r r r , r % ( fR Montrer que r est lipshitzienne par rapport a ` uniform ement par rap (
port a ` r , et donner une constante de Lipshitz.
2. Montrer que ce probl` eme admet une solution unique. 3. Donner la solution exacte de (1), ainsi que
R % A` .
4. Appliquer la m ethode dEuler a ` ce probl` eme, e crire lalgorithme corres ` laide dun pas de pondant et donner lapproximation de y(0.2) obtenue a s%RA ( discr etisation num erique . 5. Rappeler lerreur th eorique de la m ` lerreur %RA`G ethode dEuler et la comparer a . Commentaires ? commise sur le calcul de Exercice 97 : On consid` ere la m ethode a ` pas s epar es suivante (*) :
f 7 f 7 f 7 x ` r r x r
1. Etudier la consistance, la stabilit e th eorique, la convergence.
r r . 2. On veut calculer une valeur approch ee de Montrer que ce probl` eme peut e tre remplac e par la r esolution dun probl` eme & de Cauchy dont on pr ecisera la condition initiale, on posera r r Comment peut-on obtenir une valeur approch ee & de . ? Si on utilise la m ethode (*) pour calculer & , donner lexpression de & en fonction de . primer lerreur &
, ex-
206
8.9
exercice 39
Y fR r r r G %r ( ( %f Lintervalle dint egration est ( . que e tant continue et lipshitzienne par rapport a ` Remarquons tout dabord le probl` eme de Cauchy ( admet une solution unique (th eor` eme 9 de CauchyLipshitz). M ethode dEuler Elle s ecrit :
(
r f r 4r
r
On a aussi Do` u le tableau,
A ( p 5 ( x A p 5 ( . ( de r , est Cest a ` dire que lapproximation en r e quation Appliquons la m Solution exacte de cette e ethode de la variation de
la constante. ` re tape : e quation sans second membre. 1e e
%Q x s %RA ( , ( x e e e % ` p s 5 ( % %RA %RA` %A %RA p %RA s 5 ( A A`G` A ` ( ( ( ( ( 5G3
e % 3A R 3
et r
% Am R
r
x ( % e
% A
%A('
'
r n r r H% solution evidente. solutions sont donn ees par est une sb bP0 c ) Les autres G ` . avec u r . Do` nde tape : une solution particuli` 2 e ere On applique la m ethode de la varia db b b tion de la constante do` que lon reporte dans b b b b u bk ( : ainsi, . r 1 r r1 r en int egrant par parties on trouve b r1 r 1 r1 2 5 1 ( r 2

avec 1 . b ` me tape : solution g 3e e par e en erale. On remplace donn
207
c3)
54
donc,
( r 21%6 (
r 21
dans
w
Finalement, gr ace a ` la condition initiale
% q% ` 21 e87 1 ( ( ` ( r . Ainsi, la solution exacte de ( est ( ( Estimation de lerreur. La solution exacte ci-dessus donne ( ` Ap 5 5G3G3 . Ainsi, lerreur lors de lapplication { Ap commise A %RA` s 9 effectivement @ 5 5G3G3 5 ( p { de la m ethode dEuler est { { . Cherchons
lerreur th eorique qui est donn ee par :
% (
, on d etermine 1 , do` u
a ` , qui se calcule ais ement :
! ~ ( ` h PG U { { O` u~ r et est la constante de Lipschitz de x { r ft r f { { u {

7
par rapport
De m eme, on a
h r
Ainsi ~
( r ` ( r ( r `
s`
. Donc,
{ w { @9
! `(% x x x e ( ` ( s R % A p ( % 35 (
Clairement, { { { { , donc la m ethode dEuler donne une bonne ap (. proximation de la solution de ce probl` eme de Cauchy en r
208
exercice 42
ce probl` eme de Cauchy admet une solution unique (th eor` eme 9 de CauchyLipshitz). %Rf%RA` s%A` et le pas dint Lintervalle dint egration est egration est . M ethode de RK2 Elle s ecrit :
Q f7t % ( r r r er Remarquons tout dabord que e tant continue et lipshitzienne par rapport a `
soit
Bf x ` ~ x ~
x Q ` ~ x ~ e %RA %RA `f %RA `z %RA`hf A`G x ( ( et ~ ( ( . Donc ( , avec ~ %RA 3G3G3 . %RA` Ainsi, lapproximation en r de r , est x x % A mA R 3 3G3 ( ( ( G ( ` ~ x ~ A ( ( 3G3G3
quation Solution exacte de cette e
(
En multipliant ( par S donc do` u:
` Qu r f hH` ` H` (

r
W %
r do` u
on a
x hH`
9BA
r . On pose
`G
Ce qui est une e quation diff erentielle lin eaire du 1 ordre. On lint` egre par la m ethode de la variation de la constante comme a ` lexercice pr ec edent. s` P% Pb . L equation sans second membre est de solution ou Une solution particuli` ere par la variation de la constante. On a
E c )
avec
5 C `D `Gx ` p r ce qui implique r1 . . Do` u, dans

Int egrons
209
par parties :
p0F ( ` r1 ` r1 ` r Q P
( ` rHG I1 21 `
PGR1 comme BS P , . La solution g erale est donc r S en hy ` r t ` r TP . Ainsi, r QP . Comme 1 US . Finalement, t ` S P alors r VP . `Gs t ` SW ` QP X p s Estimation de lerreur. La solution exacte est BSW YX` YX` Y`Y`Y` @9 {P WP { SaWbSYS P WP P . Donc lerreur commise est { { P P WP . On peut comparer cette erreur effective a ` lerreur th eorique sur RK2, donn ee par : (le th eor` eme du cours)
avec 1
cE)
exercice 43
Soit le probl` eme de Cauchy suivant
Remarquons tout dabord que e tant continue et lipshitzienne par rapport a ` le probl` eme de Cauchy P admet une solution unique (th eor` eme 9 de CauchyLipshitz). M ethode dEuler. Elle s ecrit :
c Y r U S
` q fR r r r P
P
P
r f ` r ` 4r
On a aussi US a ' S W Donc x
Cest a x `Sadire p `que lapproximation en r W P .
Q SaW S P , P r et r ` e e S ( W S u le tableau, , do` ` X P S ` X WP SaW SaW r S Sa'G ` SaW Y`G SaW p ` P P SaW SW X
de
r avec le pas
SaW P , est
210
quation. En appliquant la m Solution exacte de cette e ethode de la variation de la constante, comme au premier exercice, on trouve la solution g en erale, ` H` X . r r Xj SW `` Estimation de lerreur. La solution exacte ci-dessus donne BSaW . Ainsi, lerreur effectivement commise lors de lapplication de la m ethode @9 {#SaW `G` SaW p { SaW(S ' P P . Cherchons lerreur th dEuler est { { eorique qui est donn ee par :
a ` , qui est ici clairement e gale a ` . On a
~ P ` ed hgf PG U { c c r { et est la constante de Lipschitz de ~ O` u x P c c hX W r
par rapport
Ainsi ~
iX
. Donc,
{ w { @9
x dq ep ef s SaW P eqp
P
sr
sP ` p SaW(S
W
P S
Clairement, { { { { , donc la m ethode dEuler donne une bonne ap SW X proximation de la solution de ce probl` eme de Cauchy en r .
exercice 44
c Y r U S
XY` P
r X , puis P
En appliquant la m ethode de la variation de la constante, au premier ut comme exercice, on trouve la solution g en erale, r u1 v1 v1 o` est la constante dint egration.
S P , alors 1 , donc la solution du probl` eme est r . BS k w , donc la solution du probl` 2. Si eme est r P , alors 1 . w { r r r Conclusion : En comparant et , on voit que la diff e rence w { x , les deux solutions r . M eme si est tr` es petit, cet e cart tend vers y S 1. Si B
divergent lune de lautre. Ce probl` eme est donc tr` es sensible aux Conditions Initiales.
211
exercice 45
P sousla Ecrivons forme de deux e quations diff erentielles dordre 1 chacune. c ec c cR Fq R . Ainsi, on obtient le syst` , do` u eme : Pour cela on pose
c c Fq r r
g F R
ff r f r f
1. Appliquons Euler :
2.
f7 f x r f f I I x I r I ff Q ff Fq 7 r , soit Avec r et r x I Fq f x I I avec et donn es. e e M ethode de Taylor dordre 2, elle s ecrit : i f f f W f 1l x r ` r r r r
On obtient donc,
x I x
F 4 q Q q C P DGI 4 I F F 6 4 I 6 B I I ` r `P
S 6
exercice 48
Avec r
c 0 f .
c c r ` c r Y P ec h h c
do` u
1. On pose
cc
ò c ` . On trouve le syst` eme c G ` ` uq` f c

P et P . avec r et Matriciellement ce syst` eme s ecrit,
212
c 0f
h
ou
i c i i l S l P l ` ` c t r f avec 4 6 et lendomorphisme associ ea ` la matrice i C) ) S P l f ` ` f r f7f W

c
Ce syst` eme peut donc s ecrire,
2. a) Appliquons la m ethode dEuler. f Elle s ecrit x r
f6 d g f dg
4 x 6 `G
elle s ecrit :
. Appliqu ee a `
S
i i l I i l I
` i
S
` P l
i
X
` l
P
i I
` ` l I
P et avec . e e ethode b) Appliquons la m de RK2, elle s ecrit :
s`
x I x
Ì I I ` ~ x ~
avec ~ x ~ x : ~ x
r f r f
et ~

r
S
i I
r f 7 . Calculons i l I ` H ` I
` l
P

Calculons ~
213
r f ~ x ~ x i i i S l l P l F ` ` ` I H` I i i I S l 0I ` `P l ` I I i ` l I I ` ` H` I i ` I H ` l I P ` " ` `G p I

G
Ainsi,
i xl l ` x I I i i l I ` o ` ` I I x I x
~ x ~ ` ` l I P ` 1 ` H`G p I
W
Donc
H` 7 P I ` ` P ` X I P P P 1 P I ` 1 X ` P QP I
W
Par cons equent
x I x
214
8.10
On pr esente dans la suite une mise en uvre des m ethodes de r esolution num erique des e quations diff erentielles, puis des syst` emes diff erentiels. On utilise dans les deux cas, les m ethodes dEuler et de Runge-Kutta dordre 2 et 4.
8.10.1
quations diff R esolution num erique des e erentielles
Nous d ecomposons nos programmes en plusieurs classes : une classe abstraite de description de l equation diff erentielle. Elle permet d etre utilis ee dune mani` ere g en erique dans les m ethodes et programmes de traitement ; une classe abstraite d ecrivant un processus dit eration de r esolution qui pourra e tre utilis ee dans des classes g en erique de traitement. Elle est d eriv ee en trois classes de processus, la m ethode dEuler et les m ethodes de RungeKutta dodre 2 et 4 ; une classe de traitement g en erique qui d ecrit un processus it eratif de calcul de solution et une repr esentation graphique associ ee, ceci ind ependamment de l equation diff erentielle et du processus utilis es ; et nalement, une classe d ecrivant une e quation diff erentielle particuli` ere et la classe contenant le programme principal qui met en uvre le traitement g en erique pr ec edent auquel on transmettra une instance de la classe particuli` ere construite et le processus choisis. Une classe abstraite de description de l equation La classe abstraite suivante fait r ef erence a ` une e quation diff erentielle qui doit e tre d ecrite dans la m ethode calcul.
abstract class FoncEDO{ public double t0; public double y0; public double pas; public int nbpas; FoncEDO(double pt0, double py0, double ppas, int pnbpas) { t0=pt0; y0=py0; pas=ppas; nbpas=pnbpas; } abstract public double calcul (double t, double x); abstract public String libelle();

}
215
Des classes de description des m ethodes Nous d ecrivons ici une classe abstraite faisant r ef erence a ` un processus de r esolution num erique d equation diff erentielle qui doit e tre d ecrite dans la m ethode iter.
abstract class IterEDO { FoncEDO f; double h; double yCourant; double tCourant; IterEDO(FoncEDO fonc, double pas, double y0, double t0) { f=fonc; h=pas; yCourant=y0; tCourant=t0; } public void set_yCourant (double y0) { yCourant=y0; } public void set_tCourant (double t0) { tCourant=t0; } abstract public double iter(); public double iter (double t, double y) { set_tCourant(t); set_yCourant(y); return iter(); } }
La classe suivante d erive de la pr ec edente et d ecrit le processus de r esolution bas e sur la m ethode dEuler.
class IterEuler extends IterEDO { IterEuler (FoncEDO fonc, double pas, double y0, double t0) { super(fonc, pas, y0, t0); } public double iter() { yCourant = yCourant + h*f.calcul(tCourant, yCourant); tCourant += h; return yCourant;

} }
216
La classe suivante impl emente la m ethode de Runge-Kutta dordre 2.
class IterRK2 extends IterEDO { IterRK2 (FoncEDO fonc, double pas, double y0, double t0) { super(fonc, pas, y0, t0); } public double iter() { double k1 = f.calcul(tCourant, yCourant); tCourant += h; double k2 = f.calcul(tCourant, yCourant + h * k1); yCourant = yCourant + h * ( k1 + k2 )/2; return yCourant; } }
La classe suivante impl emente la m ethode de Runge-Kutta dordre 4.
class IterRK4 extends IterEDO { IterRK4 (FoncEDO fonc, double pas, double y0, double t0) { super(fonc, pas, y0, t0); } public double iter() { double k1 = f.calcul(tCourant, yCourant); tCourant += 0.5*h; double k2 = f.calcul(tCourant, yCourant + 0.5*h * k1); double k3 = f.calcul(tCourant, yCourant + 0.5*h * k2); tCourant += 0.5*h; double k4 = f.calcul(tCourant, yCourant + h * k3); yCourant = yCourant + h * (k1 + 2*k2 + 2*k3 + k4)/6; return yCourant; } }

Traitement g en erique
217
Nous d ecrivons maintenant un processus g en erique qui effectue un certain nombre dit erations a ` partir dun processus de r esolution arbitraire - de type IterEDO. Une repr esentation graphique est r ealis ee. Cette derni` ere utilise la m ethode CanvasGraphe d enies dans les chapitres pr ec edents.
import import import import java.lang.*; java.io.*; java.util.*; java.awt.*;
class TraitFEDO { TraitFEDO(FoncEDO fedo, IterEDO methode) { double t0=fedo.t0, y0=fedo.y0, pas=fedo.pas; int nbpas=fedo.nbpas; double[] tc = new double[nbpas]; double[] yc = new double[nbpas]; tc[0]=t0; yc[0]=y0; for (int i=1; i<nbpas; i++) { tc[i] = tc[i-1]+pas; yc[i] = methode.iter(); } // calcul des extrema du tableau yc : MaxminTabDouble myc = new MaxminTabDouble(yc); double maxyc = myc.getmaxi(); double minyc = myc.getmini();
// representation graphique du calcul : DomaineDouble dr = new DomaineDouble(tc[0], minyc, tc[nbpas-1], maxy DomaineInt de = new DomaineInt(0, 0, 600, 450); CanvasGraphe cg = new CanvasGraphe(dr, de, tc, yc); FenetreGraphe x = new FenetreGraphe(de, cg, fedo.libelle()); x.show(); } }
Exemple dutilisation Nous d ecrivons maintenant une utilisation des classes pr ec edentes. Nous d enissons l equation diff erentielle a ` r esoudre dans la classe FEDO et nous cr eons
218
une instance du traitement g en erique pr ec edent auquel nous transmettons des instances de la classe FEDO et dun processus de r esolution. L equation diff erentielle r e solue ici est :
Fq ` R r BS SaW s
class FEDO extends FoncEDO { FEDO (double pt0, double py0, double ppas, int pnbpas) { super(pt0, py0, ppas, pnbpas); } public double calcul(double t, double y) { return Math.sin(2*t-y); } public String libelle() {return "dy/dt = sin(2t-y)"; } } class PrgEdo{ public static void main(String args[]) { double t0=0, y0=0.5, pas=0.1; int nbpas=100; FEDO f = new FEDO(t0, y0, pas, nbpas); IterEDO methode = new IterRK4(f, pas, y0, t0); TraitFEDO work = new TraitFEDO(f, methode); } }
La solution obtenue est trac ee dans la gure 8.1.
8.10.2
R esolution num erique des syst` emes diff erentiels
Nous suivons la m eme construction pour e crire un ensemble de classes de r esolution num erique de syst` emes diff erentiels. Une classe abstraite de description du syst` eme La classe abstraite suivante fait r ef erence a ` un syst` eme qui sera d ecrit dans la m ethode calcul.
219
F IG . 8.1: R esolution num erique dune e quation diff erentielle
abstract class SysEDO { public int dim; public double t0; public double[] y0; public double pas; public int nbpas; public int ixGraph; public int iyGraph; SysEDO(int pdim, double pt0, double[] py0, double ppas, int pnbpas, int pixGraph, int piyGraph) { dim=pdim; t0=pt0; y0=py0; pas=ppas; nbpas=pnbpas; ixGraph=pixGraph; iyGraph=piyGraph; } abstract public double[] calcul (double t, double[] x); abstract public String libelle(); }

Des classes de description des m ethodes
220
La classe suivante est une construction abstraite qui fait r ef erence a ` un processus it eratif de r esolution de syst` eme d ecrit par la m ethode iter.
abstract class IterSysEDO { SysEDO f; double h; public double[] yCourant; public double tCourant; int dim; IterSysEDO(SysEDO fonc, double pas, double[] y0, double t0) { f=fonc; h=pas; yCourant=y0; tCourant=t0; dim=y0.length; } public void set_yCourant (double[] y0) { yCourant=y0; } public void set_tCourant (double t0) { tCourant=t0; } abstract public double[] iter(); public double[] iter (double t, double[] y) { set_tCourant(t); set_yCourant(y); return iter(); } }
On construit une classe qui en d erive et qui d ecrit la m ethode dEuler pour un syst` eme.
class IterSysEuler extends IterSysEDO { IterSysEuler (SysEDO fonc, double pas, double[] y0, double t0) { super(fonc, pas, y0, t0); } public double[] iter() { int i; double[] yNew = new double[dim]; for (i=0; i<dim; i++) yNew[i] = yCourant[i] + h*(f.calcul(tCourant, yCourant))[i]; for (i=0; i<dim; i++) { yCourant[i] = yNew[i];
221
//System.out.println("yCourant["+i+"] = "+yCourant[i]); } //yCourant=yNew; tCourant += h; return yNew; } }
La classe suivante impl emente la m ethode de Runge-Kutta dordre 2 pour un syst` eme.
class IterSysRK2 extends IterSysEDO { IterSysRK2 (SysEDO fonc, double pas, double[] y0, double t0) { super(fonc, pas, y0, t0); } public double[] iter() { int i; double[] k1 = new double[dim]; double[] k2 = new double[dim]; double[] yNew = new double[dim]; for (i=0; i<dim; i++) { k1[i] = (f.calcul(tCourant, yCourant))[i]; yNew[i] = yCourant[i] + h*k1[i]; } for (i=0; i<dim; i++) k2[i] = (f.calcul(tCourant+h, yNew))[i]; for (i=0; i<dim; i++) yNew[i] = yCourant[i]+0.5*h*(k1[i]+k2[i]); for (i=0; i<dim; i++) yCourant[i] = yNew[i]; tCourant += h; return yNew; } }
La classe suivante impl emente la m ethode de Runge-Kutta dordre 4 pour un syst` eme.
class IterSysRK4 extends IterSysEDO {
222
IterSysRK4 (SysEDO fonc, double pas, double[] y0, double t0) { super(fonc, pas, y0, t0); } public double[] iter() { int i; double[] k1 = new double[dim]; double[] k2 = new double[dim]; double[] k3 = new double[dim]; double[] k4 = new double[dim]; double[] yNew = new double[dim]; for (i=0; i<dim; i++) { k1[i] = (f.calcul(tCourant, yCourant))[i]; yNew[i] = yCourant[i] + 0.5*h*k1[i]; } for (i=0; i<dim; i++) { k2[i] = (f.calcul(tCourant+0.5*h, yNew))[i]; yNew[i] = yCourant[i] + 0.5*h*k2[i]; } for (i=0; i<dim; i++) { k3[i] = (f.calcul(tCourant+0.5*h, yNew))[i]; yNew[i] = yCourant[i] + h*k3[i]; } for (i=0; i<dim; i++) k4[i] = (f.calcul(tCourant+h, yNew))[i]; for (i=0; i<dim; i++) yNew[i] = yCourant[i]+h/6*(k1[i]+2*k2[i]+2*k3[i]+k4[i]); for (i=0; i<dim; i++) yCourant[i] = yNew[i]; tCourant += h; return yNew; } }
Traitement g en erique On adapte le traitement g en erique pr ec edent au cas dun syst` eme diff erentiel.
java.lang.*; java.io.*; java.util.*; java.awt.*;
223
class TraitSEDO { TraitSEDO(SysEDO fedo, IterSysEDO methode) { int dim=fedo.dim; double t0=fedo.t0; double[] y0=fedo.y0; double pas=fedo.pas; int nbpas=fedo.nbpas; int ixGraph=fedo.ixGraph; int iyGraph=fedo.iyGraph; int i; double[] tc = new double[nbpas]; double[][] yc = new double[nbpas][dim]; tc[0]=t0; for (i=0; i<dim; i++) yc[0][i]=y0[i]; for (i=1; i<nbpas; i++) { tc[i] = tc[i-1]+pas; yc[i] = methode.iter(); } double[] xgraph = new double[nbpas]; double[] ygraph = new double[nbpas]; for (i=0; i<nbpas; i++) { if (ixGraph != -1) xgraph[i] = yc[i][ixGraph]; else xgraph[i] = tc[i]; ygraph[i] = yc[i][iyGraph]; } // calcul des extrema des tableaux : MaxminTabDouble mxg = new MaxminTabDouble(xgraph); MaxminTabDouble myg = new MaxminTabDouble(ygraph); double maxx = mxg.getmaxi(); double maxy = myg.getmaxi(); double minx = mxg.getmini(); double miny = myg.getmini(); // representation graphique du calcul : DomaineDouble dr = new DomaineDouble(minx, miny, maxx, maxy); DomaineInt de = new DomaineInt(0, 0, 450, 450); CanvasGraphe cg = new CanvasGraphe(dr, de, xgraph, ygraph);
224
FenetreGraphe x = new FenetreGraphe(de, cg, fedo.libelle()); x.show(); } }
Exemple dutilisation sur un mouvement circulaire Nous testons les classes pr ec edentes en effectuant une r esolution num erique du syst` eme diff erentiel :
w Fq CIDGF r r B S S B PY
Nous trac ons un portrait de phase, cest a ` dire la trajectoire des points de B 7 f 7 r en faisant varier r . la solution th coordonn ees r eorique correspond au cercle trigonom etrique.
class SEDOCirc extends SysEDO { SEDOCirc(int pdim, double pt0, double[] py0, double ppas, int pnbpas, int pixGraph, int piyGraph) { super(pdim, pt0, py0, ppas, pnbpas, pixGraph, piyGraph); } public double[] calcul(double t, double[] y) { double[] result = new double[2]; result[0] = -Math.sin(t); result[1] = Math.cos(t); return result; } public String libelle() { return "Mouvement circulaire";} } class PrgCirc{ public static void main(String args[]) { int dim=2; double t0=0; double[] y0={1,0}; double pas=0.5; int nbpas=15; int ixGraph=0, iyGraph=1;
225
SEDOCirc sf = new SEDOCirc(dim, t0, y0, pas, nbpas, ixGraph, iyGraph); IterSysEDO methode = new IterSysEuler(sf, pas, y0, t0); TraitSEDO work = new TraitSEDO(sf, methode); } }
Lavant derni` ere ligne du programme contient le nom du processus effective de r esolution utilis ee. Il suft simplement de modier cette ligne pour utiliser un autre processus. Cest ce qui est fait dans la suite. On utilise donc dabord la m ethode dEuler qui donne de mauvais r esultats car elle amplie a ` chaque it eration sa d eviance par rapport au cercle-unit e solution du probl` eme.
F IG . 8.2: Mouvement circulaire d ecrit par une m ethode dEuler
La trajectoire suivante est obtenue en utilisant la m ethode de Runge-Kutta dordre 2. On voit que la solution num erique approch ee est meilleure que pour la m ethode dEuler. Finalement, nous utilisons la m ethode de Runge-Kutta dordre 4 qui, a ` chaque it eration, va fournir une solution situ ee sur la trajectoire exacte du syst` eme (ici, le
226
F IG . 8.3: Mouvement circulaire d ecrit par une m ethode de Runge-Kutta dordre 2
cercle unit e).
quations de Lorentz Exemple dutilisation sur les e Nous appliquons maintenant notre programme pour r esoudre les e quations de Lorentz : uy
" 1 k n B S PD
q
US
PD
, et 1 sont des param` etres qui seront e gaux, ici, respectivement a `P S ,
US
DX
et
class SEDOLorentz extends SysEDO { double a=10, b=8/3, c=28;
SEDOLorentz(int pdim, double pt0, double[] py0, double ppas, int pnbpas, int pixGraph, int piyGraph) { super(pdim, pt0, py0, ppas, pnbpas, pixGraph, piyGraph); }
227
F IG . 8.4: Mouvement circulaire d ecrit par une m ethode de Runge-Kutta dordre 4
public double[] calcul(double t, double[] y) { double[] result = new double[3]; result[0] = a*(y[1]-y[0]); result[1] = c*y[0]-y[0]*y[2]-y[1]; result[2] = y[0]*y[1] -b*y[2]; return result; } public String libelle() { return "Equations de Lorentz";} } class PrgLorentz{ public static void main(String args[]) { int dim=3; double t0=0; double[] y0={1,1,1}; double pas=0.01; int nbpas=4000; int ixGraph=0, iyGraph=2; SEDOLorentz sf = new SEDOLorentz(dim, t0, y0, pas, nbpas, ixGraph, iyGraph);
228
IterSysEDO methode = new IterSysRK4(sf, pas, y0, t0); TraitSEDO work = new TraitSEDO(sf, methode); } }
de
montrons dans la gure 8.5 la solution trouv ee en trac ant r Nous

r .
en fonction
F IG . 8.5: R esolution num erique des e quations de Lorentz - Portrait de phase en (x,z)

Livre MN Java

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Livre MN Java

Transféré par

Droits d'auteur :

Formats disponibles

METHODES NUMERIQUES APPLIQUEES cours, exercices corrig es et mise en uvre en JAVA

Table des mati` eres

M ethodes num eriques avec Java

M ethodes num eriques avec Java

M ethodes num eriques avec Java

6.4 6.5 6.6 7

Chapitre 1 ` Java Introduction a

M ethodes num eriques avec Java

Une machine virtuelle

M ethodes num eriques avec Java

Types primitifs et structures de contr ole

Structures de contr ole

M ethodes num eriques avec Java

Classes et objets en Java

D eclaration, cr eation et destruction dobjets

M ethodes num eriques avec Java

M ethodes num eriques avec Java

Construction de la classe vecteur

M ethodes num eriques avec Java

M ethodes num eriques avec Java

M ethodes num eriques avec Java

Composants de type static

M ethodes num eriques avec Java

Composants de type public et de type private

M ethodes num eriques avec Java

Cha nes de caract` eres

M ethodes num eriques avec Java

M ethodes num eriques avec Java

Organisation des chiers sources dun programme Java

Commandes de compilation et de lancement dun programme

M ethodes num eriques avec Java

M ethodes num eriques avec Java

Visibilit e des composants dans les packages

packages pr ed enis en Java

M ethodes num eriques avec Java

Polygone Triangle Rectangle

F IG . 1.1: Arbre dh eritage de classes dobjets g eom etriques

M ethodes num eriques avec Java

Constructeur dune classe d eriv ee

Accessibilit e : public, protected et private

M ethodes num eriques avec Java

et la classe ClB d enie ainsi :

ClA { autoris e autoris e interdit

M ethodes virtuelles et classes abstraites

M ethodes num eriques avec Java

Un exemple : quelques objets g eom etriques

M ethodes num eriques avec Java

La classe Triangle est une classe e l ementaire d eriv ee de la classe polygone :

M ethodes num eriques avec Java

Voici un programme principal de test :

M ethodes num eriques avec Java

Lex ecution du programme afche :

M ethodes num eriques avec Java

Passage dune fonction en param` etre dune m ethode

'("9681354@# !!"$#&% '("0)213545#768 1 

M ethodes num eriques avec Java

Le r esultat de lex ecution est :

M ethodes num eriques avec Java

M ethodes num eriques avec Java

Une ex ecution possible du programme est la suivante :

D enir sa propre exception

M ethodes num eriques avec Java

Voici deux ex ecutions successives du programme pr ec edent :

M ethodes num eriques avec Java

'("9681354@# !!"$#&% '("0)213545#768 1

D !"$# EGF "IH

" "#G U } b "d " W c !" # b Qa` Q

" tb !"$# b "dF " d0 " "P

efFripq # b egfhFpirq efFripq

si 8hpr7!($ 8hpr7 (!$ 8ghpr

C 8$G est conver , condition limite de la

ha$ !h5 choisi .