Une classe abstraite de description de processus it´eratifs . 61

Nous allons utiliser dans la suite deux processus it´eratifs, `a savoir les m´ethodes de Lagrange et de Steffensen. Ces deux processus sont bas´es sur des calculs similaires : calcul d’une formule de r´ecurrence et processus de r´ep´etition jusqu’`a une ´eventuelle convergence, li´ee `a un crit`ere donn´e. Beaucoup d’autres sch´emas num´eriques sont susceptibles de suivre de tels processus. Pour cette raison, nous avons commenc´e par d´efinir une classe abstraite de description d’un processus it´eratif, appel´ee IterGene. Cette classe est abstraite car elle contient une m´ethode abstraite, non impl´ement´ee, correspondant `a la formule de r´ecurrence. Celle-ci va d´ependre de la formule sp´ecifique d’une classe parti-culi`ere qui en d´erivera. Par contre, un sch´ema de construction de suite r´ecurrente, susceptible de converger, peut ˆetre impl´ement´e dans cette classe abstraite en s’appuyant sur sa formule de r´ecurrence, elle-mˆeme abstraite.

Il nous faut g´erer la convergence d’un processus it´eratif grˆace `a une v´erification de pseudo-stabilit´e sur deux it´er´es successifs. Dans le cas o`u il n’y a pas convergence, un nombre maximum d’it´erations est pr´ed´efini et permet de stopper le processus. Dans ce cas, il reste alors `a renseigner les programmes appe-lant de la non-convergence. Pour cela, nous utilisons un m´ecanisme d’exception qui est sp´ecifiquement adapt´e `a un tel traitement ; il sera alors capable de faire re-monter, en cascade, l’information de non-convergence, aux diff´erents programmes appelants. On d´efinit alors une classe exception ´el´ementaire capable d’ˆetre ´evalu´ee sous la forme d’une chaˆıne de caract`eres et impl´ementant, pour cela, la m´ethode toString.

class NonConvergenceException extends Exception {

public String toString() { return("Defaut de convergence"); } }

Nous pouvons alors d´efinir la classeIterGenequi est compos´ee :

– des donn´ees xn, epsilon, maxIter qui correspondent respective-ment, au terme courant du processus it´eratif, `a la pr´ecisison de

conver-gence et au nombre maximun d’it´erations autoris´ees. On impl´emente des m´ethodes permettant de fixer leurs valeurs ;

– d’une m´ethode abstraite d’it´erationiter, sans param`etre, qui actualisera le terme courant du processus it´eratif. Nous d´ecrivons aussi, une autre version de cette m´ethode, iter, avec un param`etre qui correspond `a une mise `a jour du terme courant, avant l’application du processus it´eratif ;

– d’un calcul de suite recurrentecalculSuites’appuyant sur la m´ethode d’it´eration et ´ecrite sous deux versions : sans param`etre ou avec un pa-ram`etre bool´een qui permet d’afficher une trace des termes successifs de la suite calcul´ee.

import java.lang.*;

import java.io.*;

abstract class IterGene {

double xn; // terme courant de la suite double epsilon; // precision de convergence int maxIter; // nombre maxi d’iterations // fixe la valeur du terme initial de la suite : public void set_xn(double x0) { xn = x0; }

// fixe la valeur de la precision :

public void set_epsilon(double precision) { epsilon = precision; } // fixe le nombre maxi d’iterations :

public void set_maxIter(int m) { maxIter = m; } // methode abstraite du calcul d’une iteration // a partir de xn courant :

abstract public double iter() ; // methode de calcul d’une iteration // a partir d’une valeur x donne : public double iter(double x) {

set_xn(x);

return iter();

}

// calcul d’une suite recurrente

//a partir de iter et jusqu’a convergence : public double calculSuite(boolean trace)

throws NonConvergenceException {

double xOld;

int nbIter=0;

if (trace) {

System.out.println("valeurs successives calculees :");

System.out.println(xn);

} do {

xOld=xn;

iter();

nbIter++;

if (trace)

{ System.out.println("iter. "+nbIter+" : "+xn);}

} while (Math.abs(xn-xOld) > epsilon && nbIter <= maxIter);

if (nbIter > maxIter) throw new NonConvergenceException();

return xn;

}

public double calculSuite ()

throws NonConvergenceException { return calculSuite(false);

} }

2.9.2 La m´ethode de Lagrange

Nous d´ecrivons, maintenant, la classe mettant en œuvre la m´ethode de La-grange, vue dans le paragraphe 2.4 et qui, `a partir d’une application ^Þ continue, strictement monotone sur ^{ä‘æDçFèHé} et telle queÞQêëæì+ÞQêëèaìzî8ï , construit le processus it´eratif suivant :

‚

ñö

õ æ ou^è=ç de sorte queÞQêñö¹ìcÞ¶óóêñöaìi÷¡ï ñDøjùú

õ

ñDøãýNÞQêñDøÐì

Ò Õ m 'n

Õ m ( n

La classe IterLagrange est telle que son constructeur poss`ede les pa-ram`etres suivants : la valeur initiale ^ñö et une fonction quelconque r´eelle d’une variable r´eelle (les r´eels ´etant repr´esent´es par le typedouble).

Le passage d’une fonction, comme param`etre, se fait grˆace `a une interface qui sera impl´ement´ee effectivement, par la fonction particuli`ere utilis´ee (comme d´ecrit en 1.5.7). Cette interface propose une m´ethode d’´evaluationcalculde la fonction pour un param`etre donn´e. Elle s’´ecrit :

interface FoncD2D { double calcul(double x); }

La classeIterLagrange, qui d´erive de la classeIterGene, s’´ecrit alors : import IterGene;

import FoncD2D;

class IterLagrange extends IterGene {

FoncD2D f; // fonction dont on recherche le zero double x0; // bornes de l’intervalle de calcul

// constructeurs

IterLagrange(FoncD2D fonc, double xini) { f=fonc; x0=xini;

epsilon=0.001;

maxIter=100;

}

// calcul d’une iteration : public double iter() {

xn = xn - f.calcul(xn)*(xn-x0)/

(f.calcul(xn)-f.calcul(x0)) ; return xn;

} }

Nous pr´esentons ci-dessous, un programme de test de la m´ethode de Lagrange, en commenc¸ant par d´efinir la fonction^Þ , dans une classe impl´ementant l’interface FoncD2Dcorrespondant `a :

Þíêñì õ$Ö

û

ýu3 sur l’intervalle ^äþ#ç~é

La valeur initiale de la suite r´ecurrente est la borne 5, qui satisfait `a la condition exprim´ee pr´ec´edemment.

Le programme correspondant s’´ecrit : import java.io.*;

import FoncD2D;

import IterLagrange;

class MaFonction implements FoncD2D { public double calcul(double x) {

return x*x*x-8;

} }

class TestLagrange {

public static void main(String args[]) { MaFonction f = new MaFonction();

IterLagrange rechercheZero = new IterLagrange(f,5);

rechercheZero.set_epsilon(1E-6);

try {

double resultat = rechercheZero.calculSuite(true);

System.out.println("le zero trouve vaut : "+resultat);

}

catch(NonConvergenceException e) { System.out.println(e);

} } }

Nous donnons ci-apr`es une trace de l’ex´ecution montrant la convergence de la recherche en 45 it´erations :

java TestLagrange

valeurs successives calculees : 5.0

iter. 1 : 1.225806451612903 iter. 2 : 2.8774769746022884 iter. 3 : 1.575783340029592 iter. 4 : 2.3837064484468686 iter. 5 : 1.7721357917725993 iter. 6 : 2.183912111336465 iter. 7 : 1.8801284843229529 iter. 8 : 2.091190544058032 iter. 9 : 1.9378012139273417 iter. 10 : 2.0458883891378012 iter. 11 : 1.9679808942878763 iter. 12 : 2.0232527320893645 iter. 13 : 1.9835875282989195 iter. 14 : 2.011822859470857 iter. 15 : 1.9916061843487987 iter. 16 : 2.006021559594976 iter. 17 : 1.995712170773491 iter. 18 : 2.0030695016733913 iter. 19 : 1.9978109552571226 iter. 20 : 2.00156536536722 iter. 21 : 1.998882781401325 iter. 22 : 2.000798472022616 iter. 23 : 1.9994298969642061 iter. 24 : 2.00040733587803 iter. 25 : 1.9997091067417003 iter. 26 : 2.0002078119872224 iter. 27 : 1.9998515787290103 iter. 28 : 2.0001060232863277 iter. 29 : 1.9999242732103275 iter. 30 : 2.00005409267069 iter. 31 : 1.9999613634529168 iter. 32 : 2.0000275980820095 iter. 33 : 1.999980287364067 iter. 34 : 2.0000140805969857 iter. 35 : 1.9999899425035552 iter. 36 : 2.0000071839631905 iter. 37 : 1.9999948686166795 iter. 38 : 2.000003665283473 iter. 39 : 1.9999973819453114 iter. 40 : 2.000001870041581 iter. 41 : 1.999998664257298 iter. 42 : 2.0000009541025854

iter. 43 : 1.9999993184984877 iter. 44 : 2.000000486786965 iter. 45 : 1.999999652295112

le zero trouve vaut : 1.999999652295112