Livre MN Java

METHODES NUMERIQUES APPLIQUEEScours, exercices corriges et mise en uvre en

JAVA

M.A. Aziz Alaoui et C. BertelleFaculte des Sciences et Techniques

25 rue Philippe Lebon - BP 54076058 Le Havre Cedex - France

13 septembre 2002

Resume

On presente brie`vement quelques methodes numeriques usuelles etelementaires a` lusage des etudiants en fin de premiers cycles scientifiquesuniversitaires ou de ceux debutant un second cycle.

.............. A REVOIR ..............

Les mathematiciens et autres scientifiques se sont toujours interesses a` laresolution numerique des proble`mes quils rencontrent, lanalyse mathematiqueclassique ne pouvant resoudre tous les proble`mes qui se posent (par exempleen integration, equations differentielles, interpolation, resolution dequations nonlineaires ...). Linteret des scientifiques pour les methodes et lanalyse numeriqueen general, na donc cesse daugmenter. Deux notions save`rent alors impor-tantes :

-lerreur numerique-la notion de stabilite.

Abordees de manie`re rapide dans cet ouvrage, nous renvoyons le lecteur a` desouvrages specialises [?, ?] pour approfondir ces notions utiles pour la validationdes methodes numeriques.

Les theore`mes et propositions enonces ne seront pas demontres, la plupartsont, ou peuvent etre facilement, traites en exercices, nexigeant pas dargumentsmathematiques profonds.

Nous completons un certain nombre de chapitres par des petits programmesdapplications en Java ou` lon a privilegie une lecture facile pour des debutantsdans ce langage et la programmation objet plutot que des developpementsexhaustifs et generiques necessitant souvent des constructions elaborees quidepassent le cadre des objectifs definis pour ce manuel. Le choix de Java pourimplementer des methodes numeriques est discutable en raison des faibles per-formances de calcul des plate-formes de developpement actuelles en Java maisqui sameliorent regulie`rement de manie`re importante. Notre souci premier estavant tout pedagogique et Java est un langage oriente objet propre et qui se veutsimple. Sa portabilite integrant des possibilites graphiques interessantes repond a`nos preoccupations pedagogiques et de rentabilisation de linvestissement dans unnouveau langage dans une discipline informatique en evolution permanente.

Table des matie`res

1 Introduction a` Java 21.1 Presentation de Java . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . 21.1.2 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . 21.1.3 Une machine virtuelle . . . . . . . . . . . . . . . . . . . 31.1.4 Caracteristiques . . . . . . . . . . . . . . . . . . . . . . . 3

1.2 Types primitifs et structures de controle . . . . . . . . . . . . . . 41.2.1 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . 41.2.2 Structures de controle . . . . . . . . . . . . . . . . . . . 4

1.3 Classes et objets en Java . . . . . . . . . . . . . . . . . . . . . . 51.3.1 Definition dune classe . . . . . . . . . . . . . . . . . . . 51.3.2 Declaration, creation et destruction dobjets . . . . . . . . 51.3.3 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . 61.3.4 Construction de la classe vecteur . . . . . . . . . . . . . . 71.3.5 Composants de type static . . . . . . . . . . . . . . . 101.3.6 Composants de type public et de type private . . . . 111.3.7 Chanes de caracte`res . . . . . . . . . . . . . . . . . . . . 12

1.4 Organisation des fichiers sources dun programme Java . . . . . . 141.4.1 Structure des fichiers sources . . . . . . . . . . . . . . . . 141.4.2 Commandes de compilation et de lancement dun pro-

gramme . . . . . . . . . . . . . . . . . . . . . . . . . . . 141.4.3 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . 151.4.4 Visibilite des composants dans les packages . . . . . . . . 161.4.5 packages predefinis en Java . . . . . . . . . . . . . . . . 16

1.5 Heritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.5.1 Construire une classe derivee . . . . . . . . . . . . . . . . 171.5.2 Constructeur dune classe derivee . . . . . . . . . . . . . 181.5.3 Accessibilite : public, protected et private . . . . . . . . . 181.5.4 Methodes virtuelles et classes abstraites . . . . . . . . . . 191.5.5 Un exemple : quelques objets geometriques . . . . . . . . 20

1

Methodes numeriques avec Java 2

1.5.6 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . 231.5.7 Passage dune fonction en parame`tre dune methode . . . 24

1.6 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261.6.1 Notions generales . . . . . . . . . . . . . . . . . . . . . . 261.6.2 Definir sa propre exception . . . . . . . . . . . . . . . . . 27

1.7 Entrees/Sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . 291.7.1 Classes de gestion de flux . . . . . . . . . . . . . . . . . 291.7.2 Saisies au clavier . . . . . . . . . . . . . . . . . . . . . . 301.7.3 Lecture dun fichier . . . . . . . . . . . . . . . . . . . . . 311.7.4 Ecriture dans un fichier . . . . . . . . . . . . . . . . . . . 331.7.5 Complements . . . . . . . . . . . . . . . . . . . . . . . . 33

1.8 Conclusion provisoire . . . . . . . . . . . . . . . . . . . . . . . . 34

2 Resolution des equations non lineraires dans 352.1 Localisation (ou separation) des racines . . . . . . . . . . . . . . 352.2 Methode des approximations successives . . . . . . . . . . . . . . 362.3 Ordre dune methode . . . . . . . . . . . . . . . . . . . . . . . . 392.4 Exemples de methodes iteratives . . . . . . . . . . . . . . . . . . 41

2.4.1 Methode de Lagrange (ou de la corde) . . . . . . . . . . . 412.4.2 Methode de Newton . . . . . . . . . . . . . . . . . . . . 42

2.5 Acceleration de la convergence . . . . . . . . . . . . . . . . . . . 432.5.1 Methode dAitken, ou Procede dAitken . . . . . . . . 432.5.2 Methode de Steffensen, exemple de composition de

methodes . . . . . . . . . . . . . . . . . . . . . . . . . . 442.5.3 Methode de Regula-Falsi . . . . . . . . . . . . . . . . . . 44

2.6 Enonces des exercices corriges . . . . . . . . . . . . . . . . . . . 452.7 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 472.8 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 512.9 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 61

2.9.1 Une classe abstraite de description de processus iteratifs . 612.9.2 La methode de Lagrange . . . . . . . . . . . . . . . . . . 632.9.3 La methode de Steffensen . . . . . . . . . . . . . . . . . 66

3 Resolution des syste`mes lineaires 683.1 Methode delimination de Gauss . . . . . . . . . . . . . . . . . . 69

3.1.1 Resolution dun syste`me triangulaire . . . . . . . . . . . . 693.1.2 Methode de Gauss . . . . . . . . . . . . . . . . . . . . . 693.1.3 Factorisation . . . . . . . . . . . . . . . . . . . . . . 703.1.4 Remarque sur le Pivot . . . . . . . . . . . . . . . . . . . 71

3.2 Enonces des exercices corriges . . . . . . . . . . . . . . . . . . . 733.3 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 75


3.4 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 773.5 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 85

3.5.1 Les tableaux multidimensionnels en Java . . . . . . . . . 853.5.2 Une classe matrice . . . . . . . . . . . . . . . . . . . . . 853.5.3 Une classe abstraite de syste`me lineaire . . . . . . . . . . 903.5.4 Les classes syste`mes lineaires triangulaires . . . . . . . . 913.5.5 La classe syste`mes lineaires generals implementant la fac-

torisation LU . . . . . . . . . . . . . . . . . . . . . . . . 97

4 Graphisme scientifique avec Java 1024.1 Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

4.1.1 Un premier exemple . . . . . . . . . . . . . . . . . . . . 1024.1.2 Passage de parame`tres . . . . . . . . . . . . . . . . . . . 1034.1.3 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . 1044.1.4 Complements . . . . . . . . . . . . . . . . . . . . . . . . 104

4.2 Gestion de fenetres avec AWT . . . . . . . . . . . . . . . . . . . 1044.2.1 Traces dans des applets . . . . . . . . . . . . . . . . . . . 1044.2.2 Construire des interfaces fenetrees . . . . . . . . . . . . . 106

4.3 Construction de courbes de traces scientifiques . . . . . . . . . . 1104.3.1 Les domaines bidimensionnels de lutilisateur et du dis-

positif daffichage . . . . . . . . . . . . . . . . . . . . . 1104.3.2 Un gestionnaire de fenetres de base . . . . . . . . . . . . 1114.3.3 Une classe dutilitaires pour le trace de graphismes scien-

tifiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 1124.3.4 Un exemple dutilisation . . . . . . . . . . . . . . . . . . 115

5 Interpolation Polynomiale 1185.1 Introduction. Existence et unicite du polynome dinterpolation . . 1185.2 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . . . 1185.3 Interpolation dHermite . . . . . . . . . . . . . . . . . . . . . . 1205.4 Enonces des Exercices Corriges . . . . . . . . . . . . . . . . . . 1215.5 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 1235.6 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 1245.7 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 132

6 Approximation par moindres carres 1416.1 Principe dapproximation et crite`re de moindres carres . . . . . . 1416.2 Regression lineaire . . . . . . . . . . . . . . . . . . . . . . . . . 142

6.2.1 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . 1446.3 Generalisation aux mode`les lineaires . . . . . . . . . . . . . . . . 147

6.3.1 Ecriture matricielle du proble`me . . . . . . . . . . . . . . 149


6.3.2 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . 1506.4 Enonces des exercices corriges . . . . . . . . . . . . . . . . . . . 1606.5 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 1616.6 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 161

7 Integration Numerique 1627.1 Methodes des Rectangles . . . . . . . . . . . . . . . . . . . . . . 162

7.1.1 Methode des Rectangles superieurs et inferieurs . . . . . . 1627.1.2 Methode des rectangles points-milieux . . . . . . . . . . 163

7.2 Methodes des trape`zes . . . . . . . . . . . . . . . . . . . . . . . 1637.3 Methode de Simpson . . . . . . . . . . . . . . . . . . . . . . . . 1647.4 Methode de Romberg . . . . . . . . . . . . . . . . . . . . . . . . 1657.5 Enonces des exercices corriges . . . . . . . . . . . . . . . . . . . 1687.6 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 1707.7 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 1737.8 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 179

7.8.1 Des classes abstraites dintegration numerique . . . . . . 1797.8.2 Des classes dimplementation de la methode des trape`zes . 1807.8.3 Des classes dimplementation de la methode de Simpson . 1817.8.4 Un programme de test des methodes des trape`zes et de

Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . 1827.8.5 Mise en uvre de la methode de Romberg . . . . . . . . . 183

8 Resolution Numerique des equations differentielles 1868.1 Introduction, le proble`me mathematique . . . . . . . . . . . . . . 1868.2 La Methode dEuler . . . . . . . . . . . . . . . . . . . . . . . . . 187

8.2.1 Etude de lerreur dEuler . . . . . . . . . . . . . . . . . . 1898.3 Methodes de Taylor dordre deux . . . . . . . . . . . . . . . . . . 1898.4 Methodes de Runge-Kutta . . . . . . . . . . . . . . . . . . . . . 190

8.4.1 Runge-Kutta dordre 2 : RK2 . . . . . . . . . . . . . . . 1908.4.2 Runge-Kutta dordre 4 : RK4 . . . . . . . . . . . . . . . 190

8.5 Generalites sur les methodes a` un pas . . . . . . . . . . . . . . . 1908.6 Resolution de syste`mes differentiels dans IR . . . . . . . . . . . 1928.7 Enonces des exercices corriges . . . . . . . . . . . . . . . . . . . 1938.8 Enonces des exercices non corriges . . . . . . . . . . . . . . . . . 1978.9 Corriges des exercices . . . . . . . . . . . . . . . . . . . . . . . 2038.10 Mise en uvre en Java . . . . . . . . . . . . . . . . . . . . . . . 211

8.10.1 Resolution numerique des equations differentielles . . . . 2118.10.2 Resolution numerique des syste`mes differentiels . . . . . 215

Chapitre 1

Introduction a` Java

Lobjectif de ce chapitre nest pas de faire une presentation exhaustive de Java,mais den donner les notions essentielles au lecteur qui ny est pas coutumier, pourquil en saisisse lesprit et puisse comprendre les developpements dapplicationsde methodes numeriques qui seront faites dans les chapitres suivants. Le lecteurdesirant des renseignements plus complets sur ce langage pourra consulter, parexemple [?, ?].

Nous supposons, par ailleurs, que le lecteur a une connaissance prealable dunlangage de programmation evolue - C par exemple - mais pas necessairementen programmation objet. On peut considerer que cest le cas de la majorite desetudiants en premier cycle scientifique.

1.1 Presentation de Java1.1.1 Objectifs

Le langage Java a ete developpe afin de pouvoir generer des applications quisoient independantes des machines et de leur syste`me dexploitation. Une desautres caracteristiques du langage est de pouvoir ecrire des applications structu-rellement distribuees sur des reseaux. Il appartient, par ailleurs, a` la famille deslangages objets purs ou` rien ne peut exister en dehors des classes.

1.1.2 HistoriqueAu debut des annees 1990, une equipe de developpeurs de la societe SUN

Microsystems travaille sur limplementation du langage OAK pour lintegrer endomotique, notamment pour le developpement de la television interactive. Il fal-lait que les codes des applications dans ce langage soit peu volumineux, efficaces

5


et independants de larchitecture. A cette epoque, la television interactive na pasconnue lessor escompte alors que le developpement dInternet et du Web fai-sait apparatre des besoins urgents de meme nature. En 1995, OAK devient Javaet se trouve popularise rapidement pour ses possibilites de developpement liesau Web. Les annees qui suivent font connatre a` Java une popularite en tant quelangage generaliste qui depasse les previsions de SUN. Les grands industrielsdu developpement ladopte rapidement en lespace de quelques annees. Pour lesannees a` venir, les industriels projettent la creation de puces electroniques dedieesa` Java ... un juste retour vers les preoccupations initiales des concepteurs originauxde OAK/Java.

Certes Java est un langage proprietaire, mais de licence ouverte, ce qui lui apermis de se faire adopter par tous les professionnels du developpement avec unengouement sans precedent par rapport aux autres langages plus anciens.

1.1.3 Une machine virtuelleLe langage Java est un langage compile et interprete. Cette definition contra-

dictoire sexplique par le fait que le code source est transforme dans un byte-codeuniversel executable par une machine virtuelle. Cette machine virtuelle peut etreinstallee a` partir dune distribution du langage comme le Java Development Kit(JDK) de SUN. Elle peut etre egalement integree sous une forme compactee dansun navigateur afin quil puisse executer des applets Java.

Ces caracteristiques confe`rent au langage des proprietes de portabilite sansprecedents, mais ont aussi un cout correspondant au fonctionnement de la machinevirtuelle qui reduit les performances dexecution du programme. Afin de resoudrece proble`me, un effort important est consenti pour developper des compilateursa` la volee en code machine qui fonctionnent lors de lexecution du programme(compilateurs identifies sous la denomination de JIT - Just In Time).

1.1.4 CaracteristiquesLe langage Java posse`de une syntaxe inspiree du C++. Il se veut plus propre

en terme de developpement objet, ne permettant pas de construction en dehors desclasses. Il se veut aussi plus simple en affranchissant le programmeur de toute lagestion dynamique des objets construits, grace au fonctionnement dun ramasse-miettes (Garbage Collector) dont la fonction est didentifier et deliminer tous lesobjets qui ne sont plus references.

Java propose des executions paralle`les de programmes grace a` une utilisationqui se veut plus facile des threads (ou processus legers) par rapport au langageC. Il posse`de egalement des aspects lies a` la distribution grace a` ses possibilitesdintegration dans des documents Web distribues par les applets, mais egalement


avec la bibliothe`que RMI (Remote Methods Invocation) qui propose de la pro-grammation dobjets repartis. Levolution de cette bibliothe`que la fait convergerprogressivement vers CORBA, le standard dans le domaine des objets repartis.Les bibliothe`ques CORBA sont aujourdhui integrees dans les distributions duJDK 1.2 ou superieures de SUN.

Dans cet ouvrage ou` Java sert de langage elementaire dimplementationde methodes numeriques, les threads et la programmation en objets distribuesne seront pas utilises. Le parallelisme et la programmation distribuee sontindeniablement des apports recents et majeurs en calcul scientifique et ferontcertainement lobjet douvrages specifiques complementaires a` celui que nouspresentons ici.

1.2 Types primitifs et structures de controle

1.2.1 Types primitifsComme tout langage de programmation evolue, Java posse`de un certain

nombre de types de donnees de base : le type boolean qui prend une des 2 valeurs true ou false sur 1 octet ; le type char qui correspond a` un caracte`re sur 2 octets ; les types byte, short, int et long qui sont 4 types dentiers stockes

respectivement sur 1, 2, 4 et 8 octets ; les types float et double qui sont 2 types de flottants stockes respecti-

vement sur 4 et 8 octets.Les declarations de telles variables peuvent se faire nimporte ou` dans le code

mais avant leur utilisation, comme en C++.On utilise les operateurs usuels sur les variables de ces types avec la syntaxe

du C.

1.2.2 Structures de controleCe sont essentiellement les memes constructions quen C, a` savoir Laffectation qui se fait par loperateur = et qui consiste a` recopier la valeur

de la variable primaire a` droite du symbole dans la variable situee a` gauche. Les structures conditionnelles :

if (cond) instruction1; [else instruction2;] switch (selecteur) case c1 : instructions1;...

case cn : instructionsN;


default : instructionsNP;

Les structures repetitives ou boucles : for (initialisation; condition; instructionDe-Suite),

while (condition) instruction; do instruction; while (condition).

1.3 Classes et objets en Java1.3.1 Definition dune classe

Une classe permet de definir un type dobjets associant des donnees et desoperations sur celles-ci appelees methodes. Les donnees et les methodes sont ap-peles composants de la classe. Lexemple de base decrit dans un paragraphe sui-vant permettra de definir une classe Vecteur representant des vecteurs au sensmathematique. A chaque vecteur, seront rattaches :

une structure de donnees - un tableau - pour le stockage de ses coefficients ; des traitements comme les suivants,

son addition avec un autre vecteur, son produit scalaire avec un autre vecteur, ...

et aussi son procede de creation.

1.3.2 Declaration, creation et destruction dobjetsPour manipuler un objet (par exemple, un vecteur particulier de la classe

Vecteur), on doit tout dabord declarer une reference sur la classe correspon-dant au type dobjet. Cette operation permet de reserver en memoire une adressequi referencera lobjet. Par exemple, pour declarer un objet x de type Vecteuron ecrira :

Vecteur x;

Pour que cet objet soit reellement construit, cest a` dire que la referencedesigne un emplacement a` partir duquel on pourra acceder aux caracteristiques delobjet, on devra appeler loperation new qui alloue cet emplacement en memoireet le renvoie a` la reference de lobjet. On dispose alors dune nouvelle instance delobjet. Par exemple, pour la construction effective de notre vecteur x, on ecrira :

x = new Vecteur();


Cette instruction fait appel a` un procede de construction dobjets, appeleconstructeur, qui est defini par defaut, mais qui peut aussi etre redefini commeoperation dans la classe Vecteur. Si cette instruction de construction nest paseffectuee, la reference associee a` x est initialisee par defaut a` NULL, qui est uneadresse fictive ne pointant vers aucun emplacement memoire reel.

Par ailleurs, si lon a besoin de referencer lobjet courant dans la definition dela classe, cette reference se fait par le mot reserve this qui vaut donc ladressede lobjet courant dans une instance de la classe.

La destruction des objets est pris en charge par le Garbage Collector, appeleencore ramasse-miettes dans sa denomination francisee. Cet outil logiciel fonc-tionne en meme temps que le programme, il recherche, identifie et supprime de lamemoire les objets qui ne sont plus referencables.

On peut toutefois ajouter a` chaque classe un service finalize(), quisera appele au moment de la destruction de lobjet, sil est utile deffectuer desoperations specifiques a` cet instant.

Comme nous lavons indique precedemment, le nom dun objet permet dedefinir une reference, cest a` dire une adresse. Il est alors possible de faire uneaffectation entre deux objets de meme nature. Une telle operation va donc reco-pier ladresse de lobjet affecte. Ainsi une affectation est notablement differentelorsquelle se fait entre des variables de type simple (int, char, double, ...) ou entredes objets.

Le passage de parame`tres dans les fonctions se fait par valeur, comme en C.Ainsi, soit le parame`tre est de type simple alors on recopie sa valeur dans celui dela fonction appelee, soit cest un objet, on recopie alors ladresse referencee parlobjet (qui est bien sa valeur) dans celui de la fonction appelee.

1.3.3 TableauxUn tableau va permettre de stocker un certain nombre delements de meme

type dans une structure de donnees qui dispose dun index pour y acceder. Untableau en Java est un objet a` part entie`re.

Par exemple, un tableau monodimensionnel de flottants de type double seradeclare de la manie`re suivante :

double monTableau[];

ou encore

double[] monTableau;

Comme nous lavons explique precedemment, cette declaration a permis daf-fecter une reference au nom du tableau une reference (cest a` dire une adresse,


initialisee par defaut a` NULL). Pour construire effectivement le tableau, cest a`dire disposer de plusieurs emplacements memoire, par exemple 10, qui lui sontpropres, on invoque loperation de construction dobjets suivante :

monTableau = new double[10];

Ces deux instructions de constructions peuvent secrire en une seule fois :

double[] monTableau = new double[10];

Il est egalement possible dinitialiser la construction en affectant un tableauconstant de la manie`re suivante :

double[] montableau = {0.0, 1.1, 3.5};

Les tableaux en tant quobjets proposent un certain nombre doperations, no-tamment ils posse`dent une donnee propre length qui renvoie la taille du tableau.

Par exemple, les instructions suivantes permettent dafficher le contenu dutableau precedent, en utilisant la methode1 daffichage standard sur lecranSystem.out.print2 :

for (int i=0; i


Le premier constructeur construit un vecteur dont le nombre de composantsest donne en parame`tre.

Le second constructeur construit un vecteur en recopiant un tableau passeen parame`tre.

Par lintermediaire de ces deux constructeurs, il est ainsi possible de definirdes methodes de meme nom, a` condition quelles diffe`rent au niveau du type oudu nombre de parame`tres ou de leur resultat renvoye. On parle alors de surchargede methodes.

On definit differentes methodes : elt renvoyant la valeur de sa composante dont lindice est donne en pa-

rame`tre ; toElt permettant de modifier la composante dont lindice et la nouvelle

valeur sont passes en parame`tres ; dim renvoyant la taille du vecteur ; afficher affichant les valeurs de ses composantes ; add renvoyant un vecteur qui est la somme du vecteur courant avec le vec-

teur passe en parame`tre ; prodScalaire renvoyant le produit scalaire du vecteur courant avec le

vecteur passe en parame`tre.Cet exemple permet dillustrer la facon dont on acce`de aux composants de

lobjet courant, en invoquant simplement leur nom, mais aussi la facon dont onacce`de aux composants dun objet exterieur, en invoquant le nom de la compo-sante precedee dun point et du nom de lobjet en question.

Lecriture de la classe Vecteur est la suivante,

class Vecteur {double[] composant;

// constructeursVecteur(int dim) { composant = new double[dim]; }

Vecteur(double tableau[]) { composant = tableau; }

// acces a la composante idouble elt(int i) { return composant[i]; }

// modification de la composante ivoid toElt(int i, double x) { composant[i] = x; }

// renvoie sa taillaint dim() { return composant.length; }


// affiche ses composantesvoid afficher() {for (int i=0; i


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 executer le programme serontdecrites au paragraphe 1.4.2. Le programme gene`re alors laffichage suivant a`lexecution :

premier vecteur :1.0 2.0 3.0deuxieme vecteur :5.5 7.5 9.5leur somme vaut :6.5 9.5 12.5leur produit scalaire vaut : 49.0

1.3.5 Composants de type staticIl est possible de definir des composants4, donnees ou methodes, qui ne sont

pas rattaches de manie`re propre a` chaque objet instancie, cest-a`-dire a` chaqueinstance de la classe, mais qui sont communs a` toutes. Pour cela il suffit de declarerle composant avec le qualificatif static.

Par exemple, on peut ajouter a` la classe vecteur une donnee entie`re qui vacompter le nombre dobjets de la classe qui ont ete instancies. On peut egalementremplacer la methode add par une methode qui est static et qui prend 2 objetsVecteur en parame`tres : on redonne a` lecriture de cette fonction une apparencede symetrie sur ses arguments correspondant a` la propriete de communtativitede laddition. Ci-dessous nous avons partiellement reecrit la classe Vecteur enprenant en compte ces modifications.

class Vecteur {double[] composant;static int nb =0;

// constructeurs4voir 1.3.1


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 parametrestatic Vecteur add(Vecteur x, Vecteur y) {vecteur w = new vecteur(x.dim());for (int i=0; i


au tableau composant interne a` la classe. Ainsi nous declarerons public lesdeux fonctions elt et toElt mais private le tableau composant.

Linteret de separer ainsi les parties publiques des parties privees est de garan-tir une evolutivite possible des classes, sans avoir a` modifier les programmes quiles utilisent, a` partir du moment ou` lon conserve leur interface publique. Ainsila classe vecteur pourra utiliser des types de structures de donnees autres quedes tableaux pour stocker ses composantes. On pourra par exemple, utiliser unstockage directe sur fichier (pour des vecteurs de dimension importante) ou en-core un stockage specifique pour des structures creuses (en ne stockant que lescoefficients non nuls et leur position). Il suffira alors de redefinir correctement lesdeux fonctions dacce`s en lecture (elt) et en ecriture (toElt) en respectant leurmode dappel. Tous les programmes utilisant des classes vecteurs nauront alorspas lieu de subir la moindre modification pour pouvoir utiliser ces nouveaux typesde vecteurs.

La classe vecteur pourra alors etre partiellement reecrite avec des parties pu-bliques et privees, comme ci-dessous :class Vecteur {

private double[] composant;static int nb =0;

// acces a la composante ipublic double elt(int i) { return composant[i]; }

// modification de la composante ipublic void toElt(int i, double x) { composant[i] = x; }

...

}

Lutilisation de ces fonctions nest pas affectee par ces declarationssupplementaires : on introduit simplement des limitations aux composants commedecrit precedemment.

Il est a` noter quen nindiquant ni public ni private, les composants sontconsideres comme etant definis public par defaut, sauf si lon se trouve dansun autre package que celui de la classe consideree - nous reviendrons sur cettenuance dans le paragraphe 1.4.3.

1.3.7 Chanes de caracte`resLes chanes de caracte`res en Java sont des objets, instances de la classe

predefinie String, et elles referencent des chanes constantes. On pourra les


declarer comme dans lexemple suivant :

String ch1 = new String("bonjour");ou encore, sous une forme condensee qui est specifique au type String :

String ch1 = "bonjour";La chane "bonjour" est ici constante mais ch1 peut etre reaffectee pour

referencer une autre chane constante, comme dans lexemple suivant :

String ch2 = "au revoir";ch1 = ch2;

Lensemble des methodes de la classe String peut etre obtenu en consultantla documentation de lAPI (Application Programming Interface) associee au JDKutilise. Cette documentation, au format HTML, se reve`le insdispensable dans lapratique, pour pouvoir acceder aux descriptions des interfaces des nombreusesclasses proposees dans Java. Toutefois nous allons examiner quelques unes desmethodes les plus utiles relatives a` la classe String :

La methode static String valueOf(int i) renvoie une chanecontenant la valeur de i. Cette fonction existe aussi pour des parame`tres detous les types primaires. Notons que cest une methode statique qui sap-pelle, par exemple, de la manie`re suivante : String.valueOf(12) etqui retourne ici la chane 12.

La methode boolean equals(String s) compare le contenu de lachane courante avec la chane s.

La methode String concat(String s) renvoie la concatenation dela chane courante (celle qui va prefixee la fonction concat) et de s. Ilfaut noter toutefois que les concatenations de chanes peuvent se faire sim-plement avec loperateur +, comme on peut le remarquer dans les appels dela fonction daffichage dans certains des exemples qui prece`dent.

La methode int length() renvoie la longueur de la chane courante. La methode int indexOf(int c) renvoie la position de la premie`re

occurence du characte`re de code ASCII c. Elle renvoie -1 si ce caracte`renapparat pas.

La methode char charAt(int i) renvoie le caracte`re a` la position i.Nous avons vu que les objets String referencent des chanes constantes.

On peut, en fait, travailler avec des chanes modifiables, en utilisant des objetsde la classe predefinie StringBuffer dont on va decrire, sommairement, lesmethodes essentielles. La` encore, pour plus dinformations, on consultera la do-cumentation en ligne de lAPI.

Les differents constructeurs de la classe StringBuffer sont :


StringBuffer() permettant de creer une chane vide ; StringBuffer(int dim) permettant de creer une chane de longueurdim ;

StringBuffer(String s) permettant de creer une chane contenants.

Les principales methodes de la classe StringBuffer sont : int length() renvoyant la longueur de la chane ; StringBuffer append (String s) ajoutant s a` la fin de la chane

courante ; String toString() renvoyant dans une chane constante la chane

modifiable courante.

1.4 Organisation des fichiers sources dun pro-gramme Java

1.4.1 Structure des fichiers sourcesUn programme Java correspond a` une collection de classes dans un ou

plusieurs fichiers sources dont lextension est "java". Lun de ces fichiersdoit contenir une classe qui implemente la methode public static voidmain(String args[]), comme cela est fait dans lexemple precedent deconstruction de la classe vecteur et de son programme de test.

1.4.2 Commandes de compilation et de lancement dun pro-gramme

Pour compiler et executer les programmes java on utilise les outils fournis avecle JDK. On commence par lancer la compilation des fichiers avec la commandejavac. Par exemple, pour les deux fichiers relatifs a` notre classe vecteur et a` sonprogramme de test, on ecrira :

javac Vecteur.javajavac TestVecteur.java

Deux fichiers : Vecteur.class et TestVecteur.class ont etegeneres et correspondent aux noms de toutes les classes definies dans les fichierssources. Ce sont des fichiers en byte-code portables sur toute machine devant etretraites par la machine virtuelle java lancee par la commande java. On executedonc le programme principal, qui est dans la classe TestVecteur, en tapant lacommande :


java TestVecteur

1.4.3 PackagesUn package permet de regrouper un ensemble de classes. Linstruction

package nomPack en debut de fichier indique que les classes qui y sontdefinies appartiennent au package nomme nomPack. Pour acceder aux classesde ce package, lorsque lon est dans une classe qui ny appartient pas, on utilisela denomination nomPack.className, ou` className designe le nom de laclasse.

Les designations de package suivent un schema de construction arborescentdu type : name.subname.subsubname. Il existe un lien entre les noms depackage et les repertoires ou` se trouvent les classes y appartenant . Par exemple,une classe watch appartenant au package time.clock doit se trouver dans lefichier time/clock/watch.class.

Les repertoires ou` Java effectue sa recherche de packages sont definis dans lavariable denvironnement : CLASSPATH.

Linstruction import packageName permet dutiliser des classes du pa-ckage defini, sans avoir besoin de les prefixer par leur nom de package. On peutimporter toutes les classes dun package en utilisant un import du type importpackageName.*;, mais, ATTENTION, limport dun niveau de package nepermet pas dimporter les packages qui sont en-dessous dans larborescence desrepertoires.

Voici un exemple dillustration qui montre une organisation de classes java,dans differents repertoires et leur utilisation.

La variable denvironnement CLASSPATH doit etre dans le fichier.profile ou dans .bashrc, par exemple, sous Unix, de la manie`re suivante :

CLASSPATH = /myJavaClass

Voici maintenant des extraits de differents fichiers ranges dans les repertoiresindiques :

le fichier /myJavaClass/bibMat/calVecteur/Vecteur.java correspond a`package bibMat.calVecteur;public class Vecteur { ... }

le fichier /myJavaClass/bibMat/calMatrice/Matrice.java correspond a`package bibMat.calMatrice;public class Matrice { ... }

le fichier /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);...

}}

1.4.4 Visibilite des composants dans les packagesOn a vu precedemment que laccessibilite des composants dune classe se fait

grace aux qualificatifs private ou public. En fait, elle est egalement lieeaux localisations dans les packages. Ainsi, lorsquun composant ne precise pas sanature (private ou public) alors il est, par defaut, public dans les classesdu package (ou du repertoire) 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 acceder a` xa et xc. Par contre C3 ne peutacceder qua` xa uniquement.

1.4.5 packages predefinis en JavaLe langage Java posse`de un grand nombre de packages predefinis regroupes

par the`mes. Ces packages et les classes quils contiennent sont decrits de manie`reexhaustive dans une documentation fournie par Sun et qui reprend lensemble desinterfaces. Cette documentation est appelee API (Application Programming Inter-face) et est distribuee sous un format HTML, permettant ainsi une navigation hy-


pertexte particulie`rement adaptee aux recherches dinformations necessaires pourle developpement de programmes. On y trouve principalement :

java.lang qui correspond aux classes de base (chanes, math, ...), java.util qui correspond aux structures de donnees (vector, piles, files,

...), java.io qui correspond aux entrees/sorties, java.awt qui correspond au graphisme et fenetrage, java.net qui correspond aux communications Internet, java.applet qui correspond aux insertions dans des documents HTML.

1.5 Heritage

1.5.1 Construire une classe deriveeLa notion dheritage est importante en programmation objet. Elle permet de

definir une classe derivee a` partir dune autre classe dont on dit quelle herite. Laclasse derivee posse`de alors, par defaut, lensemble des composants de la classedont elle herite - on lappelle classe me`re - sauf si des restrictions ont ete poses surces composants. Lheritage est donc un concept essentiel renforcant les proprietesde reutilisabilite des programmes objets.

Lutilisation repetee de lheritage sur des classes successives conduit a` laconstruction dune hierarchie entre elles, que lon peut schematiser par un arbredheritage. La figure 1.1 presente un exemple darbre dheritage construit sur desclasses permettant de representer des figures geometriques.

Figure

Polygone Cercle

RectangleTriangle

FIG. 1.1: Arbre dheritage de classes dobjets geometriques

La construction effective des differentes classes de la figure 1.1 est faite danslexemple complet du paragraphe 1.5.5.

Pour definir une classe ClB qui derive de la classe ClA, on fera une declarationdu type :


class ClB extends ClA { ... }

Un objet de la classe ClB est alors aussi un objet de la classe ClA, il peut etreutilise partout ou` un objet de la classe ClA est attendu.

On peut tester lappartenance dun objet a` une classe grace a` loperateurinstanceof, comme dans lexemple qui suit :

ClB x;if ( x instanceof ClA)

System.out.println(voici un objet ClA !);

Lexecution des lignes precedentes provoque laffichage de voici unobjet ClA!.

1.5.2 Constructeur dune classe deriveeSi lon definit un constructeur dune classe derivee, celui-ci doit explicitement

faire appel a` un constructeur de la classe me`re, auquel on acce`de avec la methodepredefinie super( ... ). Si cet appel explicite nest pas fait, lexecution duprogramme provoquera un appel implicite du constructeur par defaut, cest a` diresans parame`tre, de la classe me`re ; il faut donc imperativement que celui-ci existesinon une erreur de compilation sera diagnostiquee. Ainsi, si lon a defini un oudes constructeurs dans la classe me`re, une de ses versions devra etre sans pa-rame`tre.

Lappel explicite du constructeur de la classe me`re se fait par la methodepredefinie super( ... ), cet appel est obligatoirement la premie`re instruc-tion du constructeur. On ne peut donc transmettre que des valeurs de parame`tresdu constructeur courant lors de lappel de super( ... ).

On retrouve de telles constructions dans lexemple du paragraphe 1.5.5 ou` laclasse Figure posse`de un composant de type Point correspondant a` son ori-gine et pouvant etre initialise par le parame`tre x du constructeur Figure(Pointp). On definit la classe Cercle derivant de Figure, dont le constructeur estdefini par :

Cercle (Point centre, double r){ super(centre); ... }

1.5.3 Accessibilite : public, protected et privateOn a vu precedemment que les composants dune classe pouvaient etre

eventuellement qualifies des termes public ou private. Il existe, en fait, un


troisie`me qualificatif protected qui indique que ce composant est accessibleuniquement dans les classes derivees et les classes du meme package.

Par exemple, soit la classe ClA definie de la manie`re suivante :package aa;public class ClA {

protected int JJ;...

}

et la classe ClB definie ainsi :

package bb;import aa.*;class ClB extends ClA {

void PP() {JJ++; // autoriseClB b;b.JJ++ // autoriseClA a;a.JJ++ // interdit

}}

1.5.4 Methodes virtuelles et classes abstraitesUne classe peut annoncer une methode sans la definir, on dit alors que la classe

est abstraite. Elle doit etre introduite avec le mot cle abstract.Par exemple, on peut definir la classe abstraite ClA suivante et une classe ClB

qui en derive.

abstract class ClA {abstract void fctP() ;void fctQ() { ... };...

}class ClB extends ClA {

void fctP() { ... };...

}

En raison de sa definition incomple`te, il est impossible dinstancier une classeabstraite qui ne sert qua` la construction de classes derivees. Ces dernie`res devrontredefinir toutes les methodes abstraites, pour ne pas letre elles-memes et pouvoirainsi etre instanciees.


1.5.5 Un exemple : quelques objets geometriquesNous donnons un exemple dimplementation des differentes classes decrites

sur la figure 1.1. Nous commencons par definir une classe Point qui servira dansles 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 definissons ensuite une classe abstraite pour definir le type Figureconstitue de deux methodes abstraites daffichage et de calcul de perime`tre :

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 derive de la classe Figure en implementant sesdeux methodes 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");


System.out.println("rayon : " + rayon +" et centre : " +"(" + origine.abscisse +"," + origine.ordonnee + ") ");

}}

La classe Polygone derive de la classe Figure. Elle se caracterise par untableau 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


Triangle(Point[] m) { super(m,3); }}

La classe Rectangle derive de la classe Polygone. Elle est definie avecses caracteristiques mathematiques classiques, cest a` dire la longueur de ses coteset un de ses sommets, le sommet inferieur gauche. On a alors une bonne illustra-tion de lutilisation des constructeurs successifs des classes derivees. Pour ap-peler le constructeur de Polygone qui posse`de le tableau de ses sommets enparame`tres, il faudrait tout dabord faire la construction de ce tableau a` partir descaracteristiques de Rectangle, ce qui nest pas possible, car lappel de superdoit etre la premie`re operation. Il faut donc utiliser le constructeur par defaut dansla classe Polygone qui sera appele au debut de lexecution du constructeur deRectangle. 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 superPoint 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");

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());

}}

Lexecution du programme affiche :

java Geometrieperimetre cercleCerclerayon : 2.0 et centre : (3.0,4.0)perimetre : 12.566368Polygone(4.0,4.0) (9.0,4.0) (9.0,6.0) (4.0,6.0)perimetre : 14.0Polygone(0.0,0.0) (1.0,0.0) (0.0,1.0)perimetre : 3.414213562373095

1.5.6 InterfacesUne interface, en Java, permet de decrire un mode`le de construction de classe

dans lequel on nindique uniquement que les en-tetes des methodes. Cela equivaut,dune certaine manie`re, a` une classe ou` toutes les methodes sont abstraites.

On dira quune classe implemente une interface, si elle redefinit toutes lesmethodes decrites dans cette interface.

Par exemple, on definit un mode`le de proble`me par une interface qui comportedeux methodes poserProbleme et resoudreProbleme :


interface AResoudre {void poserProbleme();void resoudreProbleme();

}

On peut alors construire une classe equationPremierDegre quiimplemente 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 interet des interfaces provient de la limitation de Java en termedheritage multiple. En effet, Java ne permet pas quune classe derivee puisseavoir plusieurs classes me`res et donc de beneficier des composants definis dansces differentes classes. Pour pallier cette limitation, on devra utiliser conjoin-tement lheritage et limplementation dinterfaces. Il est, par ailleurs, possibledimplementer plusieurs interfaces en Java, contrairement a` lheritage.

1.5.7 Passage dune fonction en parame`tre dune methodeNous nous interessons au proble`me du passage dune fonction en tant que

parame`tre dans une methode. Par exemple, on souhaite decrire dans une classe unprocede qui approche le calcul dune derivee dune fonction reelle dune variablereelle par un taux daccroissement :

!#"#%$&'$&!#"(

Nous allons montrer comme ce procede peut etre decrit dune manie`re generique,cest a` dire en utilisant une fonction abstraite

, parame`tre du procede. Onapplique alors ce procede de derivation numerique a` une fonction particulie`re enla transmettant par lintermediaire de ce parame`tre.

Dans beaucoup de langages, comme le C ou le C++, le passage dune fonc-tion en parame`tre seffectue en gerant un pointeur qui contient ladresse effectivedu code de la fonction. Le langage Java ne proposant pas de gestion explicite depointeur, on doit alors creer une enveloppe de type objet contenant une methode


correspondante a` levaluation de la fonction. Cest cette classe enveloppe qui cor-respond au parame`tre a` gerer.

Il faut donc commencer par definir une classe abstraite, ou une interface, quidecrit les fonctionnalites minimales de la classe correspondant au parame`tre fonc-tionnel.

Nous donnons un exemple qui sappuie sur lutilisation dune interface mi-nimale caracterisant une fonction reelle dune variable reelle. Les nombres reelssont implementes par le type double :

interface FoncD2D { public double calcul(double x); }

Nous pouvons alors utiliser cette interface pour decrire un procede generiquede calcul de derivation numerique, comme decrit 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 procede, il suffit maintenant de definir une fonction particulie`redans une classe qui implemente 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 classeFoncCarre qui permet dutiliser la fonction particulie`re qui y est definie. Ilconstruit aussi un objet de la classe DiffFinies qui permet dutiliser le procedede derivation numerique qui est invoque sur lobjet de type FoncCarre, reconnucomme une implementation de FoncD2D :

class TestDiffFinies {public static void main (String args[]) {

FoncCarre f = new FoncCarre();DiffFinies df = new DiffFinies();System.out.println ("Differences finies dordre un "+

"en 1 de pas 0.01 : "+df.derivOrdre1(f, 1, 0.01));

}}

Le resultat de lexecution est :


java TestDiffFiniesDifferences finies dordre un en 1de pas 0.01 : 1.9999999999999685

1.6 Exceptions

1.6.1 Notions generalesLintroduction de la notion dexception dans un langage de programmation

a pour but de simplifier le traitement de certaines situations. Ces dernie`res sontconsiderees comme exceptionnelles, au sens ou` leur detection necessite de lesgerer, en les sortant du contexte dans lequelle elles sont detectees.

Dans les langages ne gerant pas specifiquement ces situations dexception, ilest necessaire dutiliser de nombreuses instructions conditionnelles successives,afin de reorienter le deroulement du programme de manie`re adequate. De telsprocessus peuvent conduire a` une complexite du programme dont la lecture finitpar salourdir.

Certains langages proposent de manie`re facultative lutilisation des exceptions(cest le cas du C++). Avec Java, on a lobligation de les gerer lorsque certainsappels de methodes sont succeptibles, de par leur conception, de declancher destraitements dexception.

Une gestion dexception est caracterisee par une sequence

try - Catch - finally

qui correspond typiquement au deroulement suivant :

try {//sequence succeptible de declancher une exception...

}catch (classException e1) {

//traitement a` effectuer si e1 a ete declanchee...

}catch ( ....) { ... } //autre declanchement eventuelfinally {

//traitement effectue avec ou sans declanchement dexception...

}

Nous donnons ci-dessous un exemple de programme qui recupe`re les argu-ments fournis au lancement du programme. Il calcule et affiche la moyenne de ces


arguments lorsque ce sont des entiers. Il declanche un traitement dexception silun 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


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


aucune note !

1.7 Entrees/Sorties1.7.1 Classes de gestion de flux

Dans le langage Java, deux types dentrees/sorties sont utilisables : Les entrees/sorties traditionnelles, cest-a`-dire utilisant les flux de commu-

nications par defaut, a` savoir le clavier ou lecran, ou encore les fichiers ; Les entrees/sorties basees sur des interactions avec un syste`me de fenetrage.

Celles-ci seront developpees dans le chapitre sur le graphisme.Nous presentons, dans la suite, des notions basees sur lAPI 1.1 et qui ont ete en-richies significativement par rapport aux versions precedentes. Les raisons de cesenrichissements sont principalement dues a` des questions defficacite et a` la pos-sibilite dutiliser des codes internationaux (UNICODE) qui enrichissent le codeASCII avec des caracte`res accentues, entre autres.

Les principales classes de gestion de flux sont organisees suivant la hierarchiedheritage decrite dans la figure 1.2.

InputStreamReader

BufferedReader

BufferedWriter

PrintWriter

OutputStreamWriter

Reader (abstract)

Writer (abstract)

FileReader

FileWriter

Object

FIG. 1.2: Hierarchie des classes de gestion de flux

Dans cette hierarchie, les classes suivantes apparaissent : La classe Object qui est la classe de base en Java, dont toutes les autres

heritente ; Les classes abstraites Reader et Writer qui concernent respectivement

les flux de caracte`res pour les lectures et les ecritures ; Les classes InputStreamReader et OutputStreamWriter qui per-

mettent de faire la traduction des donnees brutes en caracte`res UNICODEet inversement ;


Les classes BufferedReader et BufferedWriter qui permettentlutilisation dune memoire tampon pour les entrees-sorties. Cette memoireest indispensable pour lutilisation des peripheriques standards (ecran et cla-vier) ;

Les classes FileReader et FileWriter qui permettent lutilisation defichiers ;

La classe PrintWriter qui permet lecriture de donnees formattees sem-blables aux affichages a` lecran.

Cette liste nest pas exhaustive mais correspond aux principales classes quenous serons amenes a` utiliser dans la suite.

1.7.2 Saisies au clavierPour effectuer une saisie au clavier, on construit successivement : Un flux InputStreamReader avec le flux de lentree standard, a` savoirSystem.in ;

Un flux de lecture bufferise de type BufferedReader a` partir du fluxprecedent.

On presente, ci-apre`s, un exemple typique de lecture au clavier. Dans cetexemple, on lit dans le flux bufferise avec la methode readLine() permet-tant la lecture dun chane de caracte`res jusqua` ce que lon rencontre un sautde ligne. La chane de caracte`re est alors convertie en entier, avec la methode() parseInt, ou en flottant, avec un construction plus complexe qui utilisela methode floatValue(), sur lobjet de la classe Float obtenu en appelantvalueof(). Cette dernie`re methode est statique et a pour parame`tre la chanelue. Il faut noter qua` partir du JDK 1.2, on pourra plus simplement appeler lamethode parseFloat(), similaire a` parseInt().

On remarquera que, dans cet exemple, il est necessaire de gerer ledeclanchement eventuel dexceptions peuvant se produire,

soit par un proble`me de lecture de flux qui provoque le declanchement delexception IOException ;

soit par un proble`me de conversion de chane de caracte`res en valeurnumerique 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("reel lu : " + f);

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"); }

}}

Laffichage obtenu a` la suite de lexecution du programme est le suivant :

java Testiotaper 1 ligne de caracteres : java sait lireligne lue : java sait liretaper 1 nombre entier : 3entier lu : 3taper 1 nombre reel : 12.5reel lu : 12.5somme des deux nombres : 15.5

1.7.3 Lecture dun fichierUne lecture dans un fichier est effectue dans le programme suivant. Il est si-

milaire au precedent avec, toutefois, quelques differences : FileReader est la classe instanciee pour construire le flux dentree a`

partir du nom du fichier. Cette instanciation pourra declancher lexceptionFileNotFoundException, si le fichier nest pas trouve.

La methode close() ferme le fichier.


On utilise une boucle qui detecte la fin de fichier, suite au resultat dunelecture 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 execute le programme precedent avec le fichier "donnee.dat" suivant :


2.31.23.42.15.2

Laffichage, produit par le programme, est alors le suivant :

java Testfilenombre lu : 2.3nombre lu : 1.2nombre lu : 3.4nombre lu : 2.1nombre lu : 5.2Moyenne : 2.84

1.7.4 Ecriture dans un fichierLe programme suivant va utiliser un fichier dans lequel on ecrit. On construit

un flux de type FileWriter, utilise dans un tampon decriture (de typeBufferedWriter). Un flux, de type PrinterWriter, permet alors def-fectuer des ecritures formattees avec la methode println, comme on le faitcouramment sur la sortie standard, cest-a`-dire lecran.

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 ComplementsIl est possible de lire et decrire des donnees brutes (donc non formattees) avec

les classes DataInputStream et DataOutputStream. Les fichiers, ainsiconstruits, ne sont pas lisibles directement sous un editeur de texte, par exemple,mais leur taille est plus reduite.


La classe StringTokenizer est une classe qui permet dinstancier un petitanalyseur de texte qui peut, par exemple, decouper des lignes en sous-chanes decaracte`res, en reconnaissant un certain nombre de separateurs (blancs, virgules,...).

La classe java.io.File permet de faire des manipulations de fichiers, si-milaires aux commandes dun syste`me dexploitation. Elle permet par exemple,de lister un repertoire, de renommer ou supprimer un fichier, etc.

1.8 Conclusion provisoireNous terminons ici cette introduction a` Java. Des complements seront donnes

au fur et a` mesure de leur besoin. On abordera la partie graphisme dans le chapitre4.

Chapitre 2

Resolution des equations nonlineraires dans )+*

Dans ce chapitre, on presente un resume de cours sur quelques methodes clas-siques de resolution numerique des equations non lineaires dans IR,

,

-/.

10

IR 2(2.1)

La generalisation aux syste`mes dequations non lineaires a` plusieurs variables( &0 IR 3 ) nest pas traite dans ce volume, (mais une introsduction en est donneesous forme dexercice, presente dans le chapitre 3, voir exercice 25) on pourraconsulter les references bibliographiques en fin de volume, par exemple, [?], ... .

Soit ,54 IR$76

IR une application continue, on se propose de trouver la (oules) solution(s) de lequation (2.1). Excepte quelques cas tre`s simples, par exemplepour les polynome de degre inferieur ou egal a` trois, les methodes analytiquesde resolution dequations ne permettent pas de resoudre de tels proble`mes. Lerecours aux methodes numeriques, fournissant des solutions approchees, devientalors incontournable.

2.1 Localisation (ou separation) des racinesLa plupart des methodes numeriques supposent que lon connaisse un inter-

valle contenant la racine cherchee et aucune autre. On dit alors quelle est localiseeou separee, des autres eventuelles racines.Les deux methodes les plus classiques pour localiser ou separer les racines sont :

1. Letude des variations de , , puis lutilisation du theore`me de la valeur in-termediaire.

38


2. La reecriture de lequation ,

8- sous la forme,9

,

, puis larecherche de(s) point(s) dintersection des courbes representatives de ,:9 etde ,

. Le proble`me sera plus simple a` traiter si lune des deux fonctions etlidentite. La solution cherchee correspond alors a` un point fixe de lautrefonction. Voir ci-dessous.

Remarque 1 : On supposera dans la suite que , est continue et que la racine

est localisee dans un intervalle borne [a,b].

2.2 Methode des approximations successivesDans cette methode, on construit a` partir de lequation a` resoudre, la suite

;

3=

3

.

@

choisi dans ACBD.FEHGI.(2.2)

dans lespoir quelle tende vers la solution

du proble`me. La limite de cette suiteverifie

J>

.

Definition 1 . Soit > 4 IR$6

IR, un point fixe de > est un reel solution delequation

J>

.

Lequation,

K- peut secrire, sous la forme

L>

. On peut choisir parexemple

>

,

MN

2(2.3)

Ainsi, resoudre ,

O- revient a` trouver les points fixes de >

.

Exemple 1 . Soit lequation,

$PQ$NR:SUTV

O-/.

elle peut secrire, sous la forme ?> avec >

$&RSWTV

,

>

YX

Z R:SUTV

,

>

O[]\_^a`cbd^aeWfhgi

.

ou` il faut choisir lecriture permettant la convergence du processus iteratif 3j

3

vers la solution cherchee, lorsque cette convergence est possible.


Exemple 2 . Soit lequation,

"kmlUTV$noqp#k=

-/.

les valeurs

sr

!#"tvu

r netant pas racines de ,

L- , on peut ecrire cetteequation, entre autres, sous la forme : > "%wFx]TM , sur un intervalleqy

zGWr

!("{u

r:.mr

!("&|uiP}~

rA qui isole une racine et sur lequel >

est definie,les racines de ,

- sont les points fixes de > .Definition 2 . Soit > 4 IR

$6

IR, sil existeu0

AC-.

}

A tel que, pour tous et elements de IR, on ait >

$

>

%

u

$

, alors on dit que > est contrac-tante (ou est une contraction) sur IR. Si linegalite est stricte, on dira que > eststrictement contractante.

u

est appele rapport de contraction.

Proposition 1 . Soit > une application derivable sur lintervalle ACBD.FEHG , si laderivee > verifie, B

^j] F U

>

us}

, alors > est strictement contractantedans AB.HEFG .

Le theore`me suivant fournit une condition suffisante de convergence du pro-cessus des approximations successives.

Theore`me 1 (du point fixe) . Soit > 4 IR $6 IR verifiant les conditions sui-vantes :

1.0

ABD.FEHG7V>

0

ACBD.FEHGI. (cest a` dire >VABD.FEHGMsACBD.FEHG )2. > est une application strictement contractante dans AB.HEFG , de rapport de

contractionu

,

alors pour tout@0

ACBD.FEHG la suite recurrente definie par,;

@0

AB.HEFG

3j

3

.

01

converge vers lunique solution

de

J>

, avec10

ACBD.FEHG . De plus, la formulesuivante donne une majoration de lerreur commise a` literation , lors du calculde

,

3

$

u

3

}$&u

9

$P@

2

Il est souvent delicat de determiner un intervalle ABD.FEHG dans lequel les hy-pothe`ses du theore`me du point fixe sont verifiees, cependant on a le resultat sui-vant.

Proposition 2 : Si > est derivable au voisinage dun point fixe , et si > 7 } ,alors il existe un voisinage

^

de

tel que pour tout@

dans ^

, les iterations,

3=

3

, convergent vers

.


Proposition 3 : Soit une solution de lequation J>

, si > est continue auvoisinage de

et si > 7

/

}

, alors pour toute condition initiale@

.

@

, lasuite definie par @ et

3=

3

ne converge pas vers

2

-

-

-

ICIIIIIIIIIIIIIIIIIIIII fin corrections faites le dim 11 nov 01 IIIIIIIIIIIIIIIIIIIci

Mettre ici la remarque ecrite dans lexo 5 vieille p :57

Remarque : Attention ...

-

-

-

Resume et Interpretation graphique :

On estime >

,

1. si >

}

, (figure 1), la suite ne converge pas vers , cest un pointrepulsif, les iteres successifs de la condition initiale @ (ou ceux de @ )seloignet de

, on elimine alors la methode.

2. si > 7

}

, (figures 2 et 3), la methode converge, est un point at-tractif, les iteres successifs de la condition initiale @ (ou ceux de @ ) serapprochent de plus en plus de

, (il faut alors determiner un intervalle AB.HEFGcontenant

, dans lequel B

^j( F U

>

}

et >

ACBD.FEHG

AB.HEFG ), deuxcas se presentent :

(a) -> i} , (figure 2),si@

la suite

3

est croissante, elle est decroissante sinon (casou` la condition initiale est

@ ). Dans les deux cas, elle tend vers .(b) $} > J- , (figure 3),

la suite

3

est alternee, deux iteres successifs de@

donnent unencadrement de

et la suite converge vers

.


x

x

xx

f(x)f(x)

y=x

x

f(x) y=x

x

y=x

x o x o x ox o x o

Figure 1. Figure 2. Figure 3.

(c) si > 7 } , cest un cas plus delicat car la methode peut converger(figure 4) ou non (figure 5) :

x

f(x)

y=x

xx

f(x)

y=x

x

Figure 4. Figure 5.

Dans la figure 4, les iteres successifs de@

convergent vers

si@

, et divergent dans le cas contraire. Dans le cas de la figure 5, ilsdiveegent quelque soit la position de

@

.

2.3 Ordre dune methodeUne methode iterative pouvant converger plus ou moins rapidement (voir les

figures 6 et 7), il existe des notions qui mesurent cette rapidite de convergence, etmesurent donc la diminution de lerreur [

3

3

$

dune iteration a` la suivante.

Definition 3 : La methode definie par @ et 3=

3

est dite dordre p si |H#

a une limite reelle strictement positive lorsque n tend vers

. On dit alorsque la methode a` un taux de convergence egal a` .


x-

x

f(x)

y=x

x-

x

f(x)

y=x

Figure 6. Figure 7.

Theore`me 2 : Si la suite

3

converge vers

et si > est suffisamment derivableau voisinage de

alors lordre de la suite

3

est le plus petit entier tel que :>

7

s==dv>

\ jb

9

e

7

- et >\ ae

7t

- . De plus on aSUlU

3=D\ ae

ou` [3

3

$

.

Ce theore`me donne une estimation de lerreur [3

a` la I

iteration.

Remarque 2 : Une methode est dite lineaire lorsquelle est dordre 1, on a alors>

O- . Elle est dite quadratique si elle est dordre 2.

Remarque 3 : Pour une methode dordre p, lorsquon passe dun itere a` lautre,le nombre de chiffres decimaux exacts est environ multiplie par p.

Tests darret des iterations.Si le processus iteratif converge, la solution

, etant la limite de la suite, ne peutetre atteinte quau bout dun nombre infini diterations. Par consequent lalgo-rithme sera arrete en utilisant lun des tests suivants, ou` designe la precision a`laquelle on souhaite obtenir la solution,

(i) 3

$P

3

b

9

d

(ii)

^

bd^

(+

^

(iii) > 3

, cest a` dire >

3

est presque nulle.Le processus sera considere comme non convergent, vers la solution cherchee,si la precision souhaitee nest pas atteinte au dela dun nombre raisonablediterations,

+^

, fixe a` lavance.

Remarque 4 En pratique, lorsque on cherche la racine

a`}

-

b

pre`s, lesiterations seront arretees lorsque deux iteres successifs

et

@

|Z ][HdS , alors

a

yz0

z

7.3 Methode de SimpsonDans cette methode on suppose que n est pair (soit n=2s), puis on subdivise

{_`Fu} en s sous intervalles egaux { \_^

yq`m\_^

y+} de longueur j , ( fgLjjjnN ), puison remplace Zc[]\td sur chaque intervalle { \_^

yq`m\_^

y+} non pas par une droite commedans les trape`zes, mais par une parabole ayant aux abscisses \_^

yq`m\_^

w

HM\_^

y lesmemes valeurs que Z ; cest a` dire par une interpolation quadratique sur ces troispoints. Le polynome

w

y dinterpolation en \_^

yq`m\_^

w

HM\_^

y est (voir chapitre 4) :w

y~[e\td g Z[e\_^

ymd

[e\\_^

yd[]\\_êd

)j

z

g Z[e\_êd

[e\\_^

ymd[]\\_^

ymd

^j

z

g Z[e\_^

ymd

[e\\_êd[]\\_^

ymd

)j

z

Dautre part la surface

^ delimitee par cette parabole, les droites \ gX\_^

y , \g

\_^

y et laxe des abscisses sobtient en calculant :

w

y[e\td\ dou` ;

^tg

j

[Zc[e\_^

yd

Zc[]\_êd

Z[e\_^

ydd


Ceci donne lapproximation de Simpson

de B , en sommant les aires

^ pourfgX a` l . Finalement :

g

j

{Zc[e\

d

Zc[e\Wz0d

_{Zc[]\kyd

Zc[]\Wbd

jjj

Zc[]\Wz0

yd"}

i{Zc[]\Wzqd

Zc[]\qd

jjj

Zc[]\Wz0

zbd"}}

cest a` dire :

g

j

{Zc[e\

d

Zc[e\Wz0d

F

y

Zc[]\Wz

yd

y

F

y

Zc[]\Wz

d"}

On demontre que lerreur

gB

commise par application de Simpson estdonnee par :

gU

[M d(j

/h

Z

[ed`B {W`uF}

Donc si `Rg=>@

|Z

[IHdS , alors

[M d

he

`

Remarque 7 En general la methode de Simpson donne une meilleure approxi-mation que celle des trape`zes, ( sous certaines conditions de regularite de Z , voirreferences ...), car lerreur commise lorsquon applique les trape`zes est propor-tionnelle a` j z , alors que pour Simpson elle est proportionnelle a` j , et comme parune transformation de la variable dintegration on peut toujours se ramener de{_`Fu} a` {hi`/~} et qualors j {hi`/} , on a donc j ]j z .

Remarque 8 Comparaison des erreurs :

Rectangles [N dmy(jTrape`zes

yz

z


Lidee de lalgorithme de Romberg est de prendre une combinaison lineaire deBo[qjWd et de Bt[

z

d qui donnera une meilleure approximation de Bt[hd , puis de recom-mencer avec Bt[

d , etc jjj .Prenons par exemple la methode des trape`zes on a Bt[hd g x

[rjWd ou`

x

gXg_Bt[rjWd designe lapproximation pour n subdivisions de {_`Fu} de longueurj .

Dans le cas ou` lon peut faire un developpement limite en j on a :

x

gBt[hd

iy(j

z

z


Une fois calcules ~ x

,

q

z

x

,

~

x

jjj , on a

F

y

x

g

z

+

z

y

la

\

\

ligne du tableau de Romberg donne des approximations de lintegralepour lesquels lerreur est en j z

; donc q x est plus precis que x pour , etdautre part ~ x est moins precis que ~ z x qui lest moins que ~ x , jjj .La precision augmente de haut en bas et de gauche a` droite du tableau, mais at-tention, pas necessairement sur les diagonales.

Remarque 9 . On remarque que dans la deuxie`me ligne du tableau de Romberg,oz

x

est exactement le resultat de la methode de Simpson.


7.5 Enonces des exercices corrigesExercice 50 :a) Donner les formules des rectangles approchant Bg

Zc[e\td\ .

b) Trouver lerreur commise en appliquant la methode des rectangles, ainsi que lenombre minimum l de subdivisions de {h`/} pour avoir y w

\ a` 1/100 pre`sc) Donner la methode des rectangles a` point milieu.d) Trouver lerreur commise en appliquant la methode des rectangles a` point mi-lieu. Meme application qua` la question b).

Exercice 51 :Determiner par le methode des trape`zes puis par celle de Simpson ^

Z[e\td&\ sur

la base du tableau suivant :

\ h |7 | |7 |7

Zc[e\td h hi77 h7hh hi77h

Ces points dappui sont ceux donnant \ , comparer alors les resultats obtenusavec la valeur exacte.

Exercice 52 :On lance une fusee verticalement du sol et lon mesure pendant les premie`res 80secondes lacceleration :

H~[

w

lnSd h h 8h h h 8h h 7h h

[

w

lo)n

z

d h i7 i hi i8 i7h 7hi

Calculer la vitesse V de la fusee a` linstant t=80 s, par les Trape`zes puis par Simp-son.

Exercice 53 :Calculer a` laide de la methode des Trape`zes lintegrale B g k[e\ z d&\ (avecN=5 puis N=10 points dappui).

Exercice 54 :Trouver le nombre N de subdivisions necessaires de lintervalle dintegration{2K`(k} , pour evaluer a` hih

pre`s, grace a` Simpson, lintegrale : B g~

)\\ .

Exercice 55 :Evaluer a laide de la methode des Trape`zes, lintegrale : `

\ , avec une

erreur inferieure a` h

.


Exercice 56 :Evaluer a laide de la methode des trape`zes puis celle de Romberg basee sur lestrape`zes, lintegrale :

y

y

y

\ , avec une erreur inferieure a` h

.

Comparer les vitesses de convergence. Comparer a` la valeur exacte .

Exercice 57 :Soit [e\td g H w

D

H . Combien faut-il de subdivisions de [0,1] pour evaluer[+Sd a /h

pre`s en utilisant1. la methode des trape`zes2. la methode de Simpson


7.6 Enonces des exercices non corrigesExercice 58 :Soit []\tdg H z w

D

H . Combien faut-il de subdivisions de [0,1] pour evaluer[+Sd a /h

pres en utilisant1. la methode des trape`zes2. la methode de Simpson

Exercice 59 :Utiliser la methode de Simpson pour approcher

y

?

)&?[v\td\ . en subdivisantlintervalle {hi`

} en egUh parties egales.

Exercice 60 :Pour evaluer [+Sd , ou` la fonction est donnee par []\tdKg m[Hd&)H , on integrele developpement de Taylor de mk[Hd ( qui commence comme suit : Hc D

a

D

...

).1. Donner lerreur commise sur le resultat si on se contente du developpement

a` lordre 6 de [e\td .2. Estimer alors [+Sd a` cette erreur pre`s, et comparer a` la valeur exacte ob-

tenue par votre calculette.

Exercice 61 :Soit [e\tdLg w

D

)H .

1. En utilisant la methode des trape`zes, combien faut-il de subdivisions de{h`/} pour evaluer [+Sd a` /h

z pre`s ?2. Determiner alors [d par les trape`zes a` /h

z pre`s .

Exercice 62 :Soit [e\tdLg_ ) z [IHd&)H .

1. En utilisant la methode de Simpson, combien faut-il de subdivisions de {hi`/}pour evaluer [Sd a` h

pre`s ?2. Determiner alors [d par la methode de Simpson a` h

pre`s .

Exercice 63 :Soit [e\tdLg_ $[Hd&)H .

1. En utilisant la methode de Simpson, combien faut-il de subdivisions de{h`(|} pour evaluer [I|d a` h

z pre`s ?2. Determiner alors [zd .


Exercice 64 :Soit [e\tdLg_ $[IHd")/[Hd&)H .

1. En utilisant la methode de Simpson, combien faut-il de subdivisions de {hi`/}pour evaluer [Sd a` h

pre`s ?2. Determiner alors [d par la methode de Simpson a` /h

pre`s .

Exercice 65 :Soit [e\tdLg_ >7$[Hd)H .

1. En utilisant la methode de Simpson, combien faut-il de subdivisions de{h`

} pour evaluer [

d a` /h

pre`s ?2. Determiner alors [

d . Comparer a` la solution exacte.

Exercice 66 :Soit [e\tdLg_

y

[H

z

d)H .

1. En utilisant la methode de Simpson, combien faut-il de subdivisions de { ` w }pour evaluer [ w d a` h

z pre`s ?2. Determiner alors [ w d .

Exercice 67 :Soit [e\tdLg_ y

y

D

)H .

1. En utilisant la methode des trape`zezs, combien faut-il de subdivisions de{h`/} pour evaluer [Sd a` h

pre`s ?2. Determiner alors [d par la methode des trape`zezs a` h

pre`s .

Exercice 68 :Soit B&g

Zc[IHd&)H . On conside`re une subdivision de {_`Fu} en l sous intervalles

egaux de bornes H"ôgp

fmj , ou` fsgh`/jjjkùl , gCH

, RgCH

x

et jg

l

.

1. Retrouver lerreur

^+[qjWd commise par la methode des trape`zes sur un sousintervalle { H"â`(H"^

y+} . Montrer que la formule generale de lerreur

g_BX

commise par application de cette methode, sur tout {_`Fu} , est donnee par :

gX

[M d(j

z

S

ZX_[ed`B{_`Fu}

En deduire que si zMg_=?>A@

|Z e[IHdS , alors

a

yz0

z .

2. Soit Zc[HdKgw

D

H

z

et Bg

y

Zc[IHd&)H .


(a) Montrer que BXgiy ou` iyg y

no[ td& et ou` no[ tdg w

, (pensera` un bon changement de variable).

(b) En utilisant le fait que =

w

gUh , approximer y par la methodedes trape`zes. Si j g hi donner la valeur approchee de iy par cettemethode.

(c) Combien faut-il de subdivisions de [0,1] pour evaluer iy a` /h

pre`sen utilisant la methode des trape`zes.

Exercice 69 :Pour approcher numeriquement lintegrale Bg

y

.a

, on lecrit sous laforme BVg

ou`

g

y

.a

et

g

y

.a

(

reel stricte-ment positif).

1. Montrer que lon peut determiner un reel strictement positif

tel que

U

y

z

h

.

(Indication : majorer yy

.a

par y.a

d .

2. Pour calculer

, on utilise la methode des trape`zes :(a) Rappeler la formule des trape`zes ainsi que lerreur commise par son

application. Donner une demonstration de lerreur.(b) Exprimer en fonction de gp\ m

ZXW[]\tdS le nombre N de pointsdintegration necessaire pour calculer

avec une erreur inferieure a`y

z

h

.

(c) Trouver et en deduire N.


7.7 Corriges des exercicesexercice 31

B g

Z[e\td&\

a) Soit lapproximation de B par la methode des trape`zes, le pas j est donnepar, jg


a) Calculons B par la methode des trape`zes. Ici, dapre`s le tableau des valeurs,jgUh .

B g

j

[e\

d

[e\

x

d

x

y

^

y

[e\_^d

g

/hu"h

7h`F

i[iù

=

i`F7hd&v

g 7hKn

y

b) Calculons B par la methode de Simpson.

[hdBg

j

u

[]\

d

[e\

x

d

W[

[e\kymd

[]\Wqd

jjjFd

[

[]\Wzbd

[e\~d

jjjFd v

g

h

u

h

7hi`F

W[`F

ù

=d

[iù

`b7

=d

v

g hcn

y

exercice 34Soit

B gk

m\

z

\

a) e g donc le pas dintegration est j g

. Calculons B par la methode destrape`zes.

B g

j

Zc[]\

d

Z[e\

x

d

x

y

^

y

Zc[e\_êd

g

h

um[

z

d

m$[hd

[ k[

d

z

m$[

d

z

$[

d

z

m[

d

z

d&v

g hi8h7i

a) egUh donc le pas dintegration est jg h

.

B g

7h

u

m$[

z

d

$[hd

[m[

/h

d

z

$[

h

d

z

m$[

%

h

d

z

jjj

m$[

/h

d

z

d

v

g hi77

alors que la valeur exacte est approximativement h77 . Avec ce pas pluspetit lapproximation numerique est meilleure.


exercice 35Soit

B g

)\\

Le pas dintegration est jg e

g

e

. Dautre part lerreur theorique sur lamethode de Simpson est donnee par

[rjWdrg

[M d

h

j

Z

[ed

[rjWdrg

h

N

A

eQ

ou` {_`Fu} , par consequent,

[qjdX

h

N

eQ

Ainsi pour que

[qjWdS hi

c

h

il suffit que e verifie

y

J

b

b

h

c

/h

,

donc, e hi

c

h

h

%

. Ainsi e verifie e /i . On prendra e1g8h ,car pour Simpson, le nombre de subdivisions de lintervalle {_`Fu} doit toujoursetre pair.

exercice 36Soit

n/fvlc[e\td

\

\

Lerreur de la methode des trape`zes est :

[qjWdKgU

S

j

z

Z

[ed

donc,

[rjWdS

M

[ d

z

l

z

z ou` zg =>@DFE

Z

[Hd . Ainsi, pour avoir

[qjWdSWk , ou` est lerreur permise, il suffit de prendre e subdivisions de lin-tervalle dintegration telles que

[ d

S

z

e

z


Donc, il suffit que e verifie,

e

[M d

S

z [Sd

Cherchons . On a

et

m

)

m

Pour dterminer les extremas de

, on cherche alors les racines de

.

Un calcul simple donne

)

"!

)

"#

%$'&

(

!

%$'&

*)

On cherche donc les racines de lequation,

+-,/.

0!

+1,/.

"#

.

$'&

(

!

.

$'&

234)

Dou`

#

0!

+1,/.

56

!

#

.

$7&

8)

En supposant+-,/.

:9

et !

#

9

, cest a` dire;9 =

, ( >@?A

4B

BC


Donc, c7$'dY*v

eg

w2x

. Par ailleurs, on verifie facilement que,x

zy6{

J


Ainsi, linequation (1) devient y xe

X

, soit y p/

# . Avec

p

/

#

subdivisions, lerreur commise lors de lapproximation de cette integrale par lamethode des trape`zes serea plus petite que

[D

.

b) Cherchons le nombre de subdivisions de U 4B V pour evaluer

a

[D

pre`s en utilisant la methode de Simpson.Lerreur theorique de cette methode est :

w

/

donc, {

{

Dr

~

ou` ~

d

Mo

E

C

7

{

H

{ . Ainsi, pour avoir {

{

, ou`

[D

, il suffit de prendre subdivisions de lintervalle dintegrationtelles que

D

r

~

)

Donc, il suffit que

verifie,

y

GD

r

/

~

Q


7.8 Mise en uvre en JavaNous presentons des mises en uvre des methodes des Trape`zes, de Simpson

et de Romberg.

7.8.1 Des classes abstraites dintegration numeriqueLes deux premie`res methodes implementees, celle des Trape`zes et de Rom-

berg, necessitent des interfaces analogues, tout en mettant en uvre des calculsdifferents. Nous avons decrit des classes abstraites pouvant etre derivees aveclune ou lautre methode. Ce procede permettra dutiliser ces classes abstraitespour la methode de Romberg qui pourra alors etre utilisee avec lune ou lautremethode.

Deux approches sont mises en uvre qui dependent de la situation pratiquedans laquelle se trouve lutilisateur :

Lutilisateur dispose dune representation analytique ou informatique dela fonction dont il cherche lintegrale sur un intervalle U

B

V . La classeabstarite suivante va permettre de decrire cette situation. Elle utilise laclasse FoncD2D decrite et utilisee de nombreuses fois dans les chapitresprecedents :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 connatre une fonction qua` partir dun tableau de va-

leurs en des points regulie`rement espaces. Dans ce cas, sil ignore la formeanalytique de la fonction, il ne pourra utiliser que ce tableau de valeurs quifixe le pas separant chaque point devaluation de la fonction. La classeabstraite suivante va permettre de decrire cette situation. Elle utilise unedescription 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);

}


abstract public double calcul() throws NbSubException;}

Par ailleurs, il a ete remarque dans les paragraphes suivants que le nombrede subdivisions devait respecter des proprietes de parite pour pouvoir utiliser lamethode de Simpson. Cest pour cette raison, que nous allons utiliser un traite-ment dexception pour gerer une situation ne verifiant pas la condition adequate.Nous creons donc la classe dexception qui suit :

class NbSubException extends Exception {public String toString() {

return ("Nombre de subdivisions impropre");}

}

7.8.2 Des classes dimplementation de la methode des trape`zesNous presentons ci-apre`s deux classes implementant de manie`re elementaire

la formule des trape`zes telle que decrite dans les paragraphes precedents. Chacunedes classes derive dune des deux classes abstraites precedentes.

Livre MN Java

Documents

Transcript of Livre MN Java