Beruflich Dokumente
Kultur Dokumente
13 septembre 2002
Résumé
1 Introduction à Java 2
1.1 Présentation de Java . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 Une machine virtuelle . . . . . . . . . . . . . . . . . . . 3
1.1.4 Caractéristiques . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Types primitifs et structures de contrôle . . . . . . . . . . . . . . 4
1.2.1 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . 4
1.2.2 Structures de contrôle . . . . . . . . . . . . . . . . . . . 4
1.3 Classes et objets en Java . . . . . . . . . . . . . . . . . . . . . . 5
1.3.1 Définition d’une classe . . . . . . . . . . . . . . . . . . . 5
1.3.2 Déclaration, création et destruction d’objets . . . . . . . . 5
1.3.3 Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.3.4 Construction de la classe vecteur . . . . . . . . . . . . . . 7
1.3.5 Composants de type static . . . . . . . . . . . . . . . 10
1.3.6 Composants de type public et de type private . . . . 11
1.3.7 Chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . 12
1.4 Organisation des fichiers sources d’un programme Java . . . . . . 14
1.4.1 Structure des fichiers sources . . . . . . . . . . . . . . . . 14
1.4.2 Commandes de compilation et de lancement d’un pro-
gramme . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.4.3 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.4 Visibilité des composants dans les packages . . . . . . . . 16
1.4.5 packages prédéfinis en Java . . . . . . . . . . . . . . . . 16
1.5 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.5.1 Construire une classe dérivée . . . . . . . . . . . . . . . . 17
1.5.2 Constructeur d’une classe dérivée . . . . . . . . . . . . . 18
1.5.3 Accessibilité : public, protected et private . . . . . . . . . 18
1.5.4 Méthodes virtuelles et classes abstraites . . . . . . . . . . 19
1.5.5 Un exemple : quelques objets géométriques . . . . . . . . 20
1
Méthodes numériques avec Java 2
1.5.6 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.5.7 Passage d’une fonction en paramètre d’une méthode . . . 24
1.6 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.6.1 Notions générales . . . . . . . . . . . . . . . . . . . . . . 26
1.6.2 Définir sa propre exception . . . . . . . . . . . . . . . . . 27
1.7 Entrées/Sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.7.1 Classes de gestion de flux . . . . . . . . . . . . . . . . . 29
1.7.2 Saisies au clavier . . . . . . . . . . . . . . . . . . . . . . 30
1.7.3 Lecture d’un fichier . . . . . . . . . . . . . . . . . . . . . 31
1.7.4 Ecriture dans un fichier . . . . . . . . . . . . . . . . . . . 33
1.7.5 Compléments . . . . . . . . . . . . . . . . . . . . . . . . 33
1.8 Conclusion provisoire . . . . . . . . . . . . . . . . . . . . . . . . 34
Introduction à Java
1.1.2 Historique
Au début des années 1990, une équipe de développeurs de la société SUN
Microsystems travaille sur l’implémentation du langage OAK pour l’intégrer en
domotique, notamment pour le développement de la télévision interactive. Il fal-
lait que les codes des applications dans ce langage soit peu volumineux, efficaces
5
Méthodes numériques avec Java 6
1.1.4 Caractéristiques
Le langage Java possède une syntaxe inspirée du C++. Il se veut plus propre
en terme de développement 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âce au fonctionnement d’un ramasse-
miettes (Garbage Collector) dont la fonction est d’identifier et d’éliminer tous les
objets qui ne sont plus référencés.
Java propose des exécutions parallèles de programmes grâce à une utilisation
qui se veut plus facile des threads (ou processus légers) par rapport au langage
C. Il possède également des aspects liés à la distribution grâce à ses possibilités
d’intégration dans des documents Web distribués par les applets, mais également
Méthodes numériques avec Java 7
default : instructionsNP ;
Vecteur x;
Pour que cet objet soit réellement construit, c’est à dire que la référence
désigne un emplacement à partir duquel on pourra accéder aux caractéristiques de
l’objet, on devra appeler l’opération new qui alloue cet emplacement en mémoire
et le renvoie à la référence de l’objet. On dispose alors d’une nouvelle instance de
l’objet. Par exemple, pour la construction effective de notre vecteur x, on écrira :
x = new Vecteur();
Méthodes numériques avec Java 9
1.3.3 Tableaux
Un tableau va permettre de stocker un certain nombre d’éléments de même
type dans une structure de données qui dispose d’un index pour y accéder. Un
tableau en Java est un objet à part entière.
Par exemple, un tableau monodimensionnel de flottants de type double sera
déclaré de la manière suivante :
double monTableau[];
ou encore
double[] monTableau;
class Vecteur {
double[] composant;
// constructeurs
Vecteur(int dim) { composant = new double[dim]; }
// 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; }
Méthodes numériques avec Java 12
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 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);
}
}
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
class Vecteur {
double[] composant;
static int nb =0;
// constructeurs
4
voir 1.3.1
Méthodes numériques avec Java 14
Vecteur(int dim) {
composant = new double[dim];
nb++; System.out.println("creation de l’objet "+nb);
}
Vecteur(double tableau[]) {
composant = tableau;
nb++; System.out.println("creation de l’objet "+nb);
}
...
...
// 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; }
...
}
L’utilisation de ces fonctions n’est pas affectée par ces déclarations
supplémentaires : on introduit simplement des limitations aux composants comme
décrit précédemment.
Il est à noter qu’en n’indiquant ni public ni private, les composants sont
considérés comme étant définis public par défaut, sauf si l’on se trouve dans
un autre package que celui de la classe considérée - nous reviendrons sur cette
nuance dans le paragraphe 1.4.3.
ou encore, sous une forme condensée qui est spécifique au type String :
La chaı̂ne "bonjour" est ici constante mais ch1 peut être réaffectée pour
référencer une autre chaı̂ne constante, comme dans l’exemple suivant :
javac Vecteur.java
javac TestVecteur.java
java TestVecteur
1.4.3 Packages
Un package permet de regrouper un ensemble de classes. L’instruction
package nomPack en début de fichier indique que les classes qui y sont
définies appartiennent au package nommé nomPack. Pour accéder aux classes
de ce package, lorsque l’on est dans une classe qui n’y appartient pas, on utilise
la dénomination nomPack.className, où className désigne le nom de la
classe.
Les désignations de package suivent un schéma de construction arborescent
du type : name.subname.subsubname. Il existe un lien entre les noms de
package et les répertoires où se trouvent les classes y appartenant . Par exemple,
une classe watch appartenant au package time.clock doit se trouver dans le
fichier time/clock/watch.class.
Les répertoires où Java effectue sa recherche de packages sont définis dans la
variable d’environnement : CLASSPATH.
L’instruction import packageName permet d’utiliser des classes du pa-
ckage défini, sans avoir besoin de les préfixer par leur nom de package. On peut
importer toutes les classes d’un package en utilisant un import du type import
packageName.* ;, mais, ATTENTION, l’import d’un niveau de package ne
permet pas d’importer les packages qui sont en-dessous dans l’arborescence des
répertoires.
Voici un exemple d’illustration qui montre une organisation de classes java,
dans différents répertoires et leur utilisation.
La variable d’environnement CLASSPATH doit être dans le fichier
.profile ou dans .bashrc, par exemple, sous Unix, de la manière suivante :
CLASSPATH = ˜/myJavaClass
Voici maintenant des extraits de différents fichiers rangés dans les répertoires
indiqués :
– le fichier /myJavaClass/bibMat/calVecteur/Vecteur.java correspond à
package bibMat.calVecteur;
public class Vecteur { ... }
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);
...
}
}
– Package P2 :
class C3 { ... }
Dans cet exemple, la classe C2 peut accéder à xa et xc. Par contre C3 ne peut
accéder qu’à xa uniquement.
1.5 Héritage
1.5.1 Construire une classe dérivée
La notion d’héritage est importante en programmation objet. Elle permet de
définir une classe dérivée à partir d’une autre classe dont on dit qu’elle hérite. La
classe dérivée possède alors, par défaut, l’ensemble des composants de la classe
dont elle hérite - on l’appelle classe mère - sauf si des restrictions ont été posés sur
ces composants. L’héritage est donc un concept essentiel renforçant les propriétes
de réutilisabilité des programmes objets.
L’utilisation répétée de l’héritage sur des classes successives conduit à la
construction d’une hiérarchie entre elles, que l’on peut schématiser par un arbre
d’héritage. La figure 1.1 présente un exemple d’arbre d’héritage construit sur des
classes permettant de représenter des figures géométriques.
Figure
Polygone Cercle
Triangle Rectangle
La construction effective des différentes classes de la figure 1.1 est faite dans
l’exemple complet du paragraphe 1.5.5.
Pour définir une classe ClB qui dérive de la classe ClA, on fera une déclaration
du type :
Méthodes numériques avec Java 21
Un objet de la classe ClB est alors aussi un objet de la classe ClA, il peut être
utilisé partout où un objet de la classe ClA est attendu.
On peut tester l’appartenance d’un objet à une classe grâce à l’opérateur
instanceof, comme dans l’exemple qui suit :
ClB x;
if ( x instanceof ClA)
System.out.println(‘‘voici un objet ClA !’’);
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éfinissons ensuite une classe abstraite pour définir le type Figure
constitué de deux méthodes abstraites d’affichage et de calcul de périmètre :
Triangle(Point[] m) { super(m,3); }
}
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);
Méthodes numériques avec Java 26
f=r; f.affiche();
System.out.println("perimetre : " + f.perimetre());
f=t; f.affiche();
System.out.println("perimetre : " + f.perimetre());
}
}
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écrire un modèle de construction de classe
dans lequel on n’indique uniquement que les en-têtes des méthodes. Cela équivaut,
d’une certaine manière, à une classe où toutes les méthodes sont abstraites.
On dira qu’une classe implémente une interface, si elle redéfinit toutes les
méthodes décrites dans cette interface.
Par exemple, on définit un modèle de problème par une interface qui comporte
deux méthodes poserProbleme et resoudreProbleme :
Méthodes numériques avec Java 27
interface AResoudre {
void poserProbleme();
void resoudreProbleme();
}
Nous allons montrer comme ce procédé peut être décrit d’une manière générique,
c’est à dire en utilisant une fonction abstraite , paramètre du procédé. On
applique alors ce procédé de dérivation numérique à une fonction particulière en
la transmettant par l’intermédiaire de ce paramètre.
Nous pouvons alors utiliser cette interface pour décrire un procédé générique
de calcul de dérivation numérique, comme décrit 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 ;
}
}
class TestDiffFinies {
public static void main (String args[]) {
FoncCarre f = new FoncCarre();
DiffFinies df = new DiffFinies();
System.out.println ("Différences finies d’ordre un "+
"en 1 de pas 0.01 : "+
df.derivOrdre1(f, 1, 0.01));
}
}
java TestDiffFinies
Différences finies d’ordre un en 1
de pas 0.01 : 1.9999999999999685
1.6 Exceptions
1.6.1 Notions générales
L’introduction de la notion d’exception dans un langage de programmation
a pour but de simplifier le traitement de certaines situations. Ces dernières sont
considérées comme exceptionnelles, au sens où leur détection nécessite de les
gérer, en les sortant du contexte dans lequelle elles sont détectées.
Dans les langages ne gérant pas spécifiquement ces situations d’exception, il
est nécessaire d’utiliser de nombreuses instructions conditionnelles successives,
afin de réorienter le déroulement du programme de manière adéquate. De tels
processus peuvent conduire à une complexité du programme dont la lecture finit
par s’alourdir.
Certains langages proposent de manière facultative l’utilisation des exceptions
(c’est le cas du C++). Avec Java, on a l’obligation de les gérer lorsque certains
appels de méthodes sont succeptibles, de par leur conception, de déclancher des
traitements d’exception.
Une gestion d’exception est caractérisée par une séquence
try - Catch - finally
qui correspond typiquement au déroulement suivant :
try {
//séquence succeptible de déclancher une exception
...
}
catch (classException e1) {
//traitement à effectuer si e1 a été déclanchée
...
}
catch ( ....) { ... } //autre déclanchement éventuel
finally {
//traitement effectué avec ou sans déclanchement d’exception
...
}
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ère
somme += entier; nbNotes++;
}
catch (NumberFormatException e) {
System.out.println("note: "+(i+1)+" invalide");
}
return somme/nbNotes;
}
aucune note !
1.7 Entrées/Sorties
1.7.1 Classes de gestion de flux
Dans le langage Java, deux types d’entrées/sorties sont utilisables :
– Les entrées/sorties traditionnelles, c’est-à-dire utilisant les flux de commu-
nications “par défaut”, à savoir le clavier ou l’écran, ou encore les fichiers ;
– Les entrées/sorties basées sur des interactions avec un système de fenêtrage.
Celles-ci seront développées dans le chapitre sur le graphisme.
Nous présentons, dans la suite, des notions basées sur l’API 1.1 et qui ont été en-
richies significativement par rapport aux versions précédentes. Les raisons de ces
enrichissements sont principalement dues à des questions d’efficacité et à la pos-
sibilité d’utiliser des codes internationaux (UNICODE) qui enrichissent le code
ASCII avec des caractères accentués, entre autres.
Les principales classes de gestion de flux sont organisées suivant la hiérarchie
d’héritage décrite dans la figure 1.2.
BufferedReader
BufferedWriter
PrintWriter
import java.io.*;
class Testio {
public static void main(String[] args) {
InputStreamReader fluxlu = new InputStreamReader(System.in);
BufferedReader lecbuf = new BufferedReader(fluxlu);
try {
Méthodes numériques avec Java 34
catch(NumberFormatException e) {
System.out.println("erreur conversion chaine-entier"); }
}
}
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éel lu : 12.5
somme des deux nombres : 15.5
– On utilise une boucle qui détecte la fin de fichier, suite au résultat d’une
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);
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) {}
}
}
}
2.3
1.2
3.4
2.1
5.2
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
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 d’ecriture dans le fichier out.txt");
out.close();
}
}
1.7.5 Compléments
Il est possible de lire et d’écrire des données brutes (donc non formattées) avec
les classes DataInputStream et DataOutputStream. Les fichiers, ainsi
construits, ne sont pas lisibles directement sous un éditeur de texte, par exemple,
mais leur taille est plus réduite.
Méthodes numériques avec Java 37
(2.1)
,
-/. 10 IR 2
&0
La généralisation aux systèmes d’équations non linéaires à plusieurs variables
( 3
IR ) n’est pas traité dans ce volume, (mais une introsduction en est donnée
sous forme d’exercice, présenté dans le chapitre 3, voir exercice 25) on pourra
consulter les références bibliographiques en fin de volume, par exemple, [?], ... .
Soit
,54
IR
$76 IR une application continue, on se propose de trouver la (ou
les) solution(s) de l’équation (2.1). Excepté quelques cas très simples, par exemple
pour les polynôme de degré inférieur ou égal à trois, les méthodes analytiques
de résolution d’équations ne permettent pas de résoudre de tels problèmes. Le
recours aux méthodes numériques, fournissant des solutions approchées, devient
alors incontournable.
38
Méthodes numériques avec Java 39
, 8
- ,9 ,
2. La réécriture de l’équation sous la forme , puis la
,:9
,
recherche de(s) point(s) d’intersection des courbes représentatives de et
de . Le problème sera plus simple à traiter si l’une des deux fonctions et
l’identité. La solution cherchée correspond alors à un point fixe de l’autre
fonction. Voir ci-dessous.
vérifie J>
dans l’espoir qu’elle tende vers la solution du problème. La limite de cette suite
.
1.
0 ABD.FEHG7V> 0 CA BD.FEHGI.
vantes :
(c’est à dire >VABD.FEHGMsACBD.FEHG
)
> u
2. est une application strictement contractante dans , de rapport de AB.HEFG
contraction ,
alors pour tout
@0 ACBD.FEHG
la suite récurrente définie par,
; @0
9 J AB.HEFG 01
3j< > 3 . 10
converge vers l’unique solution de J> , avec ACBD.FEHG . De plus, la formule
suivante donne une majoration de l’erreur commise à l’itération , lors du calcul
$
}u $&3 u 9 $P@ 2
de ,
3
Il est souvent délicat de déterminer un intervalle ABD.FEHG
dans lequel les hy-
pothèses du théorème du point fixe sont vérifiées, cependant on a le résultat sui-
vant.
——————————-
——————————-
——————————-
————————-
——————————-
——————————-
2. si > 7 }
, (figures 2 et 3), la méthode converge, est un point at-
@
@
tractif, les itérés successifs de la condition initiale (ou ceux de ) se
B ^j( F U > }
rapprochent de plus en plus de , (il faut alors déterminer un intervalle
contenant , dans lequel et
> ACBD.FEHG AB.HEFG A B.HEFG
), deux
cas se présentent :
-
¡ > i¢} , (figure 2),
(a)
@
la suite est croissante, elle est décroissante sinon (cas
si
3 @
où la condition initiale est ). Dans les deux cas, elle tend vers .
$£}¤ >
J- , (figure 3),
(b)
est alternée, deux itérés successifs de @ donnent un
la suite
3
encadrement de et la suite converge vers .
Méthodes numériques avec Java 42
x
y=
y=
x
y=
x o x o’ xo x o’ xo
− − − x
x x x x x
f(x) f(x)
x
x
y=
y=
− x − x
x x
Figure 4. Figure 5.
@ convergent vers si @
, et divergent dans le cas contraire. Dans le cas de la figure 5, ils
Dans la figure 4, les itérés successifs de
[3 3 $
figures 6 et 7), il existe des notions qui mesurent cette rapidité de convergence, et
mesurent donc la diminution de l’erreur d’une itération à la suivante.
@ et 9 5 > est dite d’ordre p si
¥ ¦|§H§ ¨#©ª¥
Définition 3 : La méthode définie par
3=< n tend3 vers ¤¬ . On dit alors
¥ ¦ ¥ « a une limite réelle strictement positive lorsque
que la méthode à un taux de convergence égal à .
Méthodes numériques avec Java 43
f(x) f(x)
x
y=
y=
- -
x x x x
Figure 6. Figure 7.
>
Théorème 2 : Si la suite 3
converge vers et si est suffisamment dérivable
9
> 7 s®=®=®dv> \ ¯jb e 7 > \ ¯ae 7t3
-
au voisinage de alors l’ordre de la suite est le plus petit entier tel que :
et -
. De plus on a
SUlU° [ =3 < 9 } >D\ ¯ae
$ 3=±<D² [ 3 ¯ M³
où [
3 3 . ¦I´µ¦
Ce théorème donne une estimation de l’erreur [ à la
3 itération.
Remarque 3 : Pour une méthode d’ordre p, lorsqu’on passe d’un itéré à l’autre,
le nombre de chiffres décimaux exacts est environ multiplié par p.
Tests d’arrêt des itérations.
Si le processus itératif converge, la solution , étant la limite de la suite, ne peut
être atteinte qu’au bout d’un nombre infini d’itérations. Par conséquent l’algo-
·
rithme sera arrêté en utilisant l’un des tests suivants, où désigne la précision à
¾¿ B
f(x)
xo xÄÅ 1 xÆÇ 2
ÀÁ ÂÃx b x
A
Figure 8.
9 È @
ci-dessous.
1. si l’extremité est fixe, cette méthode s’écrit
3=< > 3 et donné,
où : ; @ OE
9 $ , É ^ § § bÉ v> 2
3j< 3 3 \Ê^ eb \Êce 3 J 2Ë2W2
C’est une suite décroissante et bornée, donc convergente, ( B
2Ë2W2 Ì 9 @ ).
3
2. si l’extremité
est fixe, elle s’écrit :
; @ B
9 $ , É |bd^É § § ?> 2
3j< 3 3 \eÍb \_^ e 3
@¤O 9 2Ë2W2 O
2W2Ë2Ë2 E ). 3
C’est une suite croissante et bornée, donc convergente (
Méthodes numériques avec Java 45
——————–
FIGUREsq 9 a, b , c ,d
———————
,
Î
O
$ } 9 } , 9 $ RÐÏ#Ñ , +}=
} donc Ò30 A 9 . } G . D’autre
Exemple g Y A . G , on a9 } , -/ª2 }~ , et ª}~
, - sur Ó - sur A . G , ainsi Ô- ,
c’est donc l’extremité
ª
} , +
~
}
part
c
. @ qui} sera fixe, figure 9(c). Par
, on trouve aisément : »-2ÊÕ(Ö/2W2Ë2W.
9 conséquent, en
Ï
commencant le processus par
Ï
-/2ÊÕ , ... etc ..., ainsi, ?-/2_Õ à - b près. }
f(x)
x ×Ø ÙÚ
x2 x1 xo x
Figure 10.
, t
-. 3
Cette méthode est bien définie pour ‘voisin’ de à condition que
3
Déterminer un intervalle AB.HEFG sur lequel il y’a convergence de Newton n’est pas
toujours facile, mais le théorème suivant donne une condition suffisante.
Méthodes numériques avec Java 46
â
On démontre que la suite ê åøÐì converge plus rapidement que la suite êñDøÐì vers
la même limite ñ . Mais il est conseillé d’eviter cette formulation de ê ]ø(ì qui est
]ø õ ñDø=ùúVü þ õ ï/çjþ(ç
ú ý
ú
ñDø=ùú õ
les composer pour obtenir une méthode plus rapide.
La méthode de Steffensen compose une méthode itérative
avec le êñDøÐì
â
procédé ! d’Aitken : d’où les itérations suivantes :
De même, cette écriture n’est pas numériquement stable, d’où la formulation sui-
vante, plus stable :
&'
ú ý
& &
ú &)(
*+
Þ ó êñDø#ì õ í
Þ êñDø#ì%ý&ÞQêñDø úcì
Dñ øtýPñDø ú
õ þ#ç
10 2
On démontre que cette méthode est d’ordre
celui de la méthode de Newton ; cependant Regula-Falsi â peut s’avérer plus ra-
3
pide que Newton puisque n’exigeant qu’une seule évaluation de fonction (celle de
ÞQêñDøÐì ÞíêñDø úcì
), ayant été calculé lors de l’itération précédente, alors que New-
ton en exige deux,
et . ÞQêñDøÐì Þ¶óêñDøÐì
Ainsi, avec deux évaluations de fonctions, on effectue une itération de Newton
et on multiplie environ par deux le nombre de décimales exactes (puisque cette
méthode est quadratique, théorème 4) ; désignons par 4 le temps nécessaire pour
cette itération. Dans la méthode de Regula-Falsi, durant le même temps 4 , on
effectue approximativement deux itérations (puisqu’une seule évaluation de fonc-
tions est faite par itération), et on multiplie ainsi à chaque itération, environ par
ê úIù â ì â
10 2 65
ÿ
, le nombre de décimales exactes, ce qui est meilleur et explique
(b)
êñì , D= ?= ;
â ú åñ
õ ¶ý
(c)
êñì
CB
<EGF
B
â
(d)
êñì õ
IH
ñü J .
Exercice 2 :
Voir si chacune des fonctions suivantes admet zero, un ou plusieurs points fixes,
ñ õ
Exercice 3 :
Montrer que l’équation RQ ý êñì
TS <EUF admet une unique racine dans l’intérvalle
Q
WVä ý :ç ü 7é
Q
"V ;Q IR, et S ß B B
8þ .
=
Exercice 4 :
ñâý
þ=ï#ï]ñ üsþ õ ï
Déterminer à l’aide de la méthode du point fixe les deux racines réelles de
þ=ï û
êñì õ ëú ö ùö ú ñ õ êñì õ þ=ï(ïtý ú
avec une erreur K =
ñ õ
. Utiliser pour l’une de ces racines la
NX
méthode itérative , et pour l’autre Y .
Þíêñì õ åñ û ýPñ'ý
Exercice 5 :
Soit la fonction , on se propose de trouver les racines réelles
ñDø=ùú õ â â ú
(] )
;
( ) ñDø=ùú õ þü â .
`
_
^
gente (vérifier les hypothèses du théorème du point fixe). Choisir ñö , condition
initiale de l’itération, dans l’intervalle de convergence puis trouver ñ limite de la
Z
Exercice 7 :
ù
On veut résoudre dans IR l’équation Y où, ñ õ ê ñìa
êñì õ ý ñ
õ äï jþqé
F ,
ñ ñ ß
õ
a) 1) Montrer qu’elle admet une seule racine Z , montrer que Z ed f[ .
ú ê ñì õ ú ñDø=êñùì ú õ ñ ê ñDø#ì ú
$
2) Montrer que la méthode itérative : diverge.
ih
ñDø=ùú õ ú êñì
3) on considère alors
g
, (remarquer que
existe),
$
ø õ ñDøý ñ
montrer que la méthode itérative :
converge.
En posant K
LZ montrer que
K
ø=ùú
est de signe opposé à K , qu’en conclut- ø
ñ õ þ=ï
on ? 7
Donner le bon test d’arrêt des itérations pour avoir Z à S j
près, puis donner
cette racine approchée.
b) ñ
Retrouver Z à l’aide de la méthode de Newton.
Remarquer que Newton est d’ordre 2.
Exercice 8 :
On applique la méthode de Newton au calcul de la racine carrée d’un réel positif
Exercice 9 :
1. Démontrer que si X est une fonction continue dérivable d’un intervalle d de
ñ õ ñ õ
IR dans lui même de dérivée négative et bornée sur I, alors on peut mettre
l’équation X
êñì
sous la forme
êñì
, où est une application
contractante de d .
ñ ñâý õ ï
ê ñì õ â
2. Utiliser la question précédente pour trouver la racine Z de q dans
ä þ(ç åé
avec une erreur =
2
8þ=ï
; prendre X .
Méthodes numériques avec Java 50
â õ ï åñý û õ ï
Détérminer en utilisant simultanément les méthode de Newton et de Lagrange la
ñ 2 K
K
áþ=ï ñiý
õ ï
racine située dans [0,1], avec une erreur =
de
,
,
puis de ñ û ý (ñZü
u J .
Retrouver ces racines grâce à la méthode des approximations successives.
ñâ õ
Exercice 12 :
On cherche les racines réelles de l’équation Ya
F . ê+þ ü&ñì
1. Montrer que la fonction a
Þíêñì õ ñ âiý
F admet deux racines, l’une ªê þiü ñì
évidente qu’on donnera, et l’autre que l’on note (que l’on veut approcher ñ
dans la suite).
ñ
2. Localiser dans un intervalle de longueur 1/4.
3. Ecrire la méthode de Newton relative a . Donner un choix de la condition Þ
ñö
initiale des itérations de Newton qui assure la convergence du processus.
ñDø=ùú õ ñDøjùú õ
4. Soient les méthodes d’approximations succesives suivantes :
êªþ ü&ñDø#ì ý¡þ
`
a LK
(a) F et (b)
Préciser si elles convergent ou divergent. En cas de convergence indiquer
un choix de la condition initiale . ñö
Þíêñì õ Þíêñì õ ï
Exercice 13 :
Soit YK
q ü åñ'ý
u , localiser graphiquement la racine Z de . ñ
2
En donner une approximation avec une erreur inférieure à
en utilisant simul- þ=ï
tanément la méthode de Newton et de la corde.
õ ñ â . On pose
Exercice 14 :
On cherche les racines réelles de l’équation K
Þ êñì õ
Q ýnñ â NK
1. Montrer que l’équation Þíêñì õ ï admet une unique racine sur IR, que l’on
notera ñ . Localiser ñ entre deux entiers consécutifs ; soit l’intervalle ob-
v v d
tenu.
2. Soit la méthode d’approximation successive suivante :
ñDø=ùú õ ñDøãý K
üNñ øâ ç ñöß ÿ ed
ñDø=ùú õ LK
;w
â ç ñözß ÿ ed
ñ
Cette suite converge t-elle vers v , pourquoi ?.
Þ
4. Ecrire la méthode de Newton pour . Donner une valeur explicite de qui ñö
assure la convergence de la méthode de Newton (si cette converegence est
possible), justifier.
5. Si l’une des trois méthodes proposées ci-dessus converge, l’utiliser pour
donner une approximation de v à
près.ñ þ=ï â
d { .
(f) montrer que l’ordre de cette méthode est plus petit ou égal à 1. Le
vérifier numériquementà la question ci dessous.
(g) Donner alors cette racine à þ=ï â j
près.
2. Par la méthode de Newton.
(a) Ecrire la méthode de Newton relativeà l’équation (1).
(b) Vérifier que cette méthode converge vers la racine Z et donner une ñVú
valeur explicite de la condition initiale qui assure cette convergence. ñö
(c) Donner alors cette racineà þ=ï â
j
prés.
ÞQêñì õ õ ï , ï ¡ñ
Exercice 16 :
Þ
Soit la fonction définie par 8;:< ñíýPñ K
T= ?=RV9t .
Méthodes numériques avec Java 52
1. Montrer que l’équation Þíêñì õ ï admet une unique racine ñ Z dans l’inter-
äCï/ç åé
valle V9t .
2. Soit la méthode itérative suivante :
ñDø=ùú õ êñDø#ì õ êñDø(ì
K $
8;: <
ñö choisi .
(a) Montrer qu’en choisissant un intervalle äæDçFèHé äCïç åé ,
V9t cette
méthode peut converger vers Z . ñ
(b) Montrer que ñDø¶ý ñ IZ =Yx
ø ñöý ñ
Z , on explicitera x .
B B B B
ñ ãý ñ îþjï
7
(d) Donner le nombre d’itérations { assurant l’inégalité : }| Z
B B
.
3. Ecrire la méthode de Newton pour . Donner une valeur explicite de Þ ñö qui
assure la convergence de la méthode de Newton vers Z . ñ
Þíêñì õ ñ ý åñû ü þ
Exercice 17 : 7
Soit la fonction p , on se propose de trouver les racines réelles
Þ
de par la méthode des approximations successives (méthode du point fixe que
l’on appliquera correctement), puis par la méthode de Newton.
1. (a) Montrer que Þ
possède deux racines réelles, une évidente que l’on
ñ
donnera, l’autre Z que l’on localisera dans un intervalle d de longueur
þ
t .
(ii) ñDøjùú õ
âú , n
G
_
ñDøjùú õ ¶ý
m
(iii) _ ,
(c) Si l’une de ces méthodes converge l’utiliser pour déterminer ñ à jþ ï â
Z
près.
2. (a) Ecrire la méthode de Newton pour Þ .
(b) Vérifier le théorème de convergence globale de cette méthode sur un
intervalle que vous donnerez.
(c) Donner une valeur explicite de ñö qui assure la convergence de la
méthode de Newton vers Z . ñ
Méthodes numériques avec Java 53
ÞQêñì õ ï Þ
Exercice 18 :
On veut résoudre l’équation non linéaire dans IR, : , où est une ap-
ê (ì
ê ñì õ ñ'ý ëê Þ ó êñìmìÞQâ êý ñìcÞ¶ú Þíóêêññì ì+Þ ó ó êñì
â
1. Montrer que l’ordre de convergence de cette méthode est au moins égal à 2.
ê (ì pour calculer à partir de H _
ÞQêñì õ ñ ûý
2. Quel est le schéma itératif résultant de A \
"\ , ( \ IR). Pß
3. Partant de ñö õ þ , donner alors à þ=ï û près . H _
j
õ õ õ õ
o )Z
ó ê ñì
)Z
Y
m ~
ê ñì ï et ê ñìãô ï (ñ étant la racine cherchée).
n
)Z
m ~
n
)Z Z
Méthodes numériques avec Java 54
ó êñì õ ý
8':< ê ]ñì
et
B
ó êñì B
=
ç
donc, d’après la proposition
7
1, est contractante de rapport de contraction
êñì%ý ê Ýì âú ñ'ý
(b) .
Soient ñ ç 'ß&ä ý£þ(çjþqé
B B
, montrons que
= . On a
B B B B
B
êñì%ý ê /ì õ
B
ü þ ñ ý ¶ý þ B B
u
B
B
õ
þ ñ ý
þ ñ'ý ÿ
B B B B
= W
B B
ñ ý
õ ñíý ¶ü u " ý
B B B B
=
B
ñ ý ü
í u
B
ý B
B
d’après l’inégalité triangulaire
=
B
B
ñ ý ÿ
í u
B
B
B B B B
êñú ìµý ê /ì â í
B B B B B B B B B B
Ainsi,
â %
= =
óêñì ú .
ú.
* = 7
B B
Ainsi, est contractante de rapport
(d) êñì õ
x= 7
ñü . H
J
est définie sur ä ý ç¹ü 8ä mais n’y est pas lipschitzienne.
Méthodes numériques avec Java 55
En effet,
est lipschitzienne sur d s’il existe une constante réelle , ÷Òï
telle que ðêñ ç /ìß dâ , êñì ý ê Ýì ñ ý
Q
, c’est à dire que le rapport
êñì%ý ê /ì , pour ñNõ ô , est borné.
ed =$ W
B B B B
ñ ý
Q
q
donc non bornable sur tout intervalle contenant ; ainsi ne peut être ý
lipschitzienne sur . ä ý ç¹ü 8ä
En fait, on montre que est lipschitzienne sur tout intervalle avec äæDç¹ü 8ä
þ þ
En outre,
est contractante si î þ , donc si H
zæ ü î þ , c’est à dire
æQ÷ ý
J
pour .
é ý ç¹ü 8ä .
En conclusion, est contractante sur
Exercice 2
êñì õ þ
(a) Points fixes de H
ñõ . Rappelons qu’un point fixe de est un point
d’abscisse Z vérifiant ñ
. Par abus de langage, et dans tous les exer- êñì ñ
cices qui suivent, on dira que est le point fixe de (au lieu de l’abscisse ñ
du point fixe de ).
Ici est définie sur
1¡
et on a
ù
êñì õ ñ ¢ ñ ñ õ þ H
ñ õ þ#ÿ
¢
êñì õ ñ þ ýPñ õ ï ñ Q
ñ ¡
ý þ õ ï et ñ÷¡ïÿ
ñ
H
¢ ¢
H
¤ ¤
Méthodes numériques avec Java 56
{ß äCï/ÿËþ#ç ~é
ÞQê qì õ ï
de la valeur intermédiaire, il existe un et un seul réel ¥ tel que
¥ ; celui-ci est donc le seul point fixe de sur
1¡
. Le lecteur
ù äï/ÿËþ#ç åé
êñì õ
pourra aisément démontrer que cela reste vrai sur tout £ .
YK
Þíêñì õ ãÞ óêñì õ
(b) Points fixes de
.
¦K
ýJñ Þ
ÞíêIïÐì õ þ
Posons
. est continue et dérivable sur IR, et
ý ýþLîvú ï
K
Þ
Þíê+þ=ì õ ýYþJîï
, donc est strictement décroissante. D’autre part,
ÞQê qì õ ï
et . D’après le théorème de la valeur intermédiaire,
M
il existe un et un seul réel ¥ ß äï/çjþ é
È
tel que
¥ . Ce réel est donc
l’unique point fixe de sur
äï/çjþqé
. De même, on peut aisément démontrer
Donc 2 est l’unique point fixe de sur IR ; ce point fixe est dit triple à cause
de la puissance du terme " . êñQý #ì
õ
ê ñì õ ñ êñíý #ì â õ
ÿ
K
¢
V
Þíêñì õ ê ñ'ý #ì â ý
K
u
V
ÿ
K
V
Þãó
En conséquence, est strictement croissante sur D a F PV , strictement é+ý ç ê ì ä
é ê :ç vì ä Þ ó ê ê ìcì îLï
croissante sur a F ¤V et a
F ¤V . Ainsi, IR , ðñ¡ß Fç Þ ó êñì îLï
Þ
donc est strictement décroissante.
Þíê ì õ ï
D’après le théorème de la valeur intermédiaire, il existe un et un seul réel
tß&ä £ç ê ìqä
¥ /§
a
F PV tel que ¤¥ . Ce dernier est l’unique point fixe de .
Méthodes numériques avec Java 57
Exercice 3
ñ õ %Q
ý
¨ <EUF êñì , ß çQ
?£ ¨ 8þ .
=
Þíêñì õ ñQý ü ñ õ /ï ÿ Q
u¨ <EUF
Þ ó êñì õ þý
On a
W¨ 8;:< ñ ï , car 8þ#ç ¨ =
Þ
B B
õ
WV ªV "¨ WV
Þíê ü ì Qü ê ý ìi÷¡ï Q
"V V "¨ <EUF
Q
V
exercice 4
Soit l’équation Þíêñì õ ñ â ývþ=ï(ï]ñüJþ õ ï .
a) Posons ú êñì õ
ñ â üJþ
þ=ï#ï
þ=ï#ï Z «Z )Z
õ þ ñâ ý â
þjï#ï W
"
þ=ï#ï (ï B B
B
u
B
=
B
u
B
Méthodes numériques avec Java 58
Ainsi, ðñö ߢäï/çjþ é , ñDøjùú õ ú êñVúcì õ úëö ùö ú converge vers ñ , unique solution
t
³
ñö õ ï
ñVú õ úqêñö¹ì õ ú êIï#ì õ þ=ï#þ ï õ ïÿÊï/þjï#ï#ï/þ
Y
Y
ñ õ úqêñ û ì õ ÿËÿWÿ
7
ñ
Si on cherche Z à ¨ près, on arrêtera les calculs à l’itération o telle que ñ ù úý
ñ ñ ï/ÿ_ï/þ=ï#ï#ïþ þjï B ~
ñDø=ùú õ â êñDøÐì õ
=R¨ . Ainsi la solution Z ici vaut à
´ près.
~ B
þ=ï#ï¶ý ú
z
b) L’autre solution est obtenue grâce à la méthode itérative
. Cette question est laissée en exercice.
exercice 5
Soit l’équation Þ êñì õ åñ û ý¡ñý õ ï
í Y . Il est clair que est continue et Þ
Þíê+þ~ì õ ý¤þ ÞQê #ì õ þ Þ ó êñì õ
dérivable sur £ .
On a , ¤ , donc P ÞQêªþ~ìcÞíê (ìíîÈï
. D’autre part,
]ñ â ï ä þ#ç åé
Þíê ñì õ ï
sur . Donc, d’après le théorème de la valeur intermédiaire, il existe
ñß&ä þ#ç åé
ñDø=ùú õ ú êñDøÐì õ åñ øû ý
une seule solution Z telle que )Z .
Þíêñì õ ï
(a) Etudions la convergence de la suite c . Tout
des accroissements finis, il existe qø compris entre ñDø et ñDøjùú tel que
µ
B
Y
µ
B B
Méthodes numériques avec Java 59
Donc
ú êñDøjùúmì%ý ú êñDøÐì
ñDøjùúµýPñDø
B B¶
â ñDø¶ýPñDø ú
B
B
..
.
ø ñVúµýPñö ÿ
B B
elle converge conduit vers la racine ñ de ÞQêñì dans ä þ#ç åé , car si ñ est la limite de
Z Z
õ ý ]ñ
âó êñì
·3
ê åñ â ývþ~ì â
P
õ Dê åñâ%üJþ~ì
âó ó êñì
3 ¤
ê ~ñ â ývþ=ì û
P
þ
âóó ó ý ú
+
â
3D¸ 7º¹´
õ
Donc )Z
âó ê ñ7ä þ(ì ç åé ý ð ññòû ß :ç ó êñì âó ÷
¬Z , et comme est continue, il existe un voisinage ¾ de Z tel ñ
â
que ¾ , et ¿¾ $ . Donc cette méthode ne peut pas converger
B B
a .
ø ñVú%ýnñö
d’après la proposition 3. En effet, grâce au théorème des accroissements finis, on
ñDø=ùúµýPñDø
B Bj B B
Méthodes numériques avec Java 60
cette méthode conduit à la racine de Þíêñì õ ï dans ä þ#ç åé car si ñ est la limite de
Z
ñ õ þ ü ñ donc ñ û õ þü ñ et Q
À
Z
_
Z
Þ ê ñì õ ñ û ý ñQývþ õ ïÿ
Z
Z
)Z ¬Z ¬Z
On a
ï î ûó êñì õ þ
êªþ ü â ì â î¢þ(ç
`
_
ñöß&ä þ(ç åé
ñDø=ùú õ û êñDø#ì
$
j
:
0 1 2 3 4
ñDø 1 1.144 1.162 1.165 0.165
Donc ñ õ þ#ÿËþ
Z est solution de l’équation à þ=ï û
près.
exercice 6
Soit l’équation La F ñ õ
dans . ê+þ ü&ñìMüÌï/ÿ ù
Considérons la méthode itérative définie par :
ñDøjùú õ êñDø(ì õ
$ $a
F êªþ ü&ñDø#ìMü ï/ÿ
est contractante sur d õ äæçHèFé éUï/çjþqé Å car
0 1 2 3 4 5 6 7 8 9
ñDø 0.7 0.730 0.748 0.758 0.764 0.767 0.769 0.770 0.771 0.771
exercice 7
Soit l’équation ñ õ ê ñì où êñì õ ý ñ . Y a
F
2) Si ñDøjùú õ
Z )Z Z )Z F Z
ú
Mais, ðñvß8äCæDçjþdä ç óÍêñì õ ý , et óÍêñì ÷Òþ donc la méthode ñDøjùú õ
Attention à la notation utilisée :
þ .
êñú ì
úìó õ ú .
est dérivable et on a ê
õ ê ó ì ó , par conséquent
ɺÊbËPÉ*Ì
ê Í
Í
þ
dÏ
ú. ó ú õ
Í
B B
Ñ K K K
K K
Ò R
ú ì ó êñì î¢þ .
B B
Par conséquent ê
B Y B
Z
õ õ
converge IZ Ó
K ù
Ainsi, øjùú õ /óëê ø#ì ø . Or, /óëêñìãîáïtðñ&ß IR . Donc ø=ùú et ø sont Ó µ
K
Ó
¡ K K
õ õ
=%¨
B
Ó
B B
B
B
d Ó d +$d
car :
Ó êëï/ÿWþ=ì õ ö ú ÷ /ï ÿWþ NK
°
ê+þ~ì õ þ î þ Ó
K
LK
êñì õ
äï/ÿWþ(çjþqé
ñDøjùú õ
et Ó
est monotone sur
þjï û
ñö õ þ
Calcul numérique de la racine à
près. Soit donc la méthode
K
et
0 1 2 3 4 5 6 7 8
ñDø
1 0.367 0.692 0.500 0.606 0.545 0.579 0.560 0.571
9 10 11 12 13 14 15
ñDø 0.564 0.568 0.566 0.567 0.566 0.567 0.567
ÿ
K
ó êñDø#ì þ ü K
õ
Ô£
Þ ó ó êñì ý K
îOï pour tout ñ ß . Ainsi d’après le théorème de conver-
¼£
gence globale de cette méthode (voir théorème 3), pour tout ñö ß?äCï/çqþqé tel
que ÞQêñöaìcÞ ó ó êñöaì ÷ ï l’itération de Newton converge. Prenons alors, par
exemple, ñö õ ï , alors ÞíêIïÐì+Þãó óêëïÐì õ þ t ÷¡ï , donc la méthode
K
ñö
K
K
Calcul numérique
===========================
Méthodes numériques avec Java 64
import java.lang.*;
import java.io.*;
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;
}
Õ Ò
m
( n
La classe IterLagrange est telle que son constructeur possède les pa-
ramètres suivants : la valeur initiale ñö et une fonction quelconque réelle d’une
variable réelle (les réels étant représentés par le type double).
import IterGene;
import FoncD2D;
// constructeurs
IterLagrange(FoncD2D fonc, double xini) {
f=fonc; x0=xini;
epsilon=0.001;
maxIter=100;
}
Þíêñì õ$Ö
û ýu3 sur l’intervalle ä þ#ç ~é
import java.io.*;
import FoncD2D;
import IterLagrange;
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);
}
}
}
&'
ú ý
& &
ú &)(
*+
import IterGene;
// constructeur :
IterSteffensen(IterGene fonc, double xini) {
g=fonc; xn=xini; epsilon=0.001; maxIter=100;
}
import java.io.*;
import FoncD2D;
import IterLagrange;
import IterSteffensen;
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);
}
}
}
On note Û øÝê ì ø
IR , l’espace vectoriel des matrices carrées d’ordre et à co-
ø
ß øÝê ì Óß IR , on cherche le vecteur Ö ß
õ
efficients réels. Soit § NÛ IR et Ü IR ,
Ö
solution du système linéaire § Ü . Ce système admet une solution unique
lorsque le déterminant de A est non nul, ce que nous supposerons dans la suite.
Remarquons que la résolution de ce système à l’aide des formules de Cramer
est impraticable lorsque n est ‘grand’, car ces formules nécessitent approxima-
â
tivement ÞÝ opérations arithmétiques élémentaires ; par exemple si n=15, cela
représente de l’ordre de 4 mois de calcul pour un ordinateur moyen effectuant ´ þjï
opérations à la seconde. Ce temps de calcul évolue de manière exponentielle avec
.
Nous rappelons dans la suite les principales méthodes, beaucoup plus rapides, car
‘polynomiales en temps’ :
. Quelques méthodes directes : Gauss et sa forme factorisée ß
. Quelques méthodes itératives : Jacobi et Gauss-Seidel.
Les méthodes directes calculent une solution théorique exacte, en un nombre
fini d’opérations, mais avec une accumulation d’erreurs d’arrondis qui d’autant
plus grande que la dimension l’est.
Par conséquent, pour des matrices de dimension importante, il est préférable
d’utiliser des méthodes itératives basées sur la construction d’une suite conver-
gente vers la solution du système. Dans ce cas, le contrôle de la convergence de la
suite par une condition d’arrêt renvoie une solution plus précise.
71
Méthodes numériques avec Java 72
õ õ ëê æ qì ú ø
se fait en “remontant” les équations de la dernière ligne à la première.
Soit donc le système § Ö
inversible. Dans ce cas, Š
Ü où §
, àbà
àâá àU° áã ° est triangulaire inférieure et
puisque å K;æ § Nç àã àà . õ
ð þ æ õô ï ê ¶ì õ ø ú æ õ ô ï
L’algorithme de résolution est :
- .
,
ñDø õ Ò
è
ñ õ ú êIè ý
et
1à à ê
ø ùú æ ¹ñ ì
áãfà àâá á pour ä
õ
ý¡þ#çjÿËÿËÿWçjþ
Òiéé
æ/ú útõ ô ï
Pour la clarté des explications, on applique la méthode de Gauss dans le cas
où n=3. On suppose que .
ê+þ~ì
. n
âú
ì m
û ëí m
â ú â grâce à la combinaison
ú ý â
ú ce qui
m m Ò ² m
û õ û û
_
grâce à la combinaison m donne le m Ò ² m
Êâ
-
ê #ì
. n n n n
â
ì m m m m
õ
¤ gë ëí
õ
Ensuite, en supposant que æ
â â ô ï , on élimine le terme æ ûâ â ñ õ â dans ûÊâ grâce
n n
m m
²ð
à la combinaison Êâ ý
âÊâ , ce qui donne le système û ñ û équivalent
n n n n
û
_
m Ò*ï ²ð m § m Ü m
²
Ò*ï
au système initial :
Méthodes numériques avec Java 73
è âÊâ âÊâ û
-
ê Ðì
. n n n n
ì m m m m
æ û ûû ñ û õ
¤ gë ëí
è ûû
n n n
m m ë
û m
ÿ
n n n n n n
_ ² _ ²
où m m Ò ï ð
²
m m m Ò ï ð
²
m
Ò*ï Òï
Le système obtenu est donc triangulaire. On le résout grâce à l’algorithme du
paragraphe précédent.
ú õ þ ï ï ö÷
ó
m
n
ôõ
ý ¤
Ò ² þ ï
ý Ò _
Ò
Ò ² ï þ
on a donc
æ/ú ú /æ ú â æ/ú û ö÷
§ Êâ õ
m
n ó
m
ú n
§ m
ú õ n
ôõ
ï æ ââ â æ âÊâ û m
n
m
n
ÿ
ï æ ûâ â æ ûÊâ û
n n
m m
De même la matrice § Êâ
m
n
du troisième système vérifie § m û õ n ó
Êâ â
m
n
§ m
n
où
þ ï ï ö;ù
÷
ó
â õ
m
n ôø
õ
ï þ ²ð
ï
ï ý Ò*ï
_ ²ð
²
þ
Ò*ï
on a donc
ú ú æ/ú ú æ/ú â /æ ú û ö÷
§ m û õ n ó
mÊâ õ ï
n ó
m
n
§ m
n
ôõ
æ ââ â æ âÊâ û m
n
m
n
ÿ
ï ï æ û ûû
n
m
Ainsi § m
ú õ ê â
n
m m *
§
ó
m m
m
§ m
n ó
. Les matrices m
ú ì ú û =ê ú ì ú ê
n n ó n ó
Êâ ì ú û n n ó ú n
ó
Êâ
n
et m sont inversibles car leurs déterminants sont tous égaux à 1 et leurs inverses
sont faciles à calculer. En effet, on peut vérifier qu’on les obtient en transformant
Méthodes numériques avec Java 74
en leur opposé les termes figurant sous la diagonale, les autres termes restant in-
changés. On trouve alors
þ ï ï ö ù
÷
õ ê ó
m
ú ì ú ê â ì ú õ
n
ó
m
n
ôø
õ
Ò ²
¤
þ
²ð
ï ÿ
þ
Ò
_ _ ð
Ò ² Ò ï ²
²
Ò Ò*ï
Si on pose ß õ §m û n
, qui est triangulaire supérieure, § peut alors s’écrire comme
le produit des deux matrices et ß :
§
õ ß
Faire un paragraphe complet sur la méthode des pivots lignes ... plus remarque
sur le pivotage colonnes.
üü
tation de lignes ou de colonnes s’impose. Sur le plan numérique si le pivot est
“trop petit” (par rapport aux autres coefficients de la matrice ou par rapport à la
précisison de la machine), le cumul des erreurs numériques peut être important.
Ainsi pour des raisons de stabilité numérique, il faut effectuer des permutations
de lignes ou de colonnes de façon à aboutir à un pivot “plus grand”. On dira
que l’on fait un pivotage total lorsqu’on permute des lignes et des colonnes,
Méthodes numériques avec Java 75
sinon le pivotage est dit partiel. Si on n’effectue qu’un pivotage partiel sur les
lignes, cela ne revient qu’à changer l’ordre d’énumération des lignes du système
qui n’est donc pas modifié. Lorsque l’on effectue un échange de colonnes, cela
revient à permuter les éléments du vecteur inconnu Ö qui sera donc différent
de la solution du système initial. D’une manière pratique, dans ce dernier cas,
il est donc nécessaire de mémoriser toutes les permutations de colonnes afin de
pouvoir reconstruire le vecteur solution en respectant l’ordre de ses éléments
correspondant au système initial.
ñü
donne
– sans permutation de lignes, la solution ; êIï/çqþ~ì
– avec permutation de lignes, la solution . ê+þ#çjþ=ì
La solution exacte est êªþ#ÿÊï(ï#ï/þ#çFïÿ
Ðì
, ce qui montre que la première solution est
fausse alors que la deuxième est la meilleure que l’on puisse obtenir, compte-tenu
de la précision de la machine.
———————-
COMPLETER ce cours
———————
Méthodes numériques avec Java 76
]ñVú%ý åñ õ
â ü&ü&ñ ñ û õ
,
- .
ê+þ=ì åñVúMü&ñ â
û õ
(ñVú%ý ]ñ
"
â ü åñ û
J
»õ õ »õ
·
Ü
ôõ
ÿ Factoriser la matrice § en produit ß puis résoudre le système.
ý£þ
Exercice 21 :
ý£þ ñVú
ö÷ ö÷
õ õ õ
et Ü
ôõ
ï ÿ
¤ý þ
1. Factoriser la matrice § en produit ß puis résoudre le système.
ú
ê ì ú õ ú úì
2. Trouver §
( on rappelle que si M et N sont deux matrices (n,n) inversibles
ó ó
alors { *
{¿
.
Exercice 22 :
Soit le système linéaire :
cñü õ þ
ê #ì
P
S
ñZü
õ
õ þjï
b) en permutant les deux lignes
7
du système.
Application avec S
et un ordinateur fictif à 3 chiffres décimaux significa-
tifs. Qu’obtient-on dans les deux cas ? expliquer ces résultats .
Méthodes numériques avec Java 77
Exercice 23 :
Résoudre le système suivant :
a) En représentant les nombres en virgule flottante avec 8 chiffres significatifs,
b) puis exactement,
ñZü õ
ê Ðì
¤
êªþüJþ=ï ì ñü
q
ý "
õ ü?þ=ï
ý
Exercice 24 :
On applique la méthode de Gauss au système tridiagonal suivant :
èqú =ú ï ï ï
¥ ï
ö;ù
ù ñVú ö;ù
ù ú x
ö;ù
ù
æâ èâ â ï ï ñâ
ù ù ù
â
ôø ù ôø ù ôø ù
¥ x
ï æû èû û ï ñû
ø ù ø ù ø ù
ÿû
ø ù ø ù ø ù
¥ x
ÿ ÿ ÿ
ø ù ø ù ø ù
ø ø ø
õ
ù ù ù
ÿ ÿ ÿ ÿ ÿ
ø ù ø ù ø ù
ø ù ø ù ø ù
ÿ ÿ ÿ ÿ
ø ù ø ù ø ù
ø ù ø ù ø ù
ï ï ÿ ÿ
ø ÷ ø ÷ ø ÷
ø ø ø
ï ï #æ ø
ú èFø ú Fø ú ñDø ú #ø ú
ø ø ø
õ õ õ
¦¥ x
ï ï ï Ðæ ø Hè ø
ñDø
#ø x
õ ý&æ ú
ì à à à
ì
xà àUà
þ
à à à
Exercice 25 :
Zýnñ â ü â õ ï ê (ì
u
P
Méthodes numériques avec Java 78
ñüâ ü û õ þ
Résoudre par Gauss direct, puis par factorisation de la matrice le système :
,
â ü û ü õ ï
- .
û
õ ï
7
ü ü 7
2
»õ
Exercice 27 :
Ö
Soit le système linéaire en dimension 3,§ Ü ,ö÷ où \ et ] sont deux réels et
þ ñVú
ö÷ ö÷
õ õ õ
]
§
ôõ
ï \ þ , Ö ôõ
ñâ et Ü
ôõ
ÿ
ñû ï
1. Donner la décomposition ß de § où est une matrice triangulaire à dia-
gonale unité et ß une matrice triangulaire supérieure. Pour quelles valeurs
de \ cette décomposition existe.
2. Pour quelles valeurs de \ et ] ce système admet une solution unique ; don-
ner cette solution.
3. En utilisant la décomposition ß trouver §
ú lorsqu’elle existe.
Exercice 28 :
à õ þ û ï õ ñâ õ
÷ ÷ ÷
û ÿ
ôø ôø ôø
þ þ ï ¤ý þ ñû
ø Ö ø ø
, et Ï
7
û
õ õ õ
ï ï ï þ ñ7
ú ;
à »õ
Exercice 29 :
Ö
Soit le système linéaire en dimensionö;ù 4, Ï , où : ö;ù
ï ï ï ñVú ý
ö;ù
ù ù ù
à õ ï þ þ ¤ý þ õ ñâ õ þ
÷ ÷ ÷
ÿ
ôø ôø ôø
ï ï ý ñû
ø Ö ø ø
õ , õ et Ï õ
·
ï ý þ ñ7
ý ûâ
Méthodes numériques avec Java 79
ì
inconnue et le système 3X3 restant, que l’on notera § , (
êñ â mç ñ û çcñ
7
).
2. Factoriser la matrice § en produit ß (où est triangulaire inférieure à
diagonale unité et ß triangulaire supérieure), puis résoudre le système.
à »õ
Exercice 30 :
Ö
Soit le système linéaire en dimension 4, Ï , oùö;:ù
þ ï ñVú ï
ö;ù ö;ù
ù ù ù
à õ ï õ ñâ õ þ
÷ ÷ ÷
ÿ
ôø ôø ôø
ï ï ï ñû þ#þ
ø Ö ø ø
õ
, õ
et Ï
õ
ï ñ7
ï
1. La résolution de ce système peut être ramenée à celle d’un système linéaire
ñ
ñ õ è
de dimension trois. Quelle est l’inconnue á facile à déterminer. Donner
cette inconnue et le système 3X3 restant, que l’on notera § .
2. Factoriser la matrice § en produit ß (où est triangulaire inférieure à
diagonale unité et ß triangulaire supérieure) puis résoudre le système.
3. Trouver §6
.
ú
Méthodes numériques avec Java 80
]ñVú%ý åñ õ
â ü&ü&ñ ñ û õ
,
- . "
åñVúMü&ñ â
üâ ~û ñ û õ
(ñVú%ý ]ñ
u J
ý þ
ö÷ ö÷
õ õ
§
ôõ
þ þ et Ü ôõ
ý
·
Posons § m
ú õ
n
§ , on calcule § â õ
m
n ó
m
ú n
§ m
ú n
, où
þ ï ï ö ù
ù
ú õ
÷
ý âû þ ï ç
ôø
ó n
ø
m
õ
ý û ï þ
7
d’où :
ý þ ö;ù
ù
Êâ õ ú
÷
ï
ôø
n
ûú û
ø
§ m
õ
ï ý û âû
on calcule § m û õ n ó
â Êâ
m
n
§ m
n
, où
þ ï ï
ö÷
ó
Êâ õ n
ï þú ï ÿ
ï þ
ôõ
m
Donc,
ý þ ö;ù
ù
û õ ú
÷
ï ÿ
ôø
n
û û
ø
§ m
õ
ï ï 2
û n
û õ Êâ â õ â ú ú
La matrice § m est ainsi triangulaire supérieure, c’est la matrice ß recherchée.
n ó n n ó n ó n n
D’autre part, on a § m m § m m m § m , on en déduit donc que
ú õ ê ú ì ú ê Êâ ì ú
û ÿ
§ m
n
ó
m
n
ó
m
n
§ m
n
Méthodes numériques avec Java 81
Ainsi, § õ §6m
ú õ n
ß , avec
þ ï ï þ ï ï þ ï ï
ö÷ ö÷ ö÷
õ õ
ûâ ï þ ï þ ï þú ï
ï ý þ
âû þú ï
ÿ
ôõ ôõ ôõ
û ý þ
7 7
û
On a ainsi factorisé § sous la forme :
þ ï ï ý þú
ö÷ ö÷
õ
âû þ ú ï ï ÿ
û ý þ ï û û
ôõ ôõ
§
ï
7
2
õ õ õ
Présantation de la méthode d’identification
Résoudre § Ö Ü revient à résoudre ß Ö Ü . On pose alors ú ß
Ö
, la
résolution du système initial revient à résoudre successivement les deux systèmes
triangulaires :
õ
õ
ú Ü
Ö
ß ú
þ ï ï ö;ù
ú ö;ù ö;ù ö;ù
ú
ù ù ù ù
õ õ õ
÷ ÷ ÷ ÷
âû þ ï ÿ
ôø ôø ôø ôø
â
ú û
ø ø ø ø
ú Ü ¢ ¢ ú
õ õ õ õ
7
ý ú þ
û
2
û
Finalement, on résout :
ý þ ö;ù
ñVú ö;ù ö;ù
þ ö;ù
ú
ù ù ù ù
õ ú õ õ
÷ ÷ ÷ ÷
ï ñâ ÿ
ôø ôø ôø ôø
û û úû
Ö ø ø ø Ö ø
ß ú ¢ ¢
ï û
õ õ õ õ
ï ñû 2
Exercice 20
Soit le système linéaire § »õ
Ö
Ü où :
þ ï ý
ö÷ ö÷
õ õ
·
§
ôõ
ï þ et Ü ôõ
ÿ
ý
· ï ý¤þ
Posons § m §
ú õ
Factorisons la matrice § en produit ß .
n
, on calcule § m
n ó
m
n
â õ ú § m
ú n
, où
þ ï ï
ö÷
ó
m
ú õ
n
ôõ
ýï þ ï ç
ý ï þ
ª
Méthodes numériques avec Java 82
d’où :
þ ï ý
ö÷
Êâ õ
·
§ m
n
ôõ
ï þ
ï ý · þ
on calcule § m û õ n ó
â Êâ
m
n
§ m
n
, où
þ ï ï
ö÷
ó
Êâ õ
m
n
ôõ
ï þ ï ÿ
ï þ
Donc,
þ ï ý
ö÷
û õ
§ m
n
ôõ
ï þ ÿ
ï ï þ 3
û n
û õ Êâ â õ â ú ú
La matrice §m est ainsi triangulaire supérieure, c’est la matrice ß recherchée.
n ó n n ó nPó n n
D’autre part, on a § m m § m m m § m . On en déduit donc
ú õ ê ú ì ú ê Êâ ì ú
û ÿ
§ m
n
ó
m
n
ó
m
n
§ m
n
Ainsi, § õ § m
ú õ n
ß , avec
þ ï ï þ ï ï þ ï ï
ö÷ ö÷ ö÷
õ ôõ
ï þ ï ôõ
ï þ ï õ ôõ
ï þ ï ÿ
ï þ ï ý · þ ý
· þ
§ se factorise donc sous la forme :
þ ï ï þ ï ý
ö÷ ö÷
õ
§
ôõ
ï þ ï ôõ
ï þ ÿ
ý
þ ï ï þ 3
Résolvons le système § Ö õ Ö õ
õ õ
Ü . Cela revient à résoudre ß Ü , c’est à
dire à résoudre successivement les systèmes ú Ü puis ß Ö ú .
þ ï ï ú
ö÷ ö÷ ö÷ ö÷
õ õ õ
ú Ü Ã¢
ôõ
ï þ ï ôõ
â
ôõ
¢ ú
ôõ
ÿ
ý
· þ
û ý£þ
Finalement, on résout :
þ ï ý ñVú
ö÷ ö÷ ö÷ ö÷
õ ï þ
·
ñâ õ
õ úû ÿ
ûú
Ö ôõ ôõ ôõ Ö ôõ
ß ú â ¢
ï ï þ 3 ñû
û
Méthodes numériques avec Java 83
Exercice 18
C’est un exercie sur le pivot de Gauss. Soit le système linéaire :
cñü õ þ ê úmì
êªþ~ì S
ñü
"
"
õ
ê âì
cñü õ þ ê úmì
ïüêªþý ú Pþ=ì õ tý ú Pþ
ê #ì
P
S
i
¤
ê óâ ì
¤
Si on pose S õ þjï
7
alors le système (2) s’écrit
jþ ï ñZü ú
7
õ þ ê iúmì
ê óì
P
ïüOê+þý úëö ì
Ì º
õ zý úëö ú P
þ Ì
ê :óâ ì
et on obtiendrait ainsi
5
þ
d’où en reportant dans la première ligne du système (2’) on trouve
ñ õ ï/ÿ
La solution du système donnée par cet ordinateur fictif serait alors . êIï/çqþ~ì
b) Permutant maintenant les deux lignes du système initial (1). on résout donc
ñü õ ê âì
ê Ðì
Scñü
"
"
õ þ
ê úmì
ê ó ì ñïüü
õ ê âì
êªþý ú Pþ~ì õ þý ú
" ¤
¤
º Æ ê óú ì
¤
õ
ê ó ì ñZïüO
ü
ê+þý úëö ú P~þ ì õ þý ëú ö ú
ê âì
P Ì
º
Ì
Æ ê :óú ì
Méthodes numériques avec Java 84
5
þ#ç
et en reportant dans la première ligne du système (2’) on trouve
ñ 5
þ#ÿ
La solution du système donnée par cet ordinateur fictif serait alors , très ê+þ(çjþ~ì
proche de la solution exacte qui est bien sur . êªþ#ÿÊï(ï#ï/þ#çFïÿ Ðì
õ þ=ï
La solution obtenue grâce au système (1) sans permutation de lignes est 7
er-
ronée car, lors de l’élimination de Gauss, on divise par le pivot S
, très
voisin de la précision de la machine utilisée, d’où l’erreur numérique. En permu-
tant les deux lignes du système on évite ce problème puisque le nouveau pivot est
þ
alors égal à , valeur très grande par rapport à la précision de la machine.
Exercice 19
Résoudre le système suivant :
a) En représentant les nombres en virgule flottante avec 8 chiffres significatifs,
b) puis exactement,
ñZü õ
ê Ðì
¤
q
êªþüJþ=ï ì ñü
ý "
õ ü?þ=ï
ý
—————-
SOLUTION a TAPER ...
Exercice 20
ôø
æâ èâ â .. .. .. ù
ù ôø ñâ ù
ù ôø
x
â
ù
ù
. . .
ñû
ø ¥ ø ø
æû èû
ù ù ù
..û
ø ø ø
û
ù ù x ù
ø ¥ ù ø ù ø ù
ø
.. .. .. ù ø .. ù ø ù
õ
ø
. . . ù ø . ù ø . ù
ø ù ø ù ø ù
ø ø ø
.. .. .. ù ù ù
ø
ø
. . . ù ø
ø
ù ø
ø
ù
ù ù ù
ø .. .. .. ÷ ø
.. ÷ ø
.. ÷
ø . . . ø
.
ø
.
ñDø ú (ø ú
ø ø ø
õ ..
.
..
.
..
. æ#ø ú èHø ú ¹ø ú ¥
õ õ
x
ï ï ï ÿËÿWÿ
æ#ø Hè ø
ñDø
(ø x
" !$#&%"*( )' +! 444 667!- 444 : - ( ) 444
,
- - - 444 444
.. .. ..
. . .
444
.. .. .. 444 ..
444 9
..
444
444 444
. . . . .
..
.
..
.
..
.
44
5 686..0 5 : ./: .0 5
.. .. ..
.. .. ..
. . .
Si on pose ;
þ
ú õ Ñÿ
ú õ ú
(et ¥ ¹ø õ ï )
õ õ õ çjÿWÿËÿËç
ü
è è
+< =<
þ ÿ Ì
à
è
é
Ì
à
è
ü é
Òié é
Ì
pour ä
é
Ò é é
Òié é
. . .
444
.. .. ..
444 ..
444 9
..
444
444 444
. . . . .
..
.
..
.
..
.
44
5 6867..0 5 : :/. .0 5
.. .. ..
, ./0 /. ,0 . . 0 .
.. ..
. . . . .
.. .. ..
. . .
þ
þ division soustraction ü?þ
multiplication, ü?þ ê ý¡þ=ì
fois
CA
à
þ ü ü ê ý¡þ=ì
ø/D
division J soustraction J multiplication, fois
èFE A
à
yKy K
ê ývþ=ìqê+þ
soustraction mutliplication ü?þ ì
Méthodes numériques avec Java 86
Exercice 21
Résolution d’un système dans £ â
ñ'ýnñâý â õ ï +ê þ=ì
Zýnñ â ü â õ ï ê (ì
u
P
êªþ~ì êñíý þ ì â ý u â õ þ
ê tü þ ì â ýPñ â õ þ
ê #ì
¤
]øjùú õ ñ øâ ý ø â õ
"
u
êñDøç ]ø(ì
/H
I G KJJ ñ
â â â â
õ ü LJ ü MJ ñ ü NJ îþ
X X
s
J J J
È » l» » l»
½ ½ ½ Þ½
Dêñ â ü â ìiîþ
Ýö
s s
È ¤ P ¤ ¤ È 3 "
ã
G PRÝQ ö ñ â ü â î ú .
s
`
c.à.d. que
â â
È
*3
ñDø ]ø
þ#ç ]ï Ðï ï/ç ]ï /þ 3
ê ñ ç ì SG ñâü â ÷
`
ú
Ce procédé diverge-t-il ? Il faut montrer qu’en Z Z , on ` a
õ
ñDø=ùú ñ øâ ü øâ õ
ñ ñâ ü â
"
Dê ñ â ü â ì õ
â Sâ G
s
. Or, donc Z . Ainsi, È
ñ î âúâ
Y Z Ñ Z 3 Z c Z
0
s H
ñ
3«Z , et
H
ñ î þ
È implique que Z H
Ò , ce qui est impossible
ñT /ï ç ñUT ï/ç VTï/ç J÷ ï/ç
È 3«Z
0
H H
puisque Z 3 . Donc, Z *3 *3 * . . . La méthode
diverge.
Méthodes numériques avec Java 87
2. Méthode de Newton.
Ö
ø=ùú õ
YÖ
q!
Ö
, avec øü ø
ø õ ñDø
]ø
Ö
» , et
]ø õ Zø ñ ñ
J J
»
J Þñ J O ý J Þ J Oñ
å ½
Zø õ
J J J J
å »
½
Ici,
JÞ õ ý
J
J Oñ
OQêñ ç Ýì õ ýPñ â ü â õ ý åñ
J
¢
J O õ þü
J
q
ñDøjùú õ Dñ øü ê ñ øâ ü êªþø â ý ý åñDñDødø#ìqìqêªþ ê+þ ü ü å]ø#ø(ìMìüOýJê+ý ê+ý å]ñDø#ìqøÐê ìq]ê+øzý ýPåñ ø#øâì ý ø â ì
"
"
J
q
u
"
"
J ¤
u
P
ñDø åø
ï ïç ïç *3
ÿËÿËÿWÿ
ïç õ ñ ïç õ Z j Z
Méthodes numériques avec Java 88
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("");
}
result.toCoef(i, j, somme);
}
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.};
Méthodes numériques avec Java 92
m4 = matrice.addition(m1, m3);
System.out.println("m1+m3 : ");m4.afficher();
m4 = matrice.soustraction(m1, m3);
System.out.println("m1-m3 : ");m4.afficher();
}
}
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
Méthodes numériques avec Java 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
}
Pour tester notre classe, il nous faut saisir la matrice et le second membre du
système. Pour cela nous allons passer par l’intermédiaire d’un fichier en reprenant
les constructions qui ont été présentées au premier chapitre et en y ajoutant l’uti-
lisation d’un analyseur de type StringTokenizer qui va pouvoir décomposer
une ligne constituée de plusieurs valeurs numériques et les extraire. Une lecture at-
tentive du listing qui suit permet facilement d’en comprendre le fonctionnement :
tout est basé sur l’utilisation de la fonction nextToken() qui décompose la
chaı̂ne jusqu’au prochain séparateur.
import java.io.*;
import java.util.*;
class bibMatFileIn{
FileReader fichier=null;
BufferedReader lecbuf;
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();
Méthodes numériques avec Java 96
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;
}
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");
}
Méthodes numériques avec Java 97
return mlu;
}
}
}
5 5
1 2 3 4 5
0 7 8 9 8
0 0 6 7 3
0 0 0 5 6
0 0 0 0 1
5
5 4 3 2 1
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
5 5
1 2 3 4 5
Méthodes numériques avec Java 99
0 7 8 9 8
0 0 6 7 3
0 0 0 5 6
0 0 0 0 0
5
5 4 3 2 1
L’affichage généré par le programme, à partir de ce fichier, 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ème triangulaire inférieure sur le
même modèle, mais en ne s’intéressant qu’au cas où la matrice est, de plus, à
diagonale unitée. En effet, c’est ce cas qui sera rencontré lorsque l’on mettra en
œuvre la méthode de factorisation LU.
class sysTriangInfUnite extends sysLin{
§
õ ß
avec à/á õ ï Q÷
si î Jä , à/á õ þ
si î õ
ä et ß9à/á
õ ï si íî î Jä .
La formule du produit matriciel s’écrit :
õ Yø
ú
§·à/á à ß á
ü ü
ã
ü
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);
}
}
}
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;
}
}
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();
Méthodes numériques avec Java 103
}
catch (SysLinException e){
System.out.println(e);
}
}
}
5 5
1 2 3 4 5
2 5 1 6 7
2 6 1 8 6
5 6 4 7 7
2 5 5 2 2
5
5 4 3 2 1
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
Méthodes numériques avec Java 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
4.1 Applets
Une applet est un programme qui est inclus dans une page HTML et qui va
donc être exécuter par le navigateur lisant cette page, à condition qu’il possède
les fonctionnalités pour le faire. Il doit donc contenir une machine virtuelle Java
compressée (c’est le cas des navigateurs usuels qui contiennent aujourd’hui un
noyau Java correspondant à un JDK 1.1).
La classe java.applet.Applet doit être la classe mère de toute applet
incluse dans un document.
Il faut noter dès à présent que cette applet ne possède pas de point d’entrée
main(), celui-ci se trouve gérer implicitement par le navigateur.
105
Méthodes numériques avec Java 106
4.1.4 Compléments
Nous donnons brièvement et de manière non exhaustive quelques points
d’entrée pour les lecteurs désirant utiliser les aspects multimédia de Java mais que
nous n’utiliserons pas dans le cadre des applications présentées dans cet ouvrage.
Des méthodes sont disponibles pour récupérer 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éthodes de la classe java.applet.AudioClip permettent de ma-
nipuler les sons ainsi récupérés :
– public abstract void play() ;
– public abstract void loop() ;
– public abstract void stop().
Des méthodes sont également disponibles pour jouer directement les sons :
– public void play(URL url) ;
– public void play(URL url, String name).
Pour terminer, nous signalons que, dans la suite de cet ouvrage, nous
présenterons principalement des applications graphiques autonomes et non sous
forme d’applets, car elles sont, de fait, plus générales. Les indications données
précédemment sont suffisantes pour permettre une transformation assez facile de
ces applications autonomes en applets.
import java.awt.*;
import java.awt.event.*;
}
public void windowClosed(WindowEvent event) {}
public void windowDeiconified(WindowEvent event) {}
public void windowIconified(WindowEvent event) {}
public void windowActivated(WindowEvent event) {}
public void windowDeactivated(WindowEvent event) {}
public void windowOpened(WindowEvent event) {}
Un exemple : un compteur
Dans l’exemple commenté suivant, on met en œuvre une petite interface gra-
phique incluant différents boutons et gérant des évènements.
import java.awt.* ;
import java.awt.event.* ;
int compteur ;
// définition de boutons
// en paramètre : le texte des boutons
Button boutonIncr = new Button("+");
Button boutonDecr = new Button("-");
Button boutonQuit = new Button("quit");
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());
Méthodes numériques avec Java 112
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;
Méthodes numériques avec Java 114
Il faut aussi définir un processus de passage d’un domaine à l’autre, ce qui est
décrit dans les paragraphes suivants.
addWindowListener(new MiniWinAdapter());
add("North",c);
add("Center", new Label(texte, Label.CENTER));
}
}
class ManipGraphe {
y1= f.calcul(x1);
Line(g, x1, y1, x2, y2);
x2=x1; y2=y1;
}
}
}
import java.awt.*;
import FoncD2D;
import ManipGraphe;
import FenetreGraphe;
import DomaineDouble;
import DomaineInt;
ManipGraphe mp = null;
FoncD2D f;
DomaineDouble cr;
DomaineInt ce;
class GraphFonc {
Interpolation Polynômiale
n
pour . Le but du problème d’interpolation est de déterminer une
fonction simple à calculer, telle que :
no[e\_^]dLgpZc[]\_^edq`rfsgphi`/jjjt`ul
[e\_^v`bZc[]\_^edmd
n
Les points sont appelés points d’interpolation ou d’appui.
jjj
Les fonctions les plus couramment utilisées sont des polynômes des fractions
n
rationnelles, des sommes d’exponentielles etc .
Dans ce volume on ne traitera que le cas où est un polynôme.
w?x Z
Théorème 5 Une condition nécessaire et suffisante pour qu’il existe un polynôme
unique interpolant est que les points d’interpolation soient tous distincts. \_^
5.2 Interpolation de Lagrange
[]\kyq`bZc[e\WzFdmd
[e\Wz`bZc[]\Wzbdmd Zc[]\td \ {|\kyq`m\Wz}
Interpolation linéaire Connaissant deux points d’appui et
\
, on approche la valeur de , pour tout dans par l’or-
donnée du point de même abscisse se trouvant sur la droite joignant les deux
points d’appui.
Dans ce cas le polynôme d’interpolation est du premier degré et s’écrit :
w y~[e\tdLgZ[e\kyd \\Wz Zc[]\Wzbd \\ky
\kyc\Wz
\WzN\ky
121
Méthodes numériques avec Java 122
[e\kyq`bZ[e\Wzbdd
[e\Wz`bZc[]\Wzbdmd [e\W`FZc[e\Wbdd Zc[e\td { \kyq`m\Wzm}
Interpolation quadratique Connaissant trois points d’appui ,
\
et , on approche la valeur de , pour tout x dans
par l’ordonnée du point de même abscisse se trouvant sur la parabole passant
par les trois points d’appui.
Dans ce cas le polynôme d’interpolation est du second degré et s’écrit :
w y~[e\tdLgZc[]\kyd [e\\WzFd
[e\\Wqd
[]\kyc\WzFd
[e\ky\WqdR
Zc[]\Wzbd []\W[e\z\k\kyyd
d
[e[e\\WzN\W\Wqqd dR
Zc[]\Wbd []\W[]\\k\kymymd~d~[e[e\\WL\W\Wzqzqd d
[e\_^v`bZc[e\_^]dmd fgh`/jjjk`ul
Interpolation de Lagrange, cas général On appellera polynôme de Lagrange
de degré n basés sur les points d’appui , pour les n+1
polynômes de degré n : x
K []\tdNg 8 \ \_^ fsghi`
jjjk`ul
\ \_^
K K
tels que []\ dg et [e\_^dgh pour fg . Le polynôme d’interpolation de
Lagrange est donné par x
w$x []\tdLg u ¢¡ K [e\tdZc[e\ d
£7l z ¥¤8l
Remarque 6 La formule ci-dessus nécéssite un grand nombre d’opérations pour
Lx [e\td
¦ x/§ y~[e\tdLg¨ © ¢¡ [e \\ © d ª [e\tdLg«[¬¨ ©x ¢¡m ® © []\ \ © dd
[]\\ d
sa mise en oeuvre informatique ( au total ). En regroupant astucieusement
les termes de , on peut économiser le nombre d’opérations, d’où, si on pose :
K [e\tdLg°¯¸±m²´³aµ¶q·
et ;
alors et
µ¶q· x
w?x []\tdNg ¦ x/§ y~[e\td F ¢¡ Zc[] \ d
ª [e\td x§ y
Théorème 6 (erreur de l’interpolation de Lagrange) Soit Z ¹ º {¼»_`F½u} , et
$
w x []\td le polynôme d’interpolation de Z sur les points []\_^"`bZc[]\_^edd , pour
f¾ghi`
jjjk`ul . Pour tout \¿¹{À»_`F½u} , il existe Á ¹Â}ÃÄfvlc[e\$`m\_^¬db`uÃÅ»Æ\s[e\$`m\_^d~{ tel que
soit
l’erreur Zc[]\td
?
w x [e\td soit Ç ¶
x§
[e\tdLg ¯ µ ±ux/²Æ§ ³ y µ·]¶qÈ · Z µ y · [eÁ ¶ d Ç
Si on pose É
x§ yKgÃÅ»Æ\KÊmËÌmË/ʹμZc[el Sd~[e\tdSÎ , on alors [e\tdÐÏÒÑ ¯±ux/²Æ§ ³ay µ¶q· Ñ É x§ y .
µ ·]È
Méthodes numériques avec Java 123
f¾ghi`
jjjk`ul . Pour?
w x tout \¿¹{À»_`F½u} , il existe Á ¹Â}ÃÄfvlc[e\$`m\_^¬db`uÃÅ»Æ\s[e\$`m\_^d~{ tel que
¶
l’erreur Zc[]\td [e\td estÇ :
[ ¦ x/§ y~[e\tdd z z x§ z
[]\tdLg [¬ß8l ß7dqè Z µ · [eÁ ¶ d
x
où ¦
x/§ y~[e\tdLg¨ © ¢¡ [e\\ © d .
Méthodes numériques avec Java 124
¡\ gUh7hiï`m\kÆycSgUé àSßl’aide
Exercice 33 :
7`m\WzgU/£Æ£ .
Avec quelle précision peut-on calculer de l’interpolation de La-
grange, si on prend les points :
Exercice 35 :
a) Reécrire la formule d’interpolation de Lagrange dans le cas où les points d’ap-
pui sont équidistants.
ðóòÞhiôõÆh ðóòÐhiôöé
£
b) Utiliser le même tableau qu’à l’exercice précédent complété par la ’vraie’ va-
leur de et estimer la valeur de .
Exercice 36 :
cZ []\tdLgyømùòÐ\$ô
a) Utiliser la formule d’interpolation de Lagrange pour trouver la cubique passant
Zc[]\tdKg ú*ûaü ¶
par 0.4, 0.5, 0.7, 0.8 pour
b) Même question pour .
Z[e\tdLg ï ß \ .
Exercice 37 :
Soit
w
1. Determiner le polynôme [e\td de Lagrange basé sur les points d’abscisses
0, 1 et 2.
w w
2. Calculer [hiô=Sd et [¬hôë´d , et comparer aux valeurs ’exactes’. Evaluer l’er-
reur d’interpolation en ces deux points. Commentaires ?
Méthodes numériques avec Java 125
Z[e\tdLg ¶¶ îî §ä yy .
Exercice 38 :
Soit
1. Determiner le polynôme
w [e\td de Lagrange basé sur les points d’abscisses
-2, 0 et 2.
2. Calculer
w [Sd
, et comparer à la valeur exacte. Evaluer l’erreur d’interpola-
tion en ce point. Commentaires ?
Exercice 39 :
Zc[e\tdLg y § y¶ î .
Calculer le polynôme d’Hermite Q tel que :
Q(0)=f(0), Q’(0) =f’(0), Q(5)=f(5), Q’(5)=f’(5), pour
En déduire la valeur de Q(4), comparer f(4) à Q(4).
Méthodes numériques avec Java 126
\_^
existe un polynôme unique interpolant une fonction , à savoir que les points
d’interpolation soient tous distincts.
Z[e\tdLg ï ß \ .
Exercice 41 :
Soit
w
1. Determiner le polynôme [e\td de Lagrange basé sur les points d’abscisses
0, 1 et 2.
w w
2. Calculer [hiô=Sd et [¬hôë´d , et comparer aux valeurs ’exactes’. Evaluer l’er-
reur d’interpolation en ces deux points. Commentaires ?
ï Sí
On se donne les trois points d’interpolation suivants : , , .
Z
Avec quelle précision peut-on calculer à l’aide de l’interpolation de Lagrange
appliquée à une fonction que vous donnerez ?
Z[e\tdLg y § y ¶
Exercice 43 :
Soit .
w
1. Determiner le polynôme [e\td de Lagrange basé sur les points d’abscisses
0, 1 et 2.
w y
2. Calculer [ z d , et comparer à la valeur exacte. Evaluer l’erreur d’interpola-
tion en ce point. Commentaires ?
ðòÂ[vé7ß7ëiôõ´ßÆd ðóòk[véÆß8ë´dpg
Exercice 44 :
õiôöß7í7hÆëÆìÆì ð ò$[vé7¤7h´dgÿõiôßÆíÆß8ì´íÆí
Approcher par interpolation de Lagrange, sachant que
et . Donner une majoration de l’erreur théorique
ðóòÂ[véÆß7ëôõ´ß7d
de cette interpolation et la comparer à l’erreur effectivement commise (utiliser
une dalculatrice pour avoir la valeur ‘exacte’ de .
Méthodes numériques avec Java 127
\ ¡ `m\kyb`
ôô=ô`\
Rappelons que le polynôme de Lagrange basé sur les points d’appui d’abs-
cisses est d’ordre N et s’écrit :
w?x [e\tdLg F ¢¡ Z [e\ d K []\tdq`
© © \ \
\¡ g Zc[]\ ¡ d
ici les points d’appui donnés par :
h g ê
\kyrg ß Zc[]\kyd g ß
\Wz g ¤ Zc[]\Wzbd g ë
\W g é Zc[]\Wbd g ìÆí`
détermineront donc un polynôme de Lagrange d’ordre 3, celui-ci s’écrit :
exercice 23
Soit Zc[]\tdLg \ z . Les points d’appui sont :
¡
\ g
ß Zc[]\ ¡ drg y
z y
\kyBg Zc[]\kymdrg
\Wzÿg h Zc[]\Wzqdrg
\Wÿg
\ g ß
Zc[]\Wqdrg
Zc[]\ ~drg zy y ô
Le polynôme de Lagrange est donc d’ordre 4. Il s’écrit
avec
K¡ [e\td g ß8 £ s\ [e\ Sd
[]\ d
[e\ ßÆd
y
[e\td g ì \s[e\ ßÆd~[e\ Sd
[]\àß7d
z
[e\td g £ []\ ßÆd
[]\ Sd
[]\ Sd~[e\ ßÆd
[e\td g õ \s[e\ ßÆd~[e\ Sd~[e\ ßÆd
8[e\td g ß8 £ \s[e\ ßÆd
[]\ Sd
[]\ dqô
Finalement,
!
"# %$&
$
"# %'(
' )
*
)
+ / +
0 21 +
0 21 ,
"13+ 4 ,
0 21 +
0 21 ,
+(,.- +*,
+5 / ,
0 / +
0 61 +
0 61 ,
"1 + / ,
0 4 +
0 4 ,
+*,
+ / ,
0 4 +
0 21 +
+(,.-
+ 1879: $ +<;
+&-
\ Ç
Calculons l’erreur théorique sur cette interpolation. celle-ci est donnée ou point
§y
par :
?
w x ¦
x §
[]\tdLgZc[e\td [e\tdLg by [e\tdc [l Sdqè Z µ¶ · []Á ¶ db`
où, Á¹à[ =ùóòM\_^a`*=?>A@M\_^]dNC
gÇ B . Elle vérife,
Î [e\tdÎåÏ«Î ¦ x§ y~[]\tdSÎ [l dqè É x§ y
où x
¦ x§ yq[]\td g F ¢¡ [e\\ d
xÉ § yrg =?DFE
>G @ μZ x§ y [IHdSÎ
é Ç
Comme ici on a points d’appui, cette erreur est majorée par :
z z
On a clairement ¦ [e\tdLg F ¢¡ []\Mê\ dKgñ\s[e\ Sd~[e\ £åd . Il reste à calculer É g
8
ß ´
£
h s
\ ¬
[
¤
8
h \ z ¤8\ d
=?DFE
>G @ μZ [HdÎöô Un calcul assez long donne : Z µ · []\tdçg
[ \ z dJ
(Ceci peut être par exemple obtenu en décomposant Z de la facon suivante, Zc[e\tdKg
§ y g zy ô y § y ^ zy ô y y ^ . On calcule alors la dérivée d’ordre KÄ[ y §y L d µ Mq· , ce qui est
yplus ¶ î simple, ¶ ä N ¶ N ¶
Ó g O z Ó
P O \RQ [ S zO \td z S O \RQ
g [[ Sd ß \tO d
N ..
SO
µ Mq· g [ SdT O M K§ è y
.
P O \ Q [ S O \td M
d’où N N
^] Î [ zy Sd Î Î [ zy dÎ y
Z [ z d
Par consq́uent , l’interpolation de Lagrange, dans ce cas,
donne une bonne approximation de .
exercice 25
Soit Zc[e\td g ðóòÐ\
Estimons la valeur de ðò$[¬hiôõ´d
grâce à une interpolation de
Lagrange basée sur les points d’appui donés dans l’exercice. Le polynôme de
K
Calculons tout d’abord les nombres [hi`Fõ´d , on a
K¡ [¬hi`uõ´d g []¡\\kyd~[e\¡ á\Wzqd
[e\¡ \Wqd
[e\ \kymd
[]\ á\Wzqd
[e\ \Wbd
g [÷[hihi`/`/Sd~d
[÷[÷hihi`/`FS¤Æd~d
[÷[÷hihi`b`ußÆ£´d d
gU õ
De même, on trouve :
y [hi`Fõ´dBg ß `
z
[hi`Fõ´dBg ¤ß `
[hi`Fõ´dBg ¤ ô
õ
w
Ainsi, S[¬hi`uõ´d g c
Z
[ i
h u
` å
£ d L¡ [¬hi`FõÆd Zc[¬hi`FéÆd y~[hi`Fõ´d Zc[hi`bíÆd zS[¬hi`uõ´d
Zc[¬hi`uì´d S[hi`Fõ´d soit w [¬hi`FõÆdKgU
h`bé7hÆëÆëÆ íÆé .
Méthodes numériques avec Java 132
Ç
Estimation de l’erreur théorique dans ce cas. Elle est majorée par
¦ x§ y~[]\td /x §
Î []\tdSÎåÏ [el Sdqè É y
x§
où É x § Ky g_=>Ç @ Î|Z µ y · [e\tdÎ , donc
Î [e\tdSÎåÏ«Î [e\\ ¡ d
[]\\kymd~[e\\Wzqd
[e\\WqdSÎ £¢ è É`Sô
z etCherchons É . On a Zc[e\tdKgñðóò [e\td , Z Ó [e\tdLg ¶ y ¡m, Z Ó []\tdNgX ¶ y î . Donc
` Z µ · [e\tdLg
Z µ · [e\tdLgU .¶ J b . Ainsi, `É Þg μZ µ · [¬hi`u£´dSÎ
g µ J ·b g z J Jdc h .
¶.a Donc,
Ç
[e\tdÐÏ«ÎÝ[]\ hô£åd~[e\àhiôéÆd
[]\àhiôíÆd~[e\ hiôì´dSÎ ß8 £ ßÆõé8õ h ô
Ç Ç
y
Ainsi, [¬hi`FõÆdMÏ z . En fait, on a
¬
[ i
h
ô ´
õ d ]
. Or, la valeur exacte
ßÆé7õ ] 4
£´h7ëÆõ
de ðóò [hiôõ´dLgX÷hiôöé hÆì´ß7õ . L’erreur effectivement commise lors de l’approximation
J
w w
de ðòÂ[¬hôõ´d par S[hiôõÆd est donc Î S[¬hôõ´dcp[÷hiôéhÆì´ß8õ´dSδgXìiôé c /h ä ] ßÆé8 õ .
Donc, dans ce cas, l’interpolation de Lagrange donne un bon résultat.
exercice 26
a) On cherche la formule de Lagrange dans le cas où les e points sont
tf¹
h`/Æ`bß`
ôô=ô` Ð\_^ § y¡ \_^kg g ¶ käå¶
équidistants.
\_^sgþ\ ¡ f
Dans ce cas on a f hg *e`i kj , (où j <l
\¹ \ `m\
), d’où
mj . D’autre part, pour tout , il existe un réel n tel que
Méthodes numériques avec Java 133
x
g © ¢¡m © ¢® n¾
w [¬hôöé8£´d g
s
u ¢¡ Zc[e\ d K []\td g s F ¢¡ cZ []\ dUo [rnSd g
hiôõiõ/£åß ÷hiôõõiìÆõ .
Finalement,
. Alors que la valeur exacte est
x
exercice 29
SoitZc[]\tdLg y § y ¶ î . Le polynôme x x
d’Hermite t s’écrit,
x
t [e\tdLg F ¢¡ []\tdmZc[]\ d F ¢¡ Ø []\tdmZ Ó [e\ d
× [e\td g uuÞàߢ[]\ z \ d Ó []\ dv z [e\td
avec
D’autre part,
\ g£
terpolation d’Hermite montre que l’erreur effectivement commise est plus petite
{Àhi`Fé
}
que cette erreur théorique, (laissé en exercice). En outre, la valeur est rela-
tivement proche du bord de l’intervalle d’interpolation qui est , et en général,
pour l’interpolation de Lagrange ainsi que celle d’Hermite, l’erreur s’amplifie au
bord de l’intervalle d’interpolation (ce phénomène est dit de Runge), voir la partie
travux pratiques.
[]\_^a`
^ed
* pour hÏ fNÏ l , les n points d’appui du calcul d’interpola-
\ s’écritx : N
Soient
tion. Le calcul de l’interpolé en
avec
x y
ª Ó g © ¢ ¡mä © ¢® [e\ \ © d
x
¦ x e[ \td g ¢¡ [e\\ © d
©
Pour effectuer ce calcul, on utilise un fichier pour récupérer les coordonnées
des points de support. On écrit pour cela une classe TableauFileIn, similaire
à celle écrite dans le paragraphe 3.4.4 et qui effectue ce travail. Les deux tableaux
des abscisses et des ordonnées sont lus l’un après l’autre. Cette classe correspond
à :
import java.io.*;
import java.util.*;
class TableauFileIn {
FileReader fichier=null;
BufferedReader lecbuf;
String line;
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;
}
import java.lang.*;
import java.io.*;
import java.util.*;
import TableauFileIn;
class InterPoly {
int n; // nombre de points d’interpolation
double [] xk; // abscisses des points d’interpolation
double [] yk; // ordonnes des points d’interpolation
double [] ydp; // coefficients de la formule d’interpolation
Méthodes numériques avec Java 138
// 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;
}
import java.lang.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import TableauFileIn;
import InterPoly;
import DomaineDouble;
import DomaineInt;
import ManipGraphe;
import FenetreGraphe;
}
}
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;}
}
class PrgInterPolyGra {
public static void main(String args[]) {
// lecture du fichier de données
TableauFileIn f = new TableauFileIn("donnees.dat");
double[] xlu = f.lectureTableau();
double[] ylu = f.lectureTableau();
f.fermer();
x.show();
}
}
Nous montrons les résultats obtenus pour deux exemples :
Premier exemple
Le fichier d’entrée qui a été utilisé pour les coordonnées des points d’appui
est composé de 4 points et permet d’obtenir un résultat prévisible et satisfaisant.
Il correspond aux données suivantes :
4
0.4 0.5 0.7 0.8
4
-0.91 -0.69 -0.85 -0.22
Deuxième exemple
Méthodes numériques avec Java 142
Zc[]\tdLg \ z
Runge a montré que l’erreur commise entre cette fonction et son interpolation
polynômiale tendait vers l’infini lorsque le degré d’interpolation tendait lui-aussi
vers l’infini.
[e\_^"` F^*d
terpolation qui passe exactement par ces points. Dans ce chapitre, on cherche à
construire une courbe qui, dans un sens à préciser, s’approche des points Y ,
ces points pouvant provenir de mesures, par exemple, et donc contenir des erreurs
expérimentales.
ci
p(x)
xi x
?[e\td
On recherche donc une fonction d’approximation, encore appelée modèle et
notée K qui va répondre à cette question. Ce modèle dépend de paramètres :
144
Méthodes numériques avec Java 145
par exemple, s’il correspond à une fonction polynôme d’un degré donné, les pa-
ramètres sont les coefficients du polynôme.
Le problème que l’on se pose consiste donc à rechercher le meilleur jeux de
paramètres de façon à ce que la courbe représentative du modèle passe “au plus
prêt” des points de données.
La notion de meilleure proximité retenue ici est le critère des moindres
x
carrés. Il consiste à rechercher le minimum de la fonction :
[K?[e\_^]dYb^]d z
^ ¢¡
Le minimum est réalisé pour des valeurs particulières des paramètres qui cor-
respondent donc à l’ajustement du modèle par rapport aux points de données.
y
y=ax+b
ci
x
xi
y
y=ax+b
ci
ei
ax+b
i
x
xi
x
Il faut donc résoudre le système linéaire suivant d’ordre 2 :
ÙÚÚ
Û Ú t » gX¥ß ^ ¢x ¡ \_^[ Yb^Wà»Æ\_^Ô ½qdLgph
ÜÚ t
gX¥ß ¢¡ [ Yb^W »Æ\_^Ôà½qdLgph
½ ^
ÙÚÚ x z x x
C’est à dire
Û Ú » ^ ¢x ¡ \ ^ ½ ^ ¢¡ \_^kg ^ ¢x ¡ \_^ Yb^
ÚÜ
» ^ ¢¡ \_^ [l d½Rg ^ ¢¡ YF^
de la dernière équation, on en déduit que
½Rg
YÐ »z\ x
où l’on note \ , la moyenne des \_^ , à savoir
¢ ¡ \_^ .
l ^
x x
En substituant dans la première équation, on obtient
x
» \ ^z &[ YM » \o d \_^og \_^YF^
^ ¢¡ ^ ¢¡ ^ ¢¡
Méthodes numériques avec Java 147
En utilisant la variance x x
g¶ l ` ^ ¢¡ [e\_^W\t d z g l ^ ¢¡ \ ^z \ z
x
on obtient :
»Ô[l Sd ¶ g ^ ¢¡ \_^IYF^t [l SdA\ Y
Et donc la valeur de » vaut :
x
\_I^ YF^Ô [l Sd\| Y
^ ¢¡
»g [l Sd ¶
Il reste alors à déterminer la pertinence du calcul de régression linéaire par
x
rapport aux données. Pour cela, on définit le coefficient de corrélation linéaire :
\_I^ YF^t [l SAd \ Y
^ ¢¡
g
[l Sd ï ¶
Î Î
représentatif de ces données ;
– Si est voisin de 1 alors les points de données sont proches d’un aligne-
ment et le calcul de régression se justifie.
import java.lang.*;
import FoncD2D;
import java.lang.*;
import java.io.*;
import java.util.*;
import java.awt.*;
import TableauFileIn;
import Reglin;
import DomaineDouble;
import DomaineInt;
import ManipGraphe;
import FenetreGraphe;
import MaxminTabDouble;
class PrgReglin {
public static void main(String args[]) {
// lecture du fichier de données
TableauFileIn f = new TableauFileIn("donnees.dat");
double[] xlu = f.lectureTableau();
double[] ylu = f.lectureTableau();
f.fermer();
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ésultats sous forme texte qui sont les suivants :
java PrgReglin
$[e\tdLg © ¢¡ O ©
© []\td
du type :
K
Les fonction © sont connues alors que les coefficients © sont les paramètres
à ajuster par rapport aux données.
O
^
Un tel modèle est appelé linéaire en raison de son expression qui est effecti-
vement linéaire par rapport aux paramètres .
O ÿ
à g ¡ []\td¥g
?[]\tdLg ¡ y"\
,
y
[e\tdLg \
On retrouve le modèle de régression linéaire en posant et
. L’expression du modèle est donc K _Y Y .
Méthodes numériques avec Java 151
x
moindres carrés qui consiste à rechercher le minimum de la fonction
¡
[ O ` O yF`/ô/ô/ô~` O d g ^ ¢¡ [ Yb^WK$[e\_^edd z
x z
g ^ ¢¡ YF^W © ¢¡ O ©< © []\_^d
chaque coefficient , gñhÞô
ô/ômà , sont nulles :
Ce minimum est atteind lorsque les dérivées partielles de par rapport à
O
Méthodes numériques avec Java 152
[ O ¡ `/ô
ô/ ô
` O d g h
x
ß ^ ¢¡ Yb^W © ¢¡ O ©© [e\_^d [ [e\_^edd g h
O
x x
©© [e\_^]d [e\_^]d g Yb^ [e\_^d
^ ¢¡ © ¢¡ x O ^ ¢x ¡
© [e\_^]d © [e\_^]d g [e\_^dYb^
© ¢¡ O ^ ¢¡ ^ ¢¡
C’est une équation linéaire à Ã inconnues : O © , g«hi`
ô/ô/ô
`mà qui se décline
pour chaque valeur de , ghi`/ô/ô/ôq`uà . On doit donc résoudre un système d’ordre
à .
6.3.1 Ecriture matricielle du problème
On pose matrice d’ordre [l 7 `uà Sd dont les coefficients valent :
?^ © g © [e\_^d
et on pose
¡ x
le vecteur de composantes q[ Y `/ô/ô/ô~`Y d .
On peut montrer que le système précédent s’écrit :
D
u vz g D
u v
La solution correspond aux [eà S d coefficients O ^ cherchés. En effet
x x
D
u v
D
g ^ ¢¡ u v ^ _^og ^ ¢¡ [e\_^dYb^
x
uu vzv g
D
¢¡ u v © © g ¢¡
D []\_^d © [e\_^d ©
© © ^ ¢
¡ O
import vecteur;
import matrice;
import sysGeneLU;
import SysLinException;
import FoncD2D;
Modlin(FoncD2D [] foncbase) {
m = foncbase.length;
phi = foncbase;
}
import java.lang.*;
import java.io.*;
import java.util.*;
import java.awt.*;
Méthodes numériques avec Java 155
import TableauFileIn;
import Modlin;
import DomaineDouble;
import DomaineInt;
import ManipGraphe;
import FenetreGraphe;
import MaxminTabDouble;
class PrgModlinPoly {
public static void main(String args[]) {
// lecture du fichier de données
TableauFileIn f = new TableauFileIn("donnees.dat");
double[] xlu = f.lectureTableau();
double[] ylu = f.lectureTableau();
f.fermer();
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
java PrgModlinPoly
coef. 2 : -0.3026973026973027
coef. 3 : -0.07925407925407925
Le résultat obtenue reste assez éloigné des points de support car le degré
du polynôme est relativement peu élevé par rapport aux variations des points
de données. On montre ci-dessous comment il est très simple de construire un
nouveau modèle, ici un polynôme de degré 9, et de l’intégrer au programme de
test. Toutes les classes utilisées sont suffisamment génériques pour ne pas avoir
besoin d’être modifiée. Le programme de test devra définir toutes les classes
qui vont permettre de construire les fonctions de base nécessaires, appelées ici
Fbasexxx. Il ne restera plus qu’à les instancier effectivement et utiliser ces
instances pour construire le tableaux des fonctions de base. Tout le reste reste
inchangé. Voici ci-dessous la partie de programme à modifier :
...
Méthodes numériques avec Java 158
...
class PrgModlinPoly {
public static void main(String args[]) {
// lecture du fichier de données
TableauFileIn f = new TableauFileIn("donnees.dat");
double[] xlu = f.lectureTableau();
double[] ylu = f.lectureTableau();
f.fermer();
...
Les résultats obtenus sont donnés ci-après, ainsi que la fenêtre graphique
générée dans la figure 6.6.
java PrgModlinPoly
?[]\tdKgp»iy
)S[hiôé
\td »´zmùò$[¬hiôé
\td »å)S[7ôöé
\td »)Xùóò$[+Æôé
\td
K
La partie de programme à modifier est la suivante :
...
Méthodes numériques avec Java 160
class PrgModlinTrigo {
public static void main(String args[]) {
// lecture du fichier de données
TableauFileIn f = new TableauFileIn("donnees.dat");
double[] xlu = f.lectureTableau();
double[] ylu = f.lectureTableau();
f.fermer();
...
Les résultats numériques et graphiques (cf. figure 6.7) sont donnés ci-après.
java PrgModlin
Exercice 46 :
.......
Exercice 47 :
.......
Exercice 48 :
.......
Exercice 49 :
.......
Méthodes numériques avec Java 164
exercice 22
exercice 23
exercice 25
exercice 26
exercice 29
Chapitre 7
Intégration Numérique
Z Z
Les méthodes d’intégration numérique, interviennent essentiellement lorsque
une primitive de est d’expression assez compliquée ou inconnue, ou lorsque
n’est connue que par points, par exemple si elle résulte de mesures physiques,
on peut l’approcher alors par interpolation ( chap. précédent), puis on intègre
numériquement l’interpolée. On traitera seulement les intégrales du type :
B k
g Zc[]\td& Æ\
où {À»_`F½u} est un intervalle fini de IR et Z est continue sur {¼»_`F½u} .
7.1 Méthodes des Rectangles
7.1.1 Méthode des Rectangles supérieurs et inférieurs
f(x) f(x)
¡ ¢#
# ¡ ¢# ¡ ¢¡ ± ²#
²# ± ²±
«ª© ¬«ª©#¡#
¬# ¬«ª© ¢# ¡ ¢# ¡ ¢¡ ²±#²# ± ²±
«ª© ¬#
¬# «ª© ¡# ¬«ª© ¢# ¡ ¢# ¡ ¢¡ ²±#²# ± ²±
¥#¥# ¦ ¦ ¦ ¡#¢##
¥ ¥ © #
ª © #
ª #
¡ © ª ¡ #
¢ ¡ ¢¡
¢# µ#
¶ µ# ¶ µ# ¶ µ¶ ²±#²# ± ²±
¥#¦# ¥ ¦# ¥ ¦¥ ª ª ¡# #
© #
© © ª ¢# ¡ ¡ ¢¡ ¯#¯#¶# µ ¯ ¶# µ ¶# µ ¶µ ²±#²# ± ²±
§ ¨§#¥#¨§ ¦#
¨# ¥ ¦# ¥ ¦¥ ª# © ª# © ª© ¢# ¡ ¢# ¡ ¢¡ ³#´# ³ ´# ³ ´³ ¯#
£ ¤#
¤# £ ¤£ §# #
§ § © #
ª © #
ª #
¡ © ª ¡ #
¢ ¡ ¢¡
¢# ³#´# ³ ´# ³ ´³ ° ¯# ° ¶# µ ¯° ¶# µ ¶# µ ¶µ ²±#²# ± ²±
¤£#¤# £ ¤£ ¨ ¨ ¥#¨ ¦# ¥ ¦# ¥ ¦¥ ¡#¢# ³#´# ³ ´# ³ ´³ ¯ °#
°# ¯ ¶# µ °¯ ¶# µ ¶# µ ¶µ ²±#²# ± ²±
¤£#¤# £ ¤£ ¨§#¨# § ¥#¨§ ¦# ¥ ¦# ¥ ¦¥ ª# © ª# © ª© ¡ ¢# ¡ ¢¡
#
³ #
³ ´ ³#
´ ³´ ¯#
° ¯# ° ¶# µ ¯° ¶# µ ¶# µ ¶µ ²±#²# ± ²±
¤£#¤# £ ¤£ § ¨#
¨# § ¥#¨§ ¦# ¥ ¦# ¥ ¦¥ ¡#¢# © #
ª © #
ª #
¡ © ª ¡ #
¢ ¡ ¢¡
¢# ®#
®# ® ´# ¯ °#
°# ¯ ¶# µ °¯ ¶# µ ¶# µ ¶µ ²±#²# ± ²±
¨§#¨# § ¥#¨§ ¦# ¥ ¦# ¥ ¦¥ ª# © ª# © ª© ¡ ¢# ¡ ¢¡ ®#
®# #
³
³#® ´# ³ ³ ´³
´# µ ° ¶# µ ¶# µ ¶µ
¤£#¤# £ ¤£ ³ ³ ´³ °#°#¶# ±#
² ±# ² ±²
§ ¨#
¨# § ¥#¨§ ¦# ¥ ¦# ¥ ¦¥ © #
ª © #
ª #
¡ © ª ¡ #
¢ ¡ ¢¡
¢# ®#®# ® ´# µ ¶#
¶# µ ¶# µ ¶µ ²±#²# ± ²±
x x
Figure 8 Figure 9
x1 x2 x x
§
3 4
Figure 10
Cette fois-ci on prend pour chaque sous-intervalle { \_^"`m\_^ § y"} , Zc[ ¶ z¶ ²´³ d
¶ Ʋ ³ cZ []\td& Æ\·}jWZc[ \_^ \_^ § y d
comme hauteur du rectangle, on a alors
¶ ß
x y § x y
d’où
ä \_^ \_^ y dLg ä jWZc[e\ ¡
ß f Wj d
Zc[]\td& Æ\·} ¢¡ jWZc[
^ ß ^ ¢¡ ß
On démontre que l’erreur de cette méthode est :
^tg j¤ [¬Zc[e\_^ ä yd £åZc[]\_^ed Z[e\_^ § ydd
Méthodes numériques avec Java 168
Ceci donne l’approximation de Simpson ¼ de B , en sommant les aires
^ pour
fgX lÄ
à . Finalement :
¼ g j¤ {ÀZc[e\ ¡ d Zc[e\Wz0Åd £_{Zc[]\kyd Zc[]\Wbd j jj
Zc[]\Wz0Å ä yd"} ßi{Zc[]\Wzqd Zc[]\qd jjj Zc][ \Wz0Å ä zbd"}}
c’est à dire :
Å y
{¤ ÀZc[e\ d cZ [e\Wz0Åd £ F y Zc[]\Wz ä yd ß Fä y Zc[]\Wz d"}
¡
Å
¼¥g
j
Ç
On démontre que l’erreur ¼
g B ¼ commise par application de Simpson est
Ç
[ M
½ » (d j
donnée par :
¼¥gU Z µ · [eÁåd¥`BÁ¹ {¼»W`u½F}
/
Æ
ì h
Donc si ` É R¿g =>@ À Î|Z µ · I[ HdSÎ , alors
ÂÁ Ç
¬
[ M
½
Î ¼¢ÎåÏ ìÆh e `É » d
mation que celle des trapèzes, ( sous certaines conditions de régularité de Z , voir
Remarque 7 En général la méthode de Simpson donne une meilleure approxi-
z
références ...), car l’erreur commise lorsqu’on applique les trapèzes est propor-
tionnelle à j , alors que pour Simpson elle est proportionnelle à j , et comme par
[¬½Nà » dmÉàzy(j
ä Éá<z j
Rectangles
yz ¡ `
ä É j
Trapèzes
y Æ
Simpson
g Ç t[¬hÆd&g Ç cZ []\td Æ\
C’est un procédé d’accélération de la convergence d’autres méthodes comme
g äx
les trapèzes. En général pour calculer B B Ã & , on fixe un pas
j
et on approxime B t[h´d
par B qj o[ Wd [ Wd [ Wd
rj , où rj est l’erreur commise,
avec l’hypothèse Z
que cette erreur tend vers 0 avec j pour suffisamment régulière.
Méthodes numériques avec Java 169
o[ Wd t[ z d t[¬h´d
L’idée de l’algorithme de Romberg est de prendre une combinaison linéaire de
B qj et de B ¼ qui donnera une meilleure approximation de B
t[ d ¼ jjj
, puis de recom-
Ç
t[h´d g x [ Wd
mencer avec B , etc .
x g
g t[ Wd
Prenons par exemple la méthode des trapèzes on a B
» ¿»X¼ _B rj désigne l’approximation pour n subdivisions de
» rj où
de longueur {À»_`F½u}
j .
Dans le cas où l’on peut faire un développement limité en j on a :
x g¿Bt[¬hÆd i» y(j z »´z<j jjj » j z M j z MAÇ [rjWd
»
M
donc l’erreur estÇ
x x
dans lequel, pour clarifier les notations, les\ valeurs
x \ x x x
trapèzes seront notées »$y &` »?y z (` »$y `/jjj , au lieu de » (` »tz (` » `/jjj De même
obtenues directement par les
on notera »
~
x ~
x
`(» z jjj le résultat de la combinaison de Romberg, voir le
tableau ci-dessous qui résume cet algorithme :
Ê
Ê »
Ê Ë $y x $y z x
» Ë $y x
» Ë $y x
» Æ Ë jjj
Ox x ÌÏÍ »tz x O
Ê
Ê
Ê
Ê »t
Ë z
ÌÎÍ »tËz z O ÌÎÍ jjj O
Ox x
Ê
Ê
Ê
Ê »t
Ë
ÌÎÍ »t z O Ì8Í jjj
Ê
Ê
Ê
Ê » O
x ÌÎÍ jjj
Ê ..
Ê .
oz x
Remarque 9 . On remarque que dans la deuxième ligne du tableau de Romberg,
» est exactement le résultat de la méthode de Simpson.
Méthodes numériques avec Java 171
g Zc[e\td ´\
Exercice 50 :
a) Donner les formules des rectangles approchant B ÓÃ .
l {Àh`/
}
b) Trouver l’erreur commise en appliquant la méthode des rectangles, ainsi que le
nombre minimum de subdivisions de pour avoir à w à 1/100 près ¡ y ¶ î Æ\
c) Donner la méthode des rectangles à point milieu.
d) Trouver l’erreur commise en appliquant la méthode des rectangles à point mi-
lieu. Même application qu’à la question b).
Exercice 51 :
Déterminer par le méthode des trapèzes puis par celle de Simpson Ã^Ô ¡ î Z[e\td& Æ\ sur
la base du tableau suivant :
\ h Õ|Ö7ì Õ|Ö
£ ¤Õ|Ö7ì Õ|Ö7ß
Zc[e\td h hiô¤Æì´ß7õ7ìƤ hôöí7hÆíh´í hiôë´ß7¤ÆìÆì7h
Ces points d’appui sont ceux donnant ùóòÐ\ , comparer alors les résultats obtenus
avec la valeur exacte.
Exercice 52 :
¦
On lance une fusée verticalement du sol et l’on mesure pendant les premières 80
secondes l’accéleration :
¦ [ ~[ol à l Sd z d ¤Æh h ¤i7ôh õƤ ¤Æ¤i8ß Àô h £Æ£ ¤´éƤ Àô h £åí ¤´í ´£ öô h íÆé £´hi8é ô h ¤Æ¤ £Æ¤iÆõ öô h ß8ë £´õi7í ô h í7h é7hiÆì ô h õ´í
H w n
w ÏÖ)n
Calculer la vitesse V de la fusée à l’instant t=80 s, par les Trapèzes puis par Simp-
son.
g ¡ ùóòk[e\ z d& Æ\
Exercice 53 :
Calculer à l’aide de la méthode des Trapèzes l’intégrale B ×ÃÙØ (avec
N=5 puis N=10 points d’appui).
Exercice 54 :
{Ý K` k} hiôéh ä g
Trouver le nombre N de subdivisions nécessaires de l’intervalle d’intégration
2Õ (Õ , pour evaluer à près, grâce à Simpson, l’intégrale : B
ä Ø ¢\ Æ\
Ã~Ø ) .
Exercice 55 :
Evaluer a l’aide de la méthode des Trapèzes, l’intégrale : ÃÚ`
Ø ÛÂÜ ¡ ü ¶ Æ\ , avec une
erreur inférieure à
. h ä ¶
Méthodes numériques avec Java 172
Exercice 56 :
¡ y y § y Æ\ h ä
Evaluer a l’aide de la méthode des trapèzes puis celle de Romberg basée sur les
trapèzes, l’intégrale : Ã
¶
, avec une erreur inférieure à .
Comparer les vitesses de convergence. Comparer à la valeur ’exacte’ .
[e\td g ¡ ¶ ä
Exercice 57 : D
Soit à H w H . Combien faut-il de subdivisions de [0,1] pour evaluer
[+Sd /h ä
a
Æ près en utilisant
1. la méthode des trapèzes
2. la méthode de Simpson
Méthodes numériques avec Java 173
[]\tdg ¡ ¶ z ä
Exercice 58 : D
Soit ÝÃ H w H . Combien faut-il de subdivisions de [0,1] pour evaluer
[+Sd /h ä
a pres en utilisant
1. la méthode des trapèzes
2. la méthode de Simpson
[e\td
1. Donner l’erreur commise sur le résultat si on se contente du développement
à l’ordre 6 de .
2. Estimer alors [+Sd à cette erreur près, et comparer à la valeur ’exacte’ ob-
tenue par votre calculette.
[e\tdLg ¡ ¶ ä î
Exercice 61 : D
Soit à w )H .
{Àh`/
} pour evaluer [+Sd à /h ä z près ? z
1. En utilisant la méthode des trapèzes, combien faut-il de subdivisions de
z
Soit á[e\tdLg_Ã ¡ ¶ ) [IHd& )H .
Exercice 62 :
[e\tdLg ¡ ¶ ùóò$[IHd"
)/[Hd& )H .
Exercice 64 :
Soit _Ã
1. En utilisant la méthode de Simpson, combien faut-il de subdivisions de {¼hi`/
}
pour évaluer [Sd à h ä près ?
2. Déterminer alors [d par la méthode de Simpson à /h ä près .
Soit [e\tdLg_Ã ã
Exercice 65 :
¡ ¶ â >7ò$[Hd )H .
{Àh` Ø } pour évaluer [ Ø d à /h ä près ?
1. En utilisant la méthode de Simpson, combien faut-il de subdivisions de
z
Soit [e\tdLg_Ã y ¶ ðòÂ[H d )H .
Exercice 66 :
y
Soit [e\tdLg_Ã ¡ ¶ y § D )H .
Exercice 67 :
µ ·î
{Àh`/
} pour évaluer [Sd à h ä près ?
1. En utilisant la méthode des trapèzezs, combien faut-il de subdivisions de
2. Déterminer alors [d par la méthode des trapèzezs à h ä près .
Exercice 68 :
Soit B&g
Zc[IHd& )H . On considère une subdivision de {À»_`F½u} en l sous intervalles
égaux de bornes H"^ogp» Ç mf j , où fsgh`/jjjk`ul , » C g ¡ g H x et jg ½ » .
H , ½RC
1. Retrouver l’erreur ^+q[ jWd commise par la méthode des trapèzes sur un sous
Çl
§
intervalle { H"^a(` H"^ y+} . Montrer que la formule générale de l’erreur g_B
»X¼
commise par application de cette méthode, sur tout {À»_`F½u} , est donnée par :
Ç
¬
[ M
½ à
» (j z
d
¼¥gX
Sß XZ ¾_[eÁåd
`BÁÇ ¹à{¼»_`F½u}
En déduire que si ÉázM_ g
=?>A§ @ À Î|ZÔÓ eI[ HdSÎ , alors Î ¼¢ÎåÏ µ y0zä · a É z .
w ä D ä ÂÁ î
2. Soit Zc[ HdKg et B
äg
Hz y ZcI[ H&d )H .
Méthodes numériques avec Java 175
y
(a) Montrer que BåäXgçæiy où æiyÐg ¡ no[ ètd& è et où no[ ètdg w ä é ³ , (penser
à un bon changement de variable).
(b) En utilisant le fait que ê ðùÂ= ¡ w ä é ³ gUh , approximer æy par la méthode
²
des trapèzes. Si j g hiôäé ë donner la valeur approchée de æiy par cette
méthode.
(c) Combien faut-il de subdivisions de [0,1] pour évaluer æiy à /h ä près
en utilisant la méthode des trapèzes.
¡ § ä §ì
§ § g à §y ä ¶ ¶.a ,§ ì on l’écrit sous la
Exercice 69 :
Pour approcher numériquement l’intégrale B
forme BVg Ø ØÐ Ø g
ä où Ð íÃ
Ð ì¡ et y ¶ ¶ Ø ä gíà Рy ¶ ¶.a (Ì réel stricte-
ment positif). .a
1. Montrer que l’on peut déterminer un réel strictement positif tel que Ø äUÏ
y h ä .
z(Indication Ì
: majorer y §
y par y d .
.¶ a .¶ a
2. Pour calculer Ø Ð , on utilise la méthode des trapèzes :
(a) Rappeler la formule des trapèzes ainsi que l’erreur commise par son
É gpÃÅ»Æ\ m¡ ¼Î Z W[]\tdSÎ
application. Donner une démonstration de l’erreur.
(b) Exprimer en fonction de À Ð X¾ le nombre N de points
Ø
zy h ä
d’intégration nécessaire pour calculer Á Ð avec une erreur inférieure à
.
(c) Trouver É et en déduire N.
Méthodes numériques avec Java 176
g ¡ Ôî Z[e\td& Æ\
B Ó
a) Soit » l’approximation de B par la méthode des trapèzes, le pas j est donné
g ¶ käå¶
par, j <l ØÆ . g
¡
» g c
Z ]
[ \ d Z c ]
[ k
\
y d ß c
Z ]
[ _
\
^ d
j
ß ^y
g
b) Soit l’approximation de B par la méthode de Simpson. Celle-ci s’écrit,
g j¤ [ ¡ % £_[ y 7bd %ß 7zbd
g Õ ì ô ¤ï î ¬[ h £W[hiô¤7ìÞjjj h ôë´ßÐjjjmd ߥjShiôí7h´íÆdmð
g 7ôhÆh7hi¤´é
ùóòR\
g ¡ î mùòÞ\ Æ\Vg
Les points d’appui donnés dans cet exercice correspondent à la fonction . Et
B Ã Ô ñ . On constate donc que l’approximation de B par Simpson
est meilleure que celle par les trapèzes, puisque òB et » óB Î ÂÎÆghiôh7hÆhi¤´é Î ÂÎ8g
hiôhSß7ìÆì7£
.
exercice 32
On sait que l’acceleration ¦ est la dérivée de la vitesse
, donc,
D
[IHdNg ¬[ hÆd ¡ ¦ [rnSd n
¡
[ìÆh´dKgñh ô ¡ ¦õ
ö [qnSd ÷n
Æ
G
Méthodes numériques avec Java 177
a) Calculons B par la méthode des trapèzes. Ici, d’après le tableau des valeurs,
j gUh
. x y
B g jß ¦ [e\ ¡ d ¦ [e\ x d ß ^ ä y ¦ e[ \_^d
g ß ô/hu"¤Æh é7h`Fõ´í ßi[¬¤iÆ`uõƤ ô=ôô £´õi`Fí7h´d&v
g ¤7hÆìÆëKÃçôøn ä y
b) Calculons B par la méthode de Simpson.
[¬ìÆhÆdBg j ¦ []\ ¡ d ¦ [e\ x d £W[ ¦ [e\kymd ¦ []\Wqd jjjFd ߢ[ ¦ []\Wzbd ¦ [e\~d jjjFd v
¤h
u
g ¤ u ¤Æh é7yhi`Fõ´í £W[¬¤Æ`FõƤ ¤´é`u£åí ôô=ôd ߢ[¤Æ¤i`u£Æ£ ¤´í`bí7é ô=ôôd v
g ¤ÆhÆì´ícÃçùô n ä
exercice 34
g ¡ mùóòÐ\ z Æ\
Soit
B k Ø
B g
Õ ßÕ ¤%Õ ëÕ
u mùò$[Õ z d ùóò$[h´d ߢ[mùòÂ[ d z ùóò$[ d z mùò$[ d z jjj mùò$[ d z d v
Õ
exercice 35
Soit
B g Ø
)¢\ñ Æ\
½ à
» ä Ø ß Õ
Le pas d’intégration est jg g e . D’autre part l’erreur théorique sur la
e
méthode de Simpson est donnée par
Ç
r[ jWdrg
[¬½MàN » d j Z µ · [eÁåd
Ç ìÆh
r[ jWdrg
ß Õ ô Aß Õ
¢Á
ìÆh eúQ
où Á¹à{À»_`F½u} , par conséquent,
Ç N
ß Õ ß Õ
Î q[ jÔdÎXÏ ûû ìÆh ô e
Q ûû
Ç û
û
û
û
c h ä il suffit que e vérifie Î ü Ø ¡ y J Ø b b ÎåÏ hôöé c /h ä ,
û û
Ainsi pour que Î q[ jWdSÎåÏ hiôé
ïý Õ õ%Õ . Ainsi e vérifie e ý /ìiôõ . On prendra e1gþß8h ,
donc, e
car pour Simpson,
hiôé c leh ä nombre
ëÆh de subdivisions de l’intervalle {À»_`F½u} doit toujours
être pair.
exercice 36
[¬½ » d Éázz ½Ï þ
Sß e
Méthodes numériques avec Java 179
ý ÿ [½M » d É z [ Sd
üÛÂÜ ¶ Setßþ
e
Cherchons É . On a
¶
mùóò ßÚ
) ß mùò
Ó
Ú
Pour dt́erminer les extremas de , on cherche alors les racines de .
Un calcul simple donne
( *)
) "! ) "# % $'& ! %$'&
On cherche donc les racines de l’équation,
+-,/. +1,/. . ( . 2 34)
0! "# $'& ! '$ &
D’où
+1,/. 5 6 . 8)
# 0! ! # $7&
+-,/. : 9 9 ; 9 =</> >@?
En supposant et ! # , c’est à dire Ø ,(
A 4B BC<D)')E)EF G I 9 HKJ <
), et , on obtient
(O
LNM & 5 ! )
! #
P Q</> R H J <
Ain,si les racines cherchées sont Ø ou ou celles de
l’équation TO
LSM & 2 ! =</*)
! #
Q</
Étudions alors cette équation
4B N
L M : Graphiquement,
en tracant les courbes
représentatives dans U ÕWV de & et de XZY\[]YC^ , on voit rapidement (à faire) que le
LSM
seul point d’intersection de & et de XZY\[] Y ^ est d’abscisse
X%[ Y*_ 2 `
.
X%[ Y _ 4B " P 0 bJ <
atteint ses extremas sur U ÕaV en
2 On en déduit que ou ou
Ø . 2 `
Cherchons c7$'d , le développement limité en de donne :
Y i ëfeg i i
i r
h j k )')E)mlnG<o )E)')ml < l t r ul
< p4q q s q
! #
i
r l )
#
Méthodes numériques avec Java 180
Application.
}
Prenons alors, , d’où [D
x , et donnons une approximation de
l’intégrale par la méthode des trapèzes : e
} . i i . } . } . *Z}
$'& T < $'& x 7$ & x E) )') '$ & x ll
< } } e Z } e
x e x x
e BS p s e e e
exercice 38
Soit
Y )
H [] H
e
x B
On a H [] H
e 4B
a) Cherchons le nombre de subdivisions de U V pour evaluer a D[
près en utilisant la méthode des trapèzes.
L’erreur de la méthode des trapèzes est :
(
<
D
donc, { { < ~ où ~ d E Mo 7¢ { H { . Ainsi, pour avoir
{ {£ ¤ , où ¤ [D , il suffit de prendre
N¡ subdivisions de l’intervalle
d’intégration telles que GD
~
< ¥¤
Donc, il suffit que vérifie,
G D
y ÿ
<¤ ~
¦ | "</ § |
Cherchons ~
{ I< a H
= . { On H [] , H H [] et H # H [] .
Donc ~ .
Méthodes numériques avec Java 181
y ª e©¨ , soit y x p / p /
Ainsi, l’inéquation (1) devient # . Avec #
X
subdivisions, l’erreur commise lors de l’approximation de cette intégrale par la
méthode des trapèzes serea plus petite que [D .
4B
b) Cherchons le nombre de subdivisions de U V pour evaluer a D[
près en utilisant la méthode de Simpson.
L’erreur théorique de cette méthode est :
w
/
Dr
{ { {
donc, ~ où ~ d E« Mo 7¢ { H . Ainsi, pour avoir { {
C¡
¤ , où ¤ [D , il suffit de prendre subdivisions de l’intervalle d’intégration
telles que D r
)
~ ¬¤
Donc, il suffit que vérifie,
GD r
y Q</
/ ¤ ~
p r
6 s
Cherchons ~ . On a H
H ]
[ H H ]
[ H H [] .
{ ® { p , et
Donc ~
.
y 4B
p
Ainsi, l’inéquation (2) devient x x , soit y # ! . On prendra
alors puisque, dans les cas de la méthode e*¯ e%°²± de Simpson, le nombre de
subdivisions de l’intervalle d’integration doit toujours être pair.
Méthodes numériques avec Java 182
return s*pas/3;
}
}
import java.lang.*;
import java.io.*;
import FoncD2D;
import TableauFileIn;
import NbSubException;
import ITrapFct;
import ISimpsonFct;
import ITrapTab;
import ISimpsonTab;
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;
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ès le fichier d’entrée utilisé par les méthodes travaillant
. Les
sur des tableaux.
4BS³valeurs
´/< ³µ´
suivantes correspondent à une tabulation de la
fonction $7& sur U V , avec un pas de .
5
0 0.382683 0.707107 0.923880 1
Les résultats obtenus sont les suiavnts. Ils respectent parfaitement les calculs
d’erreurs énoncés dans les paragraphes précédents.
java TestIntNum
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);
}
}
}
import java.io.*;
import FoncD2D;
import NbSubException;
import ITrapFct;
import Romberg;
class TestRomberg {
public static void main(String args[]) {
SinF f = new SinF();
double a=0, b=Math.PI/2;
java TestRomberg
¹ e
Remarque 10
¹
1. Si est une fonction du temps, il est d’usage de noter la
dérivée ¼½ par ¾ et de l’appeler vitesse. De même la dérivée seconde ¼ _ ½
sera notée¼ ¹ ¿ et appelée accéleration. ¼ E_
2. Si on considère une équation différentielle d’ordre supérieure
¹ À BS¹BS¹ B\Á²Á²ÁaBS¹ À x
H [
x B B\Á²Á²ÁWB À ¹0 x
on peut ramener le problème à celui d’un système d’équations différentielles
du premier ordre, en posant     et  on obtient le
189
Méthodes numériques avec Java 190
système : ÃÄÄÄ
ÄÄ
 x =Â
Å ÄÄÄÄ Â =Â
(8.3) ÄÆ ... ..
.
 À x = À
B x B B\Á²Á²ÁB À
ÂÀ[ = H Â Â Â
Exemple 6 Soit l’équation différentielle du second ordre :
¹
¹ ¹a
H # H H H
¹Ç x
posons Âx et   alors» cette équation se ramène au système :
 x =Â
 =#  x H x
Revenons au problème de Cauchy (2), un résultat fondamental est donné par le
théorème ci-dessous, mais rappelons tout d’abord la définition d’une application
lipschitzienne.
B
Définition 4 Soit f une application définie sur U VEÈ IR ; s’il existe une constante
ÉËÊ BSÌ BSÌÑ ÎÐ B Ñ { É { Ì5 {\Ò Ì8B ?
et Í telle que {ÏÎÐ H H Í
indépendante de H
?
B B Í Í
IR, et Ò H U V , alors Î est dite Lipschitzienne de rapport L sur U VEÈ IR (ou
simplement L-lipschitzienne).
B
Théorème 9 Si f est une ¹ application définie sur U Vk· IR continue et L-
¹ ¹ ?
lipschitzienne par rapport à , alors le problème de cauchy (2) admet une solution
unique sur [a,b] et ceci pour toute condition initiale , (Ò IR).
e e
¹
Proposition 4 Une condition suffisante pour que les hypothèses du théorème
soient vérifiées est que Î soit dérivable par rapport à et que sa dérivée soit
bornée. ( dem en exercice ...)
¹
Les différentes méthodes d’intégration se distinguent par la manière d’obtenir
ces Ó . La méthode d’Euler, est la plus simple et consiste à substituer la dérivée
¹D Ð Ñ
H ¼©½ par l’expression
¼
¹ Ð Ñ O¹ Ð Ñ
H H
(8.4)
[D
est le pas d’intégration numérique.
où
B B
Considérons alors une subdivision de U V en N sous intervalles U H©Ó H©ÓÖÕ x V de lon-
I4B\Á²Á²ÁaB ` I
gueur , Ô et H©Ó
¹ Ð Ñ n
Ô© ¹ , avec Ñ H ¹ Ñ et H©× ¹ . Ñ 3¹ Ñ BS¹4Ñ
L’expression (4) entraine H Ð H e Ð H d’où
BS¹ Ñ Ð H Ð H
Î Ð H .
Par conséquent, partant de la condition intiale H
¹ Ð ¹ Ð Ñ
, et prenant un pas régulier
H©ÓÖÕ x H©Ó , on obtient, en posant Ó approximation e e de H©Ó :
¹ n¹ BS¹ Ñ
(8.5) ÓØÕ x Ó ÎÐ H©Ó Ó
»
L’algorithme d’Euler s’écrit alors :
¹ ` ¹ Ð DÑ
¹ e x n¹ Î Ð BS¹ Ñ
donné
B\Á²Á²ÁWB
ÓØÕ
Ó ©H Ó Ó Ô
¹ ¹ Ñ
Interprétation géomètrique ÓÖÕ x approximation de Ð H©ÓÖÕ x est calculée à partir
BS¹ Ñ
de Ð H©Ó Ó calculés précédemment grâce à la formule de réccurence (5) et à la
¹ ÑÙ @¹ ¹
condition initiale Ð H
e e B ¹ Ñ
. On calcule une approximation de la solution en
x
¹ point H e Ô© en remplacant dans UH©Ó H©ÓÖÕ V la courbe intégrale Ð H passant par
tout
Ó par sa tangente en H©Ó .
Solution exacte
Solution Euler
inconnue
t0 t1 t2 t3 t4 t5
Figure 11
¹ ¹
Remarque 11 On dit que la méthode d’Euler est une méthode à pas séparés ou
à un pas, parceque le calcul de ÓÖÕ x ne fait intervenir que Ó .
Méthodes numériques avec Java 192
Remarque 12 1. Ce résultat s’exprime sous la forme { 1Ó { > , c’est à dire
que la méthode d’Euler est d’ordre 1.
¹T?ÝÜßÞ B ?ãÜ x Ð B Ñ
2. Pour que U V il suffit que Î U VEÈ IR .
On donne dans la suite des méthodes d’ordre plus élevé que celui de la méthode
d’Euler, donc plus rapides et plus précises.
B%¹tÑé?ëê Þ B Ñ É
Théorème 11 Supposons que ÎÐ H Ð U VEÈ IR , Î -lipschitzienne et
É ¹
æ-ç æ*ç Î x -lipschitzienne par rapport à uniformément pare rapport à H . Po-
æ æ ½ 3à2/á E« 7¢ { ¹ Ð Ñ {
sons ~ H , alors on a la majoration
C¡
Þ
{ 1Ó {]
Ð «â ì Õí °1_ î âDï [D
Ñ ~ É
!
3¹ G¹ Ð Ñ Ð S
B ¹ Ñe
où 1 Ó Ó H©Ó est l’erreur commise au point H©Ó Ó .
B 4B
où ô est une application continue de U VEÈ IRÈ0U V dans IR ; ( est le rayon
e e
de stabilité de la méthode, souvent on prendra ici ).
¹
e
Les notions théoriques que doit vérifier la fonction ô afin que Ó soit effective-
¹ Ñ
ment une approximation de Ð H©Ó sont la consistance, la stabilité théorique et la
convergence.
¹
Définition 6 Une méthode à un pas est consistante avec l’équation différentielle
si pour toute solution continue
à2/á { Ð ¹ Ð x ÑO¹ Ð Ñ Ð BS¹ Ð Ñ*B Ñ { `
c7$7d ©H ÓÖÕ H©Ó ô H©Ó H©Ó
åv e ð
? B ? B BNÑ ÎÐ B Ñ
Théorème 12 Une condition nécéssaire et suffisante pour qu’une méthode à un
pas soit consistante est que pour tout H U V et tout Í IR ô Ð H Í H Í .
¹ 34B\Á²Á²ÁWB
Définition 7 Stabilité théorique :
Soient Ó et Â1Ó (Ô » ) les solutions réspectives de
¹ x ¹ B%¹ B Ñ
¹ ÖÓ Õ ? = Ó ô Ð H©Ó Ó
IR donné
e
»
et de B B Ñ Ñ
Â1ÓØÕ ? x = Â1Ó Ð ô Ð H©Ó Â1Ó "õ Ó
Âe IR donné
On dit que la méthode à pas séparés est stable s’il existe deux constantes ñ x et
ñ Þ indépendantes de telles que :
¹ ¹ à2/á { {
d Ó oM { Ó Â1Ó {]nñ x { e  e { ñ Þ Ó õÓ
Ò ¹ ? IR
¹ ¹ Ð Ñ { I
c'$7d d Ó Mo { Ó H©Ó
e åv e
Théorème 14 Si une méthode à un pas est stable et consistante alors elle est
convergente.
Méthodes numériques avec Java 195
<
8.6 Résolution de systèmes différentiels dans IR
Þ
»
Dans IR soit le système différentiel :
¹ Ð Ñ ÎÐ BS¹B Ñ
Ñ nö Ð H BS¹B Â Ñ
H
 ÐH H Â
» d’Euler à ce système se fait composante par compo-
L’application de l’algorithme
sante d’où : ¹ `¹ BS¹ B Ñ
ÖÓ Õ x Ó ö Î Ð H©Ó B%¹ Ó B Â1Ó Ñ
Â1ÓÖÕ x 1Â Ó Ð ©H Ó Ó 1Â Ó
Cet algorithme s’applique aux équations différentielles d’ordre 2 (ou plus ...) à
condition de les réduire au préalable à des systèmes différentiels du premier ordre,
comme vu précédemment.
L’application d’autres algorithmes par exemple RK2 se fait moins simplement,
voir exercices corrigés.
Méthodes numériques avec Java 196
Exercice 71 :
Ì Ñ Ì Ì
1. Soit une suite Ð × × E
G de nombres réels positifs telle que ×²Õ x x × ? ,
Ì ×Ì
et sont des constantes positives ; montrer que ×
u÷ø[ x , ù .
? áã? Õ Ð áÑ × × Y e
C[
2. Montrer que Ò ù et Ò IR , .
3. Utiliser les deux questions précédentes pour démontrer le théorème 10 du
cours.
4. De même pour le théorème 11.
x
è)ú<
Exercice 72 :
Approcher la solution de ` 4)û<
l’équation différentielle ci-dessous en H en utili-
sant RK2, avec un pas
<
¹ Ð Ñ
`¹ Ð Ñü H ¹ Ð Ñ
H H ¹
H
Exercice 73 :
¹ Ñ ¹ /Ñj
En donnant les solutions de l’équation différentielle ci-dessous avec la condition
initiale Ð puis Ð ¬õ , õ réel non nul, vérifier qu’elle conduit à des
schémas instables. ¹ Ñ ÐH ¹ Ñü )
#/! Ð H #/ý []
Exercice 74 :
» suivant
Soit le problème de Cauchy
? 4 B
y’(t) = t + y(t), H U V
y(0) =1
Exercice 75 :
» suivant
Soit le problème de Cauchy
? 4 B
y’(t) = 2t - y(t), H U V
y(0) =1
Exercice 77 :
»
Soit l’équation différentielle du second ordre à conditions initiales :
¹ Ð Ñ o< ¹ Ð Ñ
I<o¹ Ð Ñ ? B
Ð ÑO¶ ¹ Ð D H Ñ H H
¹ Ð DÑ I<
, H U V
et
1. Ecrire cette équation différentielle sous la forme d’un système différentiel
de deux équations différentielles d’ordre un.
2. Appliquer la méthode de RK2 à ce système .
Exercice 78 :
»
On considère le problème différentiel
¹ Ð Ñ ÎÐ H SB ¹ Ð H Ñ*B%¹ ¹ Ð H Ñu Ñ ? B
ÐÑ ¹ Ð DH Ñ =
Ð Ñ ,
n
ÿ H U V
= þ et
B ¹ Ðá Ñ
¹ divise
On G¹ U V en m intervalles
¹ x de<o¹ longueur
¹ , dans (1) on remplace × par
×²Õ x × [ x ¹ Ð Ñ ×²Õ × ×[ x
<
Þ
et H par
» (1) se transforme en
1. Montrer que le problème
¹ ¹ %B ¹ Ñ Þ
Ð </Ñ ×¹ ²Õ x = ô Ð × × [ x ¹0 3 ÿÎ ×
= þ et
e
Á²Á²Áuà BS¹ B Ñ
avec ù et Î × ÎÐ H©× × ½ ÷ g ï©Þ [ ½ ÷ ° ï . Donner ô .
å
2. Ecrire (2) sous forme matricielle.
B%¹BS¹ Ñ| ¹
On suppose maintenant que ÎÐ H
3.
¹ B\Á²Á²ÁWB%¹ ; quel système linéaire
obtient-on pour .
e
Méthodes numériques avec Java 198
Exercice 79 :
¹ ÎÐ B%¹tÑ Î
B
Pour résoudre l’équation différentielle : H , où est continue de
U » VEÈ IR dans IR, on propose la méthode à un pas suivante :
¹ n¹ BS¹ B Ñ
×\Õ BSx ¹ B Ñ× ô Ð H©BS× ¹4Ñ × ÿ SB ¹ BS¹tÑuÑ BS¹ BS¹4Ñ%Ñ
ô ÐH þ Î Ð H Î Ð H åÞ åÞ ÎÐ H ÎÐ H ÎÐ H
B%ÿ èB
(þ , et sont des réels de U V ).
BSÿ
B
1. Pour quelles valeurs du triplet ( þ ) retrouve t-on la méthode d’Euler ?.
Même question pour la méthode RK2 ?.
BS¹tÑT?wÜßÞ Ð B Ñ
2. On suppose dans la suite de l’exercice que ÎÐ H U VEÈ IR et L-
lipschitzienne en y :
BSÿ
B
(a) Pour quelles valeurs þ la méthode proposée est stable ?
B%ÿB
(b) Quelle relation doit satisfaire ( þ ) pour que la méthode soit consis-
tante ?
(c) Qu’on conclure pour la convergence ?
Exercice 80 :
» différentielle
On considère l’équation
¹ Ð áÑ Ð áѹ Ð áÑ ÎÐ áÑ áÝ? B
Ð ÑO¶ ÿ , U V
y(a) = þ et y(b)=
B áÑ
y pour tout á ? B
où et Î sont continues sur U V et Ð U V . (Ces hypothèses
assurent l’existence et l’unicité de la solution.)
¹ B
1. Montrer que si est quatre fois continument dérivable dans U V alors
Þ
¹
Ð á Ñ ¹ Ð á Ñ<o¹ Ð áÑ ¹ Ð á Ñ ¹ Ð Ñ
Þ U V <
Ç? á( B%á
avec V 8U .
B
On subdivise U V en N+1 intervalles de longueur [DÕ
x et on ¹ pose
2.
á | 6èB\Á²Á²ÁWB ¹ á Ñ
Ó Ô© , Ô ¹ á Ñ x ¹ , onappelle Ó une approximation de Ð Ó
<«¹ ¹ Ñ
et on remplace Ð Ó par Ð ÓÖÕ x Ó Ó [ x dans (1). Ecrire le système
d’équations linéaires ainsi obtenu.
å_ On appelle A la matrice de ce système.
É Þ
É
3. Montrer que É où
est une matrice tridiagonale et une
matrice diagonale, donner et .
Exercice 81 :
»
Soit l’équation différentielle du second ordre à conditions initiales :
¹ Ð áÑ ¹ áÑuÑ
<«¹ Ð áÑ áã? B
ÔQù Ð Ð
Ð ÑO¶ ¹ Ð è Ñ 0 # ¹ Ð DÑ
I< , U V
et
Méthodes numériques avec Java 199
2. Donner une condition nécéssaire et suffisante sur Î pour qu’elle soit lip-
¹
schitzienne en uniformément par rapport à H
3. Quels sont parmi les problèmes ci dessous, ceux qui admettent une solution
unique» : »
¹ Ð Ñ
x ? Bs ¹ Ð Ñ
J ¹ Ò H ? U 4B V
ÐÑ ¶ ¹ Ð HÑ [ ½ ] , Ò H ÏU V Ð </ѧ¶ ¹ Ð H Ñ I ,
Exercice 83 :
» suivant
Soit le problème de Cauchy
¹ Ð Ñ Þ ¹B ? 4 B
¹ Ð H Ñ =H H U V
=
1. Trouver la solution exacte de ce problème.
ó4)
2. Appliquer la méthode d’Euler à ce problème, avec
IèB , puis evaluer la
solution en H # . Comparer à la solution exacte.
Exercice 84 :
»
Soit le problèlme de Cauchy suivant :
¹ Ð Ñ
Ë ¹ < ? èB
¹ Ð H Ñ H, Ò H V V
1. Donner la solution générale de ce problème.
4)û<
avec
I4) p
2. Appliquer la méthode d’Euler à ce problème , puis donner la
solution numérique en H , à [ près.
3. Donner l’erreur théorique de la méhode d’Euler dans ce cas et la comparer
à l’erreur effectivement commise. Commentaires ?
Exercice 85 :
»
Soit le problème de Cauchy suivant :
¹ Ð Ñ
j¹ Ò H ? V 4B V
¹ Ð / H Ñ x [] ,
Þ
Méthodes numériques avec Java 201
¹ Ð Ñ x
1. Montrer que la solution générale de ce problème est H Þ H [] .
2. Appliquer la méthode d’Euler à ce problème avec
`è)ú< `4) p
(a) , puis donner la solution numérique en H , à [ près.
`è) `4) p
(b) , puis donner la solution numérique en H , à [ près.
3. Donner l’erreur théorique de la méhode d’euler dans chacun de ces cas et la
comparer à l’erreur effectivement commise. Commentaires.
Exercice 86 :
»
Soit le problème de Cauchy suivant :
¹ Ð Ñ
0<«¹ Ð Ñ ÎÐ B%¹tÑ ? 4 B
Рѧ¶ ¹ Ð H Ñ [] H H , H U V
BS¹4Ñ ¹
1. Montrer que ÎÐ H est lipshitzienne par rapport à uniformément par rap-
port à H , et donner une constante de Lipshitz.
2. Montrer que ce problème admet une solution unique.
¹ Ð 4 )ú<Ñ
3. Donner la solution exacte de (1), ainsi que .
¹
4. Appliquer la méthode d’Euler à ce problème, écrire l’algorithme corres-
pondant et donner l’approximation Þ de y(0.2) obtenue à l’aide d’un pas de
I4)
discrétisation numérique .
¹ 4)û</Ñ
5. Rappeler l’erreur théorique de la méthode d’Euler et la comparer à l’erreur
commise sur le calcul de Ð ; commentaires ? .
Exercice 87 :
¹ ÎÐ BS¹4Ñ B
Pour résoudre l’équation différentielle : H , où Î est continue de U V%· IR
» IR, on propose la méthode à un pas suivante :
dans
¹ n¹ BS¹ B Ñ
×\Õ BSx ¹ B Ñ× ô Ð H©BS× ¹4Ñ × ÿ SB ¹ BS¹tÑuÑ BS¹ BS¹4Ñ%Ñ
ô ÐH þ Î Ð H Î Ð H åÞ åÞ ÎÐ H ÎÐ H ÎÐ H
B%ÿ èB
(þ , et sont des réels de U V ).
BSÿ
B
1. Pour quelles valeurs du triplet ( þ ) retrouve t-on la méthode d’Euler ?.
Même question pour la méthode RK2 ?.
2. On suppose dans la suite de l’exercice que ÎÐ H BS¹tÑT?wÜßÞ Ð U B VEÈ Ñ
IR et L-
lipschitzienne en y :
BSÿ
B
(a) Pour quelles valeurs þ la méthode proposée est stable ?
B%ÿB
(b) Quelle relation doit satisfaire ( þ ) pour que la méthode soit consis-
tante ?
Méthodes numériques avec Java 202
Exercice 88 :
» de Cauchy suivant
Soit le problème
? 4BN
ÐÑ y’(t) = f(t,y(t)), H U V , a réel strictement positif,
y(0) = donné dans IR,
èBN
où Î est deux fois continûment dérivable dans U V'È IR, on suppose que æ*ç est
æ½
» numériquement la solution de (1) par le schéma à un pas :
bornée. On approche
¹ x ¹ SB ¹ B Ñ 34B B\)1)\) )
Ð <Ñ ¹ ×\Õ = × ô Ð H©× × , ù
= donné dans IR
e
4BN 4B
où ô est une application de U
`èB Vè· IR ·U e V dans IR ( e est un réel positif ),
H H©× H ùW et
.
eOn donne e
4BN
le théorème suivant qui pourra être utilisé sans démonstration :
B
Théorème : si Î est deux fois continument dérivable dans U V · IR et si ô æ
4BN 4B æCå
existent et sont continues dans U V8· IR ·U e V alors le schéma (2) est d’ordre
2 si et seulement si
B%¹BN/Ñ Î Ð BS¹tÑ
ô ÐH H æ ¡ ½ ¡ e Þx Ð*æ*ç æ*ç ) Î Ñ Ò Ð H BS¹4ѧ? U èBN V8· IR )
et
æCå æ æ½ ¡½
B%¹B Ñ
Soitÿ donc à approcher les solutions de (1) par la méhode (2), avec ô Ð H
ñþ x ñ où
Exercice 89 :
»
Soit l’équation différentielle du second ordre à conditions initiales :
¹ Ð Ñ0<«¹ Ð Ñ
j¹ Ð Ñ ? èB
Рѧ¶ ¹ Ð /H
Ñ H , H U V
H ¹ Ñ Ë
et Ð
1. Ecrire cette équation différentielle sous la forme d’un système différentiel
de deux équations d’ordre un.
Méthodes numériques avec Java 203
¹
2. Donner une condition nécéssaire et suffisante sur Î pour qu’elle soit lip-
schitzienne en uniformément par rapport à H
3. Quels sont parmi les problèmes ci dessous, ceux qui admettent une solution
» :
unique »
¹ Ð Ñ
x Ò ? Bs ¹ Ð Ñ
J ¹ Ò H ? U 4B V
ÐÑ ¶ ¹ Ð H [ ½
Ñ ] , H ÏU V Ð </ѧ¶ ¹ Ð H Ñ I ,
Exercice 94 :
»
Soit l’équation différentielle du second ordre à conditions initiales :
áã? 4 B
Рѧ¶ ¹ Ñ
y”(x) +2y’(x) =2y(x), U V
y(0) = 1 et Ð
1. Ecrire cette équation différentielle sous la forme d’un système différentiel
de deux équations différentielles d’ordre un.
2. Appliquer la méthodede RK2 à ce système .
Exercice 95 :
»
Soit l’équation différentielle du troisième ordre et à conditions initiales :
¹ Ð Ñ
¹ Ð Ñ ? 4B
Рѧ¶ ¹ Ð Ñ H 3 # ¹ H Ð ,H Ñ wU µ< V ¹ Ð Ñ
et .
Méthodes numériques avec Java 205
Exercice 96 :
Soit le problème de » Cauchy suivant :
¹ Ð Ñ . Ð ÑG¹ Ð Ñ ÎÐ BS¹4Ñ ? 4B
Рѧ¶ H
¹ Ð Ñ '
$ & H H H , H U V
BS¹4Ñ ¹
1. Montrer que ÎÐ H est lipshitzienne par rapport à uniformément par rap-
port à H , et donner une constante de Lipshitz.
2. Montrer que ce problème admet une solution unique.
¹ Ð 4 )ú<Ñ
3. Donner la solution exacte de (1), ainsi que .
¹
4. Appliquer la méthode d’Euler à ce problème, écrire l’algorithme corres-
pondant et donner l’approximation Þ de y(0.2) obtenue à l’aide d’un pas de
I4)
discrétisation numérique .
¹ 4)û</Ñ
5. Rappeler l’erreur théorique de la méthode d’Euler et la comparer à l’erreur
commise sur le calcul de Ð . Commentaires ?
Exercice 97 :
On considère la méthode à pas séparés suivante (*) :
¹ `¹ %B ¹ Ñ %B ¹ SB ¹ %Ñ Ñ
×\Õ x × < U ÎÐ H©× × ÎÐ H©×²Õ x × ÎÐ H©× × V
1. Etudier la consistance, la stabilité théorique, la convergence.
ÎÐ H H . Ñ
2. On veut calculer une valeur approchée de
¹ áÑ
Montrer que ce problème peut être remplacé par la résolution d’un problème
de Cauchy dont on précisera la condition initiale, on posera Ð
Y ÎÐ Ñ
H H
Comment peut-on obtenir une valeur approchée de . ?
Si on utilise la méthode (*) pour calculer , donner l’expression de
, ex-
primer l’erreur en fonction de .
Méthodes numériques avec Java 206
?!
avec .
> Ð# Ñ Ð <Ñ
3ème étape : solution générale. On remplace donné par dans :
¹ #" Ñ
[] Ð H $
donc,
¹Ç w
H
¹ Ð Ñ
Finalement, grâce à la condition initiale , on détermine , d’où
¹ Ð Ñ Ë G <
e&%
Ñ ¹Ç
<
Ainsi, la solution exacte de Ð est H . ¹ Ñ
Estimation de l’erreur. La solution exacte ci-dessus donne Ð
< )p
# #/!/! . Ainsi, l’erreur( { )p
' effectivement commise
) ë4)û< s
# #/!/! # ý p {
lors de l’application
de la méthode d’Euler est { { . Cherchons
l’erreur théorique qui est donnée par :
Þ
Ð â D[
Ñ ~ < É ·Ý
`à2/á 7¢ { ¹ Ð Ñ { É
Où ~ Þ H et est la constante de Lipschitz de Î
¹
N¡ par rapport
à , qui se calcule aisément :
De même, on a
¹ Ð Ñh ¹
H H
< Ñ
H Ð H
<
exercice 42
¹ Ð Ñ
3¹ Ð Ñ Þ ÎÐ B%¹tÑ ¹ Ð Ñ
H H H eH
½
Remarquons tout d’abord que Î étant continue et lipshitzienne par rapport à
¹
ce problème de Cauchy admet une solution unique (théorème 9 de Cauchy-
Lipshitz). 4BS4)ú< Iè)ú<
L’intervalle d’intégration est U V et le pas d’intégration est .
Méthode de RK2 Elle s’écrit :
¹ `¹ Ñ*B
×\Õ x × < Ð~ x ~ Þ
soit
¹ x 3 ¹ Ñ
< Ð ~ x ~ Þ
e
x ÎÐ 4) ÑÙ Þ ÎÐ 4û) <èB 4û) <zÁ Ñ 4)ú<DB )û</ѵ
, avec ~
4)û et ~ . Donc ÎÐ
!/!/! . `4)û< ¹ Ð Ñ
Ainsi, l’approximation en H de H , est
¹x Ñ 4 ) m) Ñ
< Ð~ x ~ Þ Ð /! !/!
¹x )
!/!/!
Intégrons par parties :
p. Þ Þ
< H [ < [ ® H0/
< Þ Þ
H [ [ 1
<Ð Ñ Þ
2 [
H 3
?- ÌT < Þ ¹ Ñ
avec 2/4 comme Ð*5
H ¹Ë 2 ,
5 Ì ¹DÞO <
. La solution générale est donc
H J <
¹ Ð75 Ñ . Finalement,
Ê 5 ¹ J < H 62 . Ainsi, H 32 . Comme
2 alors H 82 . ¹ </ÑI J <Á 59 <
Estimation de l’erreur. La solution exacte est Ð*59 32 : p s
;:<
('
;:<
;<;<;<
2 92 2 . Donc l’erreur commise est { { {2 92 2 2 92 { 5=9>5;5 .
On peut comparer cette erreur effective à l’erreur théorique sur RK2, donnée
par : ————-
(le théorème du cours)
exercice 43
Soit le problème de» Cauchy suivant
¹
? Ð Ñ; < G¹ Ð Ñ ÎÐ BS¹4Ñ
¹ 7Ð 5 H Ñ H H H Ð2Ñ
2
Remarquons tout d’abord que Î étant continue et lipshitzienne par rapport à
¹ Ñ
le problème de Cauchy Ð 2 admet une solution unique (théorème 9 de Cauchy-
Lipshitz).
Méthode d’Euler. Elle s’écrit :
¹ ¹ ÎÐ H©× BS¹ × Ñ
×²Õ x ×
¹ Ð < H©× ¹ × Ñ
×
¹ Ð Ñ <
× 2 "H©×
¹ Ñ 3¹ ß 5=9 5
On a aussi Ð75 2 , 2 H et H©× ùW
¹ =5 9 ¹ e < e .
Donc ×²Õ x ×
5
9 5 ù , d’où le tableau,
< :
ù 5 2
< :
H¹ ©× 5 5=/9 2 < 5=9 5=9
;</ 5=9 p <
× 2 5=9 5=9 2
59 : ¹ Ð Ñ
C’est à dire que l’approximation en H
¹ x 5=9 p < de H avec le pas 5=9 2 , est
2 .
e
Méthodes numériques avec Java 210
Ainsi ~ Þ E: . Donc,
: x
{ w
{ Ð x @ Ge F [ e B 2
Ñ ·
<
2 5 [
s ÑIH · s2 < p
5=9 2 Ð eGF 2 5=95 ý 9
('
Clairement, { {µ { { , donc la méthode d’Euler donne une bonne ap-
59 :
proximation de la solution de ce problème de Cauchy en H .
exercice 44
»
¹ ? Ð Ñ; :;<«¹
Ð H Ñü: ý []
Ð2Ñ ¹ 7Ð 5 H Ñ
2 , puis 2¦ ¤
¹ Ð Ñ
Ð KJ Ñ comme
En appliquant la méthode de la variation de la constante,
au premier
exercice, on trouve la solution générale, H [ L XZ [] L XZ où
est la constante d’intégration.
¹ Ñ 5 ¹ Ñ
1. Si *Ð 5 2 , alors , donc la solution du problème est Ð H [] .
¹ Ð*5 Ñk ¤ , donc la solution du problème est ¹M Ð H ÑT
2. Si 2 ¤ , alors
[] ¤ XZ .
¹ Ð Ñ ¹ M Ð Ñ { ¹ Ð Ñ
¹M Ð Ñ { ¤
Conclusion : En comparant H et H , on voit que la différence H
H XZ . Même si ¤ est très petit, cet écart tend vers O
N , les deux solutions
divergent l’une de l’autre. Ce problème est donc très sensible aux Conditions Ini-
tiales.
Méthodes numériques avec Java 211
exercice 45
¹ ? ? Ð Ñ ö .GPRQ ¹ Ð Ñ Ð2Ñ
H H 5
Ñ
Écrivons Ð 2 sous la forme de deux équations
¹
?è ¹A? ?è ?4
TS .GPUQ différentielles
¹Ð 4Ñ d’ordre 1 chacune.
Pour cela on pose  , d’où »  . Ainsi, on obtient le système :
¹ ? ÎöÐ H BSBS¹¹B B Â Ñ Ñ
? Â TS C. PRQ ¹4Ñ
 РÐH Â
1. Appliquons Euler : »
¹ ¹ B%¹ B Ñ
\× Õ x × ö ÎÐ H©× BS¹ × B Â1× Ñ
Â1×²Õ x Â1× Ð H©× × Â1×
BS¹B Ñ 3¹ ö Ð BS¹B Ñ
S .GPRQ Ð ¹ Ð Ñ%Ñ
Avec ÎÐ H Â et H Â H , soit
»
¹ x ¹
×\Õ × Â1S × .GPRQ ¹ B
Â1×²Õ x Â1× ×
¹
avec et  donnés.
e e
2. Méthode de Taylor d’ordre 2, elle s’écrit :
Þ i
V V BV Ñ ä Ð B V Ñ ä Ð B V Ñ ú9 ÎÐ B V Ñl
×\Õ x × Ð H©× × < H©× × V H©× × H©× ×
ä H ä
» donc,
On obtient
¹ ¹ Ñ " WS G. PUQ ¹ Ñ
\× Õ x × Ð " Â1 × S Ë G. PUQ å _Þ
¹Ð Ñ
Ð × 3 2 Â1× $
" S 1+ ,/. ¹ Ñ
Â1×²Õ x Â1× × $ *å _Þ Ð × 1Â × 5 $
exercice 48
Ã
Å Æ ¹ ? ? Ð H Ñ <«¹ ? Ð H Ñ; <«¹ Ð Ñ
H
Ð 2 Ñ ¹¹A? Ð DD Ñ Ñ
<2
Ð
? B
Avec H U V.
¹? ¹ ?? ? Ë< <o¹
1. On pose  d’où  »  . On trouve le système
Calculons ~ Þ :
Ð H©× B V × ~ x Ñ
~ Þ
V Ñ
Ð ×
i ~ x i i
¹
2 l . × l l
<«¹ Â10 ×
5
< µ< < /
i i Â1× ¹ × Â1×
5
< µ<2 l × Â1× l
< й Ñ
i Â1× × Â1×
< й Ñ
Â1× × Â1× l
< й Ñ Ð < 0<Ñ
i × < ¹ Â1× 0
<
Â1×
× Â1× Ð 2 l
<Ð µ p ѹ < </Ñ
× Ð Â1×
Ainsi,
i ¹ i ¹
V \× Õ x l ×l Ð~ x ~ ÞÑ
×\Õ x <
Âi 1×²Õ x i 1
 ×
¹ < ¹ < Ñ
×l 1Â × × Â1× Ð 2 l
< o< ¹ < <Ð p Ñ ¹ < 0</Ñ 9
Â1× × 1Â × × Ð Â1×
Donc
¹ ¹ Ð ÞÑ 0< %Ñ Ñ
²× Õ x × 2§ 1Â × Ð < < Ð 2
¹ Ð< Ñ : Ñ Ñ
Â1×²Õ x × Â å Â1× Ð 2 Ð 2
Par conséquent
¹ Þ
\× Õ x Ð 2¦ ѹ × Ð 2 Ñ Â1×
< Рѹ : Þ
< Ñ
Â1×\Õ x 2 × Ð 32 Â1× 9
Méthodes numériques avec Java 214
}
}
Traitement générique
Nous décrivons maintenant un processus générique qui effectue un certain
nombre d’itérations à partir d’un processus de résolution arbitraire - de type
IterEDO. Une représentation graphique est réalisée. Cette dernière utilise la
méthode CanvasGraphe définies dans les chapitres précédents.
import java.lang.*;
import java.io.*;
import java.util.*;
import 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();
}
Exemple d’utilisation
Nous décrivons maintenant une utilisation des classes précédentes. Nous
définissons l’équation différentielle à résoudre dans la classe FEDO et nous créons
Méthodes numériques avec Java 218
une instance du traitement générique précédent auquel nous transmettons des ins-
tances de la classe FEDO et d’un processus de résolution.
»
L’équation différentielle résolue ici est :
.GPUQ Ð < ¹4Ñ
¼¹ ©½ H
¼ Ð*5 Ñ 5=9 s
class FEDO extends FoncEDO {
class PrgEdo{
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;
}
On construit une classe qui en dérive et qui décrit la méthode d’Euler pour un
système.
//System.out.println("yCourant["+i+"] = "+yCourant[i]);
}
//yCourant=yNew;
tCourant += h;
return yNew;
}
}
Traitement générique
On adapte le traitement générique précédent au cas d’un système différentiel.
import java.lang.*;
import java.io.*;
import java.util.*;
import java.awt.*;
Méthodes numériques avec Java 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();
}
á Ñ*B%¹ Ð Ñ%Ñ
Nous traçons un portrait de phase, c’est à dire la trajectoire des points de
coordonnées Ð Ð H H en faisant varier H . la solution théorique correspond au
cercle trigonométrique.
SEDOCirc(int pdim, double pt0, double[] py0, double ppas, int pnbpas,
int pixGraph, int piyGraph) {
super(pdim, pt0, py0, ppas, pnbpas, pixGraph, piyGraph);
}
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;
Méthodes numériques avec Java 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);
}
}
L’avant dernière ligne du programme contient le nom du processus effective
de résolution utilisée. Il suffit simplement de modifier cette ligne pour utiliser un
autre processus. C’est ce qui est fait dans la suite.
On utilise donc d’abord la méthode d’Euler qui donne de mauvais résultats car
elle amplifie à chaque itération sa déviance par rapport au cercle-unité solution
du problème.
cercle unité).
ÃÄÄ
Nous appliquons maintenant notre programme pour résoudre les équations de
Lorentz : ` ¹KOáÑ Ð
Y
Å ÄÄÆ ¼¼¼ ½ áká Â
G¹
X n á¹£
¼á ¼ Ñ
¹
¼ *Ð 5 2,^ Ð75 Ñ 2,^ Â Ð75
Ñ
2
´,: <
, et sont des paramètres qui seront égaux, ici, respectivement à 2 5 , et .
SEDOLorentz(int pdim, double pt0, double[] py0, double ppas, int pnbpas,
int pixGraph, int piyGraph) {
super(pdim, pt0, py0, ppas, pnbpas, pixGraph, piyGraph);
}
Méthodes numériques avec Java 227
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);
Méthodes numériques avec Java 228