Analyse numérique et Optimisation

Chapitre I : Introduction
1. Un peu d’histoire
2. Application

Chapitre II : Programmation mathématique

1. Définition
2. Conditionnement de l’algorithme
3. Conditionnement d’une matrice

Chapitre III : Méthodes directes systèmes linéaires sans

contrainte

1. Algorithme
2. Méthode de Gauss
3. Méthode de LU
4. Méthode de Jordan
5. Méthode de Cholesky

Chapitre IV : Optimisation des systèmes linéaires sans contrainte

1. Orthogonalité des vecteurs dans un espace à deux dimensions .

2. Orthogonalité des vecteurs dans un espace à n dimensions .

3. Approximation par les moindres carrés.
4. Approximation des moindres carrés lorsque est une matrice .
5. Approximation des moindres carrés lorsque est une matrice .
6. Détermination de l’erreur d’approximation.
7. Moindres carrés sous Excel.

Chapitre V : Optimisation des systèmes linéaires avec contraintes

1. Définition
2. Exemple
3. Exercice : la confection
4. Solution Excel

Chapitre VI : Méthodes itératives systèmes linéaires sans

contrainte

1. Principe
2. Décomposition de la matrice A
3. Méthode de Jacobi
4. Méthode de Gauss-Seidel
5. Méthode de relaxation
Chapitre VII : Optimisation monodimensionnelle, Méthode
dichotomique
1. Méthode dichotomique
2. Méthode du nombre d’or

Chapitre VIII : Optimisation multidimensionnelle sans contrainte

1. Méthode de Newton et de ses variantes.

2. Méthode de Newton.
3. Méthode de Quasi-Newton.
4. Méthode de Newton-Raphson.
5. Méthode de Newton amortie.
6. Méthode de Minimisation.
7. Méthode du Gradient conjugué.
Chapitre I
1. Introduction
Partie intégrante des mathématiques appliquées, l’Optimisation se veut de résoudre
des problèmes scientifiques et industriels. L’optimisation est une méthode (ensemble
de méthodes) qui permet d’obtenir le meilleur résultat approché d’un problème de
recherche de minimum d’effort à fournir pour une machine (par exemple) ou le besoin
d’obtenir un bénéfice maximal dans une gestion de production ou dans la gestion d’un
portefeuille.

L’optimisation est la transcription d’un postulat mathématique en algorithme

implémentable. Optimiser revient donc à estimer des minima et des maxima d’une
fonction ou d’un système de fonction. Ces dites fonctions peuvent être linaire ou non
linéaire. Les optima (extremum) d’une fonction sont étudiés et caractérisés en
Analyse Numérique en dimension une et pour des fonctions continues.

La difficulté de l’optimisation est de concevoir des algorithmes pour évaluer les

optimums d’une fonction dans une dimension supérieure à un avec des contraintes et
munies de variables discrètes. L’émergence de nombreuses méthodes traduit
simplement le constat qu’il n’y a pas de méthode unique qui permet de résoudre tous
les problèmes d’optimisation.

2. Un peu d’histoire
Nous devons, en grande partie, l’existence de l’optimisation par Taylor, Newton,
Lagrange et Cauchy qui ont élaboré les bases des développements limités. Les
méthodes d’optimisation des équations différentielles ont été réalisées par les
contributions de Newton et Leibnitz. Cauchy fut le premier à mettre en uvre une
méthode d’optimisation, méthode du pas de descente, pour la résolution de
problème sans contrainte. Depuis ces considérables contributions, il y a eu de peu
d’avancé. Il faut dire qu’à l’époque les mathématiciens et les ingénieurs
calculaient à la main.

Il faut attendre le milieu du vingtième siècle, avec l’émergence des calculateurs

et surtout la fin de la seconde guerre mondiale pour voir apparaître des avancées
spectaculaires en termes de techniques d’optimisation. A noter, ces avancées ont
été essentiellement obtenues en Grande Bretagne. En mille neuf cent quarante
sept, l’américain Dantzig propose un algorithme pour résoudre des problèmes
linaire avec contraintes. En mille neuf cent cinquante sept, Bellman énonça le
principe d’optimalité des problèmes de programmation dynamique.

De nombreuses contributions apparaissent ensuite dans les années soixante.

Zoutendijk et Rosen pour la programmation non linéaire ainsi que Carroll, Fiacco
et McCormick. Dans la même période, Duffin, Zener et Peterson ont développé les
méthodes de programmation géométrique. Quant à Gomory, il consacra ses
travaux à l’élaboration d’algorithme de programmation discrète, on lui qualifie le
titre de "père de l’optimisation combinatoire".

Dantzig, Charnes et Cooper se sont attaqués à la difficile tâche de développer des

techniques de programmation stochastique. Ils ont, en effet permis la résolution
de système dotés de paramètres linéairement indépendants et normalement
distribués (un savant mélange d’optimisation et de probabilité).
 Récemment de nombreuses études s’orientent vers des techniques d’optimisations
à base de théorie des jeux dont les bases furent cimentées par Von Neumann en
mille neuf cent vingt huit (nous lui devons également l'architecture de nos PC qui
n’ont guère évolués).

3. Application

Les applications sont nombreuses et multiples. Les ingénieurs ont même su faire
des émules au sein de la communauté économique. Nous pouvons toutefois citer
quelques exemples où sont employés les techniques d’optimisation :

La conception et la fabrication automobile, aéronautique, aérospatiale.

Le calcul d’éléments finis pour la modélisation et l’élaboration de structure.
La thermodynamique et l’écoulement des fluides.
La conception de machines électriques.
Le transport d’énergie des réseaux électriques.
Les protocoles de transport d’informations des réseaux informatique.
L’analyse statique de données issues de modèles expérimentaux
empiriques pour la représentation d’un phénomène physique.
La gestion de production (planning, gestion, ordonnancement).
La gestion économique (profit maximal, perte minimale).
Les stratégies militaires.
L’optimisation des contrôles des systèmes en automatique.
Chapitre II
1. Programmation mathématique
Le premier domaine exploité pour les méthodes d’optimisation est la programmation
linéaire. En particulier la méthode du simplexe élaboré par Dantzig, son algorithme
permet de résoudre des systèmes linaires de plusieurs millier de variables. L’optimum
est obtenu par une convergence rapide vers les sommets d’une forme polyédrique
définie par les contraintes. Nous trouvons l’algorithme de Dantzig implémenté dans de
nombreux logiciels commerciaux comme le solveur d’Excel (bien que son nom
n’apparaît pas dans l’aide en ligne).

Le second domaine concerne la programmation discrète ou plus exactement la

programmation combinatoire. L’énorme difficulté consiste à évalué un système doté
de variable discrète (valeur finie ou entier).

Viens ensuite le domaine de la programmation non linéaire qui estime des systèmes
d’équations non linaires définies continues et dérivables. D’énormes progrès sont
encore à faire dans la programmation non linéaire. En effet, nous n’estimons que les
systèmes d’environ une dizaine de variables. Les algorithmes convergent vers un
optima local et non vers des optimums globaux.

2. Définition
L’optimisation est l’étude des méthodes qui permet d’estimer numériquement des
variables d’une équation ou d’un système d’équation. Un problème d’optimisation sous
contrainte peut être résumé de la façon suivante :

Il s’agit d’estimer un vecteur où de sorte que ce vecteur

minimise la fonction appelée fonction objective ou fonction économique, ayant

comme contraintes ont pour but de restreindre les solutions d’un

problème, les variables .

En résumé :

La maximisation de fonction s’obtient par l’étude de la minimisation de la fonction

négative.
 Figure : maximum de f(x) = minimum de –f(x).

3. Conditionnement de l’algorithme
L’analyse numérique d’un problème passe obligatoirement vers un conditionnement de
l’algorithme afin de minimiser les erreurs d’arrondi pratiquées par le calculateur. Un
algorithme pour un problème d’approximation de valeurs discrètes ou formulé en
dimension fini, peut être écrit pour obtenir une solution de manière directe ou de
manière itérative. Un algorithme direct donne la solution du problème en nombre de
séquence de calcul fini. Il n’y a donc pas d’erreur de méthode, par contre les erreurs
d’arrondi sont présentes. Un algorithme itératif estime une solution par une suite
d’approximations successives qui convergent vers la solution. Les différentes sources
d’erreur possible sont les suivantes :

Erreur d’approximation ou de discrétisation.

Erreur due à un algorithme itératif.
Erreur d’arrondie due à la précision finie.
Erreur due à l’approximation des données.

Les calculs subissent des erreurs d’arrondi d’une part à cause du conditionnement de
l’algorithme et d’autre part à cause de l’ordinateur. Les erreurs d’arrondi relatives,
comme dans le cas d’une multiplication ou d’une division, s’additionnent. Par contre,
dans une addition ou une soustraction se sont les erreurs d’arrondi absolues qui
s’ajoutent.

Un algorithme mal choisi ou mal conditionné finit par donné un résultat loin de la
solution à cause des accumulations d’erreurs.

Opter pour l’écriture de fonction arithmétique et algébrique peut s’avérer positif dans
l’obtention du résultat estimé. Par exemple la multiplication et la division scolaire
produit moins d’erreurs d’arrondi que celles de la machine. De même les racine carré
peuvent être réécrite sous la forme taylorienne.

4. Conditionnement d’une matrice

La qualité des données peut influencer considérablement les résultats. Par exemple,
soit le système du type :

Si on introduit une perturbation dans la matrice nous obtenons alors :

Par contre si on introduit une perturbation dans la matrice nous obtenons alors :

La qualité des données issues d’une acquisition est tributaire des différentes
perturbations que peuvent subir les relevés. Ainsi on opte généralement vers une
démarche statistique (plusieurs série de mesures) pour corroborer une estimation.
L’exemple précèdent, nous montre effectivement que de faibles variations sur les
données conduisent à de fortes variations sur le résultat.
Chapitre III
1. Méthodes directes des systèmes linéaires sans contrainte
Dans cette partie nous ne détaillerons pas les méthodes classiques de résolution d’un
système linaire du type avec matrice carré et qui existe.

En règle générale, une méthode directe permet de résoudre un système linéaire en un

nombre fini d’opérations. Le principe consiste à rendre la matrice triangulaire
supérieure. Le système à résoudre s’écrit :

est inversible et

2. Algorithme

Pour de plus amples informations, nous invitons le lecteur à se référer aux ouvrages
mathématiques relatant les techniques suivantes :

3. Méthode de Gauss
La méthode de Gauss, communément appelé procédé d’élimination de Gauss, qui
consiste à transformer la matrice en une matrice triangulaire supérieure. Cette
méthode consiste à faire une composition linéaire des lignes. C’est une méthode qui
comporte certain inconvénient en terne de précision puisqu’il effectue à chaque
opération des divisions.

4. Méthode de LU

La méthode de LU qui consiste à décomposer la matrice en produit de deux

matrices avec matrice triangulaire inférieure à diagonale unité et matrice
triangulaire supérieure.

5. Méthode de Jordan
 La méthode de Jordan qui est le même principe que la méthode de Gauss mais à une
étape donnée on effectue des combinaisons linéaire des lignes pour aboutir à une
matrice diagonale.

6. Méthode de Cholesky

La méthode de de Cholesky qui suppose que la matrice est symétrique et définie

positive. Cette méthode décompose la matrice et résout deux systèmes
triangulaires du type :

et .

Algorithme de Cholesky

en exemple pour la première colonne :

a) Calcul de la matrice :

b) Résolution du système triangulaire :

c) Résolution du système triangulaire :
Chapitre IV
1. Optimisation des systèmes linéaires sans contrainte
Il est fréquent que l’on puisse parfois proposer un modèle mathématique exacte d’un
phénomène physique et que les données expérimentales se révèlent insuffisant
rendant la détermination des variables impossible par les méthodes classiques. De ce
fait nous avons souvent recourt à des méthodes d’approximation de données
numériques par des fonction analytiques dans le cas de systèmes linaires.

Nous recherchons la résolution du système pour la détermination de la matrice d’un

système du type . Nous rechercherons des solutions approchées pour des
systèmes impossibles en résolvant un problème d’approximation des moindres carrés.

Nous verrons qu’un tel problème, fondamentale pour de nombreuses applications,

équivaut à un problème de projection orthogonale sur un sous-espace. Nous
verrons également l’avantage qu’il y a de travailler avec des vecteurs orthogonaux, en
particulier la simplification de calcul qu’apporte une base orthogonale.

2. Orthogonalité des vecteurs dans un espace à deux

dimensions .

Soit muni d’un repère rectangulaire, soit un point M de coordonnées .

D’après le théorème de Pythagore, la longueur du vecteur est donnée

par . En désignant le vecteur et nous notons la

longueur du vecteur , nous avons donc :

Soient maintenant et deux point de coordonnées respectives et ,

nous pourrions dire que et sont orthogonaux s’ils définissent un triangle
rectangle. La relation équivalente est la suivante :

, et
 pour obtenir :

Cette dernière expression correspond au produit scalaire des vecteurs et que

nous pouvons également mettre sous la forme matricielle suivante :

avec et

Dans nous définissons donc le produit scalaire des vecteurs et comme étant

égale à par conséquent si nous aurons donc .

Nous soulignerons également que la norme au carré du vecteur est égale à :

3. Orthogonalité des vecteurs dans un espace à n dimensions

.
Nous aurons par la suite la notation suivant où un vecteur peut être considéré comme
une matrice où :

et

avec :

et

bien entendu :
 et

Le produit scalaire des vecteurs et est le réel issu de :

La norme du vecteur est :

Deux vecteurs et sont orthogonaux si et seulement si

Remarque :

est un réel mais ne l’est pas.

est un vecteur colinéaire à .

En conclusion pour tous système du type , où nous souhaitons des solutions

approchées par approximation des moindres carrés, revient à définir la matrice
comme une matrice de projection orthogonale.

4. Approximation par les moindres carrés.

Nous considérons est un système impossible quand le vecteur .

Nous proposons donc de déterminer un vecteur le plus proche possible du
vecteur tel que le vecteur . Cela revient donc chercher le minimum de

l’application ou de façon équivalente le minimum de

Nous noterons la valeur de qui réalise ce minimum. De même est appelé
approximation des moindres carrés de ou meilleur approximation quadratique de
.

5. Recherche de l’approximation des moindres carrés lorsque

est une matrice .
Nous avons donc :
 l’application définit bien une parabole qui admet effectivement un
minimum absolu pour :

6. Recherche de l’approximation des moindres carrés lorsque

est une matrice .

Nous souhaitons donc minimiser l’application où . De

part le résultat précédent, nous déterminons la projection orthogonale du vecteur
sur , puis nous vérifions qu’il s ‘agit de la meilleur approximation quadratique du
vecteur sur . Le fait de chercher tel que soit orthogonal à tout
vecteur de revient dons à chercher tel que :

et

il existe :

et

Soit

Or comme , nous avons donc .

Nous cherchons tel que

D’où :

Comme cela doit être vrai , il faut alors que . Cette équation
est dite équation normale du problème d’approximation des moindres carrés.

Nous remarquons que la matrice de format doit avoir supérieur ou égale à

de façon à ce que le rang de la matrice soit égale à ce qui permettra de rendre
en une matrice carré inversible.
 Ce qui à pour conséquence sur l’équation normale , si est de

rang , de dire que existe et que :

donc et comme .

Nous avons alors :

Nous reconnaissons que pour passer du vecteur au vecteur estimé le terme

est celui d’une matrice de passage ou encore celui d’une matrice de

projection orthogonale.

La question que nous sommes en droit de nous poser est : est-ce que le vecteur
estimé qui est la projection orthogonal de sur est la plus petite
approximation des moindres carrés ? Oui jusqu'à preuve du contraire. En conclusion

pour estimer le système il faut que soit une matrice de

projection orthogonal.

7. Détermination de l’erreur d’approximation.

La meilleur approximation quadratique de sur est et

erreur d approximation vaut .

Nous partons de l’inégalité de Schwarz

.
 On retrouve l’Inégalité de Schwarz où donc :

et .

Le vecteur est la projection du vecteur sur , par conséquent

est à . A noter que :

Donc la meilleur approximation quadratique de sur est :

8. Moindres carrés sous Excel.

L’exemple suivant permet d’illustrer les moindres carrés à l’aide d’Excel (ou autres
tableurs comme lotus, stardivision, applixware et Koffice). Brièvement le principe
consiste à déterminer les paramètres intrinsèques d’une caméra.
Le point M défini par ses coordonnées (X, Y, Z) dans le repère univers est
transformé par une projection perspective. Interviennent dans cette
transformation une matrice T de translations et une matrice R de rotations par la
relation :

Les angles , , et les constantes a, b, c sont les paramètres intrinsèques de

la caméra.

En projection perspective, un point M est transformé en son homologue m dans le

plan écran par :

Soit en notation matricielle :

Les coordonnées écran (cf figure précédente) sont en unité pixel, pour rendre la
transformation homogène, il est nécessaire de convertir l’unité pixel du système
de coordonnées écran en unité métrique par :

coordonnées en pixel, de l’intersection de l’axe optique et du plan image.

dimensions de la taille d’un pixel de la matrice CCD ( et ).

Les équations homogènes sont alors :

soit en notation matricielle homogène, au facteur d’échelle près :

La transformation dans le repère caméra se fait par :

Et la transformation projective complète, du repère univers au repère image, est :

où T est la matrice des translations et R la matrice des rotations, au facteur
d’échelle près.

Ce résultat est de la forme :

Après démonstration nous retrouvons la matrice de taille (3x4) appelée matrice

perspective de la caméra par [Ayache] et [Horaud/Monga]. Cette matrice contient
12 paramètres définis à un facteur d’échelle près. En théorie, il suffit de 6 points
pour déterminer les 11 paramètres de la matrice, la contrainte, le 12ième
paramètre, est généralement m34 = 1. Pour ce faire nous avons utilisé le coin de
Moravec. 6 points non coplanaires y sont extraits pour enfin obtenir la matrice
perspective par la résolution au sens des moindres carrés.

Comme nous ne connaissions pas le facteur d’échelle, nous devons, avant de

résoudre le système, supprimer la composante en faisant un rapport entre la
première composante et , de même avec la seconde. Nous obtenons donc :

Le système d’équation se ramène à :

Pour les 6 points de l’image, le système est composé de 11 équations. D’après

[Horaud et Monge] pour obtenir une solution non trivial il faut fixer .

Soit en notation matricielle :

 Qui est de la forme , où est solution de :

donc

Connaissant les dimensions du pixel de la matrice CCD, nous avons fait la

conversion des données pixels en données métriques afin d’obtenir une matrice de
projection perspective homogène.

Il va sans dire que les moindre carrés peuvent également résoudre tous types de
matrice puisque condition le système pour créer une matrice carré et
inversible. La matrice est définie dans la zone B13:L23 et la matrice est
définie dans la zone Q13 :Q23. Ensuite sélectionnez la zone L27:L38 pour y

inscrire sous la forme Excel suivante :

PRODUITMAT(INVERSEMAT(PRODUITMAT(TRANSPOSE(B13:L23),B13:L23)),
PRODUITMAT(TRANSPOSE(B13:L23),Q13:Q23))
Validez par les touches CTRL SHIFT ENTER
Chapitre V
1. Optimisation des systèmes linéaires avec contraintes
Lorsque nous avons un système linéaire avec contraintes à optimiser bien souvent, et
de manière quasi immédiate, nous recourons à la méthode du simplexe. Cette
méthode a vu le jour durant la seconde guerre mondiale par Georges Dantzig au sein
de l’U.S Air Force, mais pour des raisons évidentes, il ne publia ses travaux qu’en
1947. Le point d’origine du simplexe est la méthode de Gauss, où Dantzig y applique
une stratégie de pivot assez particulière.

2. Définition
La première forme qu’on extrait d’un problème est la forme canonique, pratique pour
les résolution graphique, qui se présente :

De là en découle la forme standard, mieux adapté pour les algorithmes, comme suit :

L’algorithme du simplexe recherche les points extrêmes du polyèdre formé par les
contraintes. Le système à résoudre est composé de variables et de contraintes.
Nous supposons plus de contraintes que d’inconnues et la matrice n’a pas de
colonne nulle.

3. Exemple
Soit le système suivant représenté sous la forme canonique suivante :

avec (fonction coût ou également appelé coût marginal) et

La méthode du simple est une suite de tableau successive décrivant les différentes
étapes de l’algorithme de Dantzig.

1er étape :

Choix de la variable entrante :

En règle générale on choisit la variable entrante celle dont le coût marginale est la
plus élevée, dans notre exemple c’est .

Le vecteur associé à la base est :

2ième étape :

Choix de la variable sortante :

Dans la colonne correspondant à la variable entrante, on calcul les l’ensemble des
quotients des coefficients de la matrice avec ceux de la colonne de la variable
entrante.

On choisit le plus petit des (pivot) qui est donc nous sortons

3ième étape :

La ligne du pivot est divisée par la valeur du pivot

Pour les autres lignes nous appliquons le formule suivante appelée pivotage :

La variable sortante est remplacer par la variable colonne du pivot. On annule

donc le coût marginale et les coefficients suivants correspondant à la colonne du
pivot.
Le vecteur associé à la base est :

Le gain Z-12 est obtenue en calculant le critère de maximisation par les valeurs
de la base

4ième étape :

Choix de la variable entrante : Il ne reste que le coût marginale de et la

variable sortante est car est petit

 5ième étape : Même principe que l’étape 3

C’est la dernière étape car il n’y a plus de coût marginaux positifs ainsi la solution
du problème est :

Le gain maxi est de Z=13.

4. Exercice : la confection
 Une entreprise de confection dispose de 4 ateliers, coupe, couture, broderie,
emballage et disposant respectivement de temps de disponibilité propre de
21000mn, 33000mn, 50000mn et 25000mn.

Le contremaître a relevé les temps de cycle de l’installation sous forme d’un

tableau.

Un contrat avec un géant de la distribution l’engage à fabriquer 4 vêtements

V1,V2,V3,V4. Sur ces produits l’entreprise dégage respectivement sur chaque
vêtement un bénéfice net de 20fr, 24fr, 24fr, 30fr.

L’endettement de l’entreprise est telle que le comptable est contraint d’afficher

une obligation de réaliser un bénéfice d’au moins 80000fr.

Autre mauvaise nouvelle pour l’ingénieur de production, le géant de la distribution

impose une fabrication minimale de 220 vêtements V1 et 500 vêtements V2, 320
vêtements V3 et 400 vêtements V4.

5. Solution Excel

L’utilisation d’Excel par le biais du solveur permet de résoudre, du moins

d’estimer, la solution optimale pour maximiser des bénéfices ou minimiser des
pertes. La solution optimale est obtenue par ajustement en fonction des autres
valeurs. Les données du problème s’inscrivent ainsi sous une représentation
matricielle. On trouve dans la colonne solution les équations canoniques du
système.
La cellule cible contient l’équation canonique de la fonction coût après résolution
elle contiendra la valeur estimé. Les cellules variables représentent les quantités
respectives des vêtements V1, V2, V3, V4 pour les ateliers de Coupe, Couture,
Broderie et Emballages. Ainsi que les divers contraintes. Les cellules variables
contiendrons les solutions du problème par programmation linéaire.

C3=0 D3=0 E3=0 F3=0

H5 =$C$3*C5+$D$3*D5+$E$3*E5+$F$3*F5
H6 =$C$3*C6+$D$3*D6+$E$3*E6+$F$3*F6
H7 =$C$3*C7+$D$3*D7+$E$3*E7+$F$3*F7
H8 =$C$3*C8+$D$3*D8+$E$3*E8+$F$3*F8
H9 =$C$3*C9+$D$3*D9+$E$3*E9+$F$3*F9
H10 =$C$3*C10+$D$3*D10+$E$3*E10+$F$3*F10
H11 =$C$3*C11+$D$3*D11+$E$3*E11+$F$3*F11
H12 =$C$3*C12+$D$3*D12+$E$3*E12+$F$3*F12
H13 =$C$3*C13+$D$3*D13+$E$3*E13+$F$3*F13

Le solveur se trouve dans le menu Outils comme indiqué dans la figure ci-après :
Apparaît ensuite la boîte de dialogue du solveur, où nous nous devons de spécifier
la cellule cible munie de ses contraintes de coût (maximisation ou minimisation),
voire même tributaire d’une valeur.
Viens alors la définition des cellules variables le solveur y rangera ses résultats de
la solution optimale du problème. Les contraintes sont définies une par une selon
l’exigence du problème. Il suffit ensuite de reporter chaque champ dans les
paramètres du solveur.
Les options du solveur permettent d'affiner le processus itératif.
Chapitre VI
1. Méthodes itératives des systèmes linéaires sans contrainte
La résolution de système linéaire par des méthodes directes dépendant en particulier
de la capacité du calculateur. Au delà d’un certain nombre d’équation à un certain
nombre d’inconnues défini par exemple par un critère d’un système temps réel, les
méthodes directes deviennent inappropriées au processus en cours (dépassement de
capacité mémoire, temps de résolution élevé). Nous avons alors recours aux
méthodes itératives.

Pour ce faire, nous résolvons le système , où est une matrice inversible,

en construisant une suite de vecteur , où .

Le vecteur optimal est généralement obtenu après un certain nombre d’itération

lorsqu’on atteint une précision souhaitée appelé également critère d’arrêt.

2. Principe

Les méthodes itératives consistent à utiliser un vecteur initiale

afin de produire une suite de vecteurs du type :

Résoudre le système ou Aest une matrice carrée d’ordre n peut s’écrire

sous une autre forme identique ou encore . Donc à

partir d’un vecteur initiale , on génère une suite de la façon

suivante :

Cette suite est représentée par la relation itérative suivante :

où et

Nous ne peut savoir si le vecteur estimé se dirige vers la solution optimale si un critère
de convergence n’est pas définie. Pour cela vecteur d’erreur est établie par la
relation :

donc :
 Autrement dit la converge existe si l’erreur tend vers lorsqu’on se rapproche de la
solution optimale :

si

3. Décomposition de la matrice A

La décomposition de la matrice est rendue nécessaire pour assurer la convergence

de la méthode. Nous créerons trois matrices, telles que :

est une matrice diagonale :

est une matrice inférieure :

est une matrice supérieure :

De là en découlent trois grande méthodes itératives de résolution de systèmes

linéaire, la méthode de Jacobi, la méthode de Gauss-Seidel et la méthode de
relaxation.

a. Méthode de Jacobi

où et

donc :

b. Méthode de Gauss-Seidel

où et

donc :
 c. Méthode de relaxation

où et

donc :

4. Méthode de Jacobi

Principe

La méthode de Jacobi écrit le système sous la forme itérative suivante :

Il est inutile de rappeler que les pivots doivent être non nuls, dans le cas contraire
il suffit d’intervertir les lignes pour remplir la condition nécessaire.

Condition d arrêt

Ils existent plusieurs conditions pour arrêter l’itération. Elles sont toutes basées sur le
vecteur d’erreur qui doit atteindre un critère prédéfini et tendant vers une valeur
proche de zéro.

On note un vecteur résidu tel que : de sorte que le critère d’arrêt

soit :

, avec choisi petit.

Une autre technique consiste à utiliser une autre test d’arrêt basé sur :

Lorsque l’optimum est voisin de 0, on se contante alors du critère d’arrêt suivant :

Convergence
La convergence est vrai lorsque le résidu ou la précision est toujours inférieur à

Algorithme de Jacobi

Choisir un vecteur initial et le critère d’arrêt .

Créer avec .
Créer avec

Pour ;

Pour ;
Créer avec

Pour ;

Pour ;

Tant que ou ou et .
Calculer

Calculer
Fin de Tant que

Implémentation Scilab de la méthode de Jacobi

// Résolution de système du type A.X=B

// par la méthode itérative de JACOBI
// Initialisation
A=[-16 6 -2 -5;
3 10 -5 1;
-4 1 18 2;
1 2 2 -14];
B=[-19;
1;
12;
1];
X0=[0.1;
0.1;
0.1;
0.1];
Xk=X0;
iter=0;
max_it=500;
tol = 0.0000000000001;

// Conditionnement des matrices D, L et U

n=4;
for i=1:n,
for j=1:n,
I(i,i)=1;
D(i,i)=A(i,i);
if i>j then, L(i,j)=-A(i,j);,
else L(i,j)=0;, end,
if i<j then, U(i,j)=-A(i,j);,
else U(i,j)=0;, end ;
end ; end;
 // première itération
// JACOBI
Xkplus1 = ( inv(D)*(L+U) * Xk + inv(D)* B);
// itérations suivantes
while norm(Xkplus1 - Xk)/norm(Xk) > tol,
iter=iter+1;
Xk = Xkplus1;
// JACOBI
Xkplus1 = ( inv(D)*(L+U) * Xk + inv(D)* B);
end;
// Solution obtenue
iter
Xkplus1

5. Méthode de Gauss-Seidel

Principe

La méthode de Gauss-Seidel écrit le système sous la forme itérative

suivante :

soit :

Même remarque : les pivots doivent être non nuls, dans le cas contraire il suffit
d’intervertir les lignes pour remplir la condition nécessaire.

Condition d arrêt

Nous les rappelons, les critères d’arrêt sont identiques à ceux utilisés dans la méthode
de Jacobi. On note un vecteur résidu tel que : de sorte que le critère
d’arrêt soit :

, avec choisi petit.

Une autre technique consiste à utiliser une autre test d’arrêt basé sur :

Lorsque l’optimum est voisin de 0, on se contante alors du critère d’arrêt suivant :

Convergence

La convergence est vrai lorsque le résidu ou la précision est toujours inférieur à

Algorithme de Gauss-Seidel

Choisir un vecteur initial et le critère d’arrêt .

Créer avec .
Créer avec

Pour ;

Pour ;
Créer avec

Pour ;

Pour ;

Tant que ou ou et .
Calculer

Calculer
Fin de Tant que

Implémentation Scilab de la méthode de Gauss-Seidel

// Résolution de système du type A.X=B

// par la méthode itérative de GAUSS-SEIDEL

// Initialisation
A=[-16 6 -2 -5;
3 10 -5 1;
-4 1 18 2;
1 2 2 -14];
B=[-19;
1;
12;
1];
X0=[0.1;
0.1;
0.1;
0.1];
Xk=X0;
iter=0;
max_it=500;
tol = 0.0000000000001;
// Conditionnement des matrices D, L et U
n=4;
for i=1:n,
for j=1:n,
I(i,i)=1;
D(i,i)=A(i,i);
if i>j then, L(i,j)=-A(i,j);,
else L(i,j)=0;, end,
if i<j then, U(i,j)=-A(i,j);,
 else U(i,j)=0;, end ;
end ; end;

// première itération
// GAUSS-SEIDEL
Xkplus1 = (
inv(D-L)*U * Xk + inv(D-L)* B)
// itérations suivantes
while norm(Xkplus1 - Xk)/norm(Xk) > tol,
iter=iter+1;
Xk = Xkplus1;
// GAUSS-SEIDEL
Xkplus1 = ( inv(D-L) * U * Xk + inv(D-L)* B);
end;
// Solution obtenue
iter
Xkplus1

6. Méthode de relaxation

Principe

La méthode de relaxation basée sur la méthode de Gauss-Seidel. On écrit le système

sous la forme itérative suivante après avoir poser :

où est le vecteur estimé par la méthode de Gauss-Seidel.

Si équivalent à la méthode de Gauss-Seidel
Si méthode de sur-relaxation
Si méthode de sous-relaxation

Même remarque : les pivots doivent être non nuls, dans le cas contraire il suffit
d’intervertir les lignes pour remplir la condition nécessaire.

Condition d arrêt

Nous les rappelons, les critères d’arrêt sont identiques à ceux utilisés dans la méthode
de Jacobi. On note un vecteur résidu tel que : de sorte que le critère
d’arrêt soit :

, avec choisi petit.

Une autre technique consiste à utiliser une autre test d’arrêt basé sur :
Lorsque l’optimum est voisin de 0, on se contante alors du critère d’arrêt suivant :

Convergence

La convergence est vrai lorsque le résidu ou la précision est toujours inférieur à

Algorithme de relaxation

Choisir un vecteur initial , le critère d’arrêt et le coefficient de relaxation .

Créer avec .
Créer avec

Pour ;

Pour ;
Créer avec

Pour ;

Pour ;

Tant que ou ou et .
Calculer

Calculer

Calculer
Ou bien comme souvent présenté dans les littératures

Calculer
Fin de Tant que

Implémentation Scilab de la méthode de relaxation

// Résolution de système du type A.X=B

// par la méthode itérative de relaxation
// Initialisation
A=[-16 6 -2 -5;
3 10 -5 1;
-4 1 18 2;
1 2 2 -14];
B=[-19;
1;
12;
1];
X0=[0.1;
0.1;
0.1;
0.1];
Xk=X0;
iter=0;
max_it=500;
tol = 0.0000000000001;
// Conditionnement des matrices D, L et U
n=4;
for i=1:n,
for j=1:n,
I(i,i)=1;
D(i,i)=A(i,i);
if i>j then, L(i,j)=-A(i,j);,
else L(i,j)=0;, end,
if i<j then, U(i,j)=-A(i,j);,
else U(i,j)=0;, end ;
end ; end;

// THEOREME
// Pour toute matrice A, une condition necessaire
// de convergence
// est que 0 < w < 2.
// première itération
// RELAXATION
w=1.1
Xkplus1 = ( inv(D-w*L) * ((1-w) * D + w*U) * Xk + inv(D-w*L)*
w*B);
// itérations suivantes
while norm(Xkplus1 - Xk)/norm(Xk) > tol,
iter=iter+1;
Xk = Xkplus1;
// RELAXATION
Xkplus1 = ( inv(D-w*L) * ((1-w) * D + w*U) * Xk + inv(D-w*L)*
w*B);
end;
// Solution obtenue
iter
Xkplus1
Chapitre VII
1. Optimisation monodimensionnelle, Méthode dichotomique
Le procédé rapide à implémenter et efficace pour l’estimation d’une racine d’une
fonction est la dichotomie. Dans un intervalle déterminé, la dichotomie trouve une
solution qui satisfait un critère initialement déterminé.

La valeur optimale, solution de la fonction est obtenue à la kème itérations. On

détermine deux évaluations de la fonction à chaque itération qui donne la relation
suivante :

La recherche de l’optimum est obtenue par la recherche de l’intervalle minimum de

séparation entre et annulant la fonction à epsilon prés.

Implémentation Scilab de la méthode de la dichotomie 1

// Recherche d'une racine d'un polynôme

// du type a.x^5 + b.x^4 + c.x^3 + d.x^2 + e.x + f = 0
// par la méthode dichotomique 1
// D'abord lancer (getf('C:\scliab\fonction.sci'))
// le fichier fonction.sci contiendra la fonction
// polynomiale suivante :
// function [y]=f(x)
// y =x^5 - 2*x^4 + 2*x^3 - 26*x^2 + 19*x + 22
// Initialisation
tol = 0.001;
iter= 0;
max_iter=500;
s = 0.0000000001;
// Borne [1,2]
xa = 1; xb = 2; eps = 0.00000001;
ya=f(xa);

// itérations suivantes
 while abs(xb - xa) > 2 * eps,
iter=iter+1;
xc = 0.5 * (xa + xb);
yc = f(xc);
if (yc*ya) < 0 then, xb = xc;,
else ya = yc; xa = xc;, end,
end;
// Solution obtenue
iter
xc

Implémentation Scilab de la méthode de la dichotomie 2

// Recherche d'une racine d'un polynôme

// du type a.x^5 + b.x^4 + c.x^3 + d.x^2 + e.x + f = 0
// par la méthode dichotomique 2
// d'abord lancer (getf('C:\scliab\fonction.sci'))
// pour la fonction polynomile suivante
// function [y]=f(x)
// y =x^5 - 2*x^4 + 2*x^3 - 26*x^2 + 19*x + 22
// Initialisation
tol = 0.001;
iter= 0;
max_iter=50;
s = 0.0000000001;
// Borne [1,2]
xa = 1; xb = 2; eps = 0.00000001;
ya=f(xa);

// itérations suivantes
while abs(xb - xa) > 2 * eps,
iter=iter+1;
xc = 0.5 * (xa + xb)- s;
xd = xc + 2 * s;
yc = f(xc);
yd = f(xd);
if yc <= yd then, xb = xd;,
else xa = xc;, end,
end;
// Solution obtenue
iter
xc

2. Méthode du nombre d’or

Le nombre d’or n’est pas issu d’une formule ésotérique mais bien d’une relation
géométrique permettant d’obtenir un rapport harmonieux dans les arts : peinture
sculpture musique, … Il a fait son apparition dans la construction des pyramides
en Egypte et Grèce où le Parthénon d’Athènes construit au cinquième siècle avant
l'an zéro est tel que la relation de ses dimensions est le nombre d’or. D’après
Euclide, prenons un segment de droite où nous positionnons un point situé
entre et de sorte que :
En remplaçant , on obtient :

Le nombre d or est la racine positive de l’équation précédente, noté :

L’idée de la méthode du nombre d’or est de diviser l’intervalle d’un facteur

constant à chaque itération, en tenant compte de deux points et symétrique
par rapport au centre. On gagne un calcul de fonction (a contrario de la méthode

dichotomique) en attribuant à si

si

Ainsi la relation qui lie les variables et symétrique par rapport au centre est :

Prenons, par exemple le cas où , donc :

et

Si l’on souhaite que nous nous devons alors de développer le terme

en utilisant la relation à la kième + 1 itérations, donc :

et en substituant par et par nous obtenons :

en simplifiant par nous avons

La racine positive de cette équations est qui égale à l’inverse du

nombre d’or .

Implémentation Scilab du nombre d or

// Recherche d'une racine d'un polynôme

// du type a.x^5 + b.x^4 + c.x^3 + d.x^2 + e.x + f = 0
// par la méthode dichotomique
// d'abord lancer (getf('C:\scliab\fonction.sci'))
// pour la fonction polynomile suivante
// function [y]=f(x)
// y =x^5 - 2*x^4 + 2*x^3 - 26*x^2 + 19*x + 22
// Initialisation
tol = 0.001;
iter= 0;
max_iter=50;
s = 0.0000000001;
nb_dor = 0.5*(sqrt(5) - 1)
// Borne [1,2]
xa = 1; xb = 2; eps = 0.00000001;
xc = xa + (1-nb_dor)*(xb-xa);
xd = xa + nb_dor*(xb-xa);
// itérations suivantes
while abs(xb - xa) > eps,
iter=iter+1;
yc = f(xc);
yd = f(xd);
if yc > yd then, xa = xc;
xc = xd;
xd = xa + nb_dor*(xb-xa);,
else xb = xd;
xd = xc;
xc = xa + (1-nb_dor)*(xb-xa);, end,
end;
// Solution obtenue
iter
xc
Chapitre VIII
1. Optimisation multidimensionnelle sans contrainte.
analyse numérique nous permettra d évaluer numériquement les racines de
un système non linéaire d équations quadratiques. Notre problème consiste

à trouver le vecteur vérifiant les quatre équations non

linéaires suivantes :

Où les coefficients sont des constantes réelles. Nous pouvons

également écrire le système sous la forme plus générale . Nous

exposerons pas toutes les méthodes possibles car elles sont nombreuses.
Par contre nous n utiliserons que les méthodes les plus importantes et les
plus utilisées (de préférence les plus robustes) pour les systèmes
quadratiques.

Le noyau de base de l analyse numérique et de l optimisation est la formule

de Taylor sur les accroissements finis. Si et ses premières dérivées

existent et sont continues sur le segment et si existent dans

intervalle il existe alors un nombre de l intervalle tel que :

Condition d arrêt

A causes des problèmes de lenteur de convergence, ou de divergence voire

même de stationnarité, nous utilisons une ou les conditions d arrêts
suivants :

Si : Arrêt dès que la distance .

 Si : Arrêt dès que le déplacement relatif .

Si : Arrêt dès que la fonction à diminué de moins de

Si : Arrêt dès que l amélioration relatif .

Efficacité de l algorithme

Hormis le fait que l algorithme puisse trouver une solution en peu d itérations
et également qu il ne soit pas tributaire du nombre d itérations, un
algorithme est robuste lorsqu il a une bonne convergence asymptotique, c est
à dire lorsque le vecteur estimé est proche du vecteur à près, que nous
écrivons également sous la forme suivante :

2. Méthode de Newton et de ses variantes.

Soit donc notre système :

Soit le vecteur d approximation initiale de la solution de

notre système. Le rôle de la méthode de Newton est de déterminer une

correction au vecteur de tel sorte que :

Pour estimer , nous faisons un développement de Taylor

ordre 1 en quatre variables pour chacune des fonctions :
Pour déterminer , nous résolvons le système linéaire suivant :

ou encore sous forme matricielle :

Ce système linéaire s écrit également sous une forme plus compacte :

Où désigne la matrice jacobienne évalué au vecteur initial

, où est le vecteur des corrections relatives à

chaque variable et où est le vecteur résidu évalué en

Nous posons ensuite :

Qui est la première approximation de la solution de notre système non
linéaire. Par la suite les nouvelles valeurs s écrivent ainsi :

a) Méthode de Newton.
De façon plus condensé :

avec

ou

Algorithme de Newton.

Choisir le critère d arrêt .

Tant que .

Résoudre le système linéaire

Mettre à jour .

Fin de Tant que

Implémentation Scilab de la méthode de Newton

// Recherche d'une solution d'un système

// d'équation non linéaire
// par la méthode de Newton
// d'abord lancer (getf('C:\scliab\fonction.sci'))
// pour la fonction suivante
//function [y1,y2,y3] = f(x)
//y1 = 4*(x(1)^2 + x(2)^2) - 2*x(1)*x(2) - 6*(x(1) + x(2));
//y2 = x(1)^3 + 2*x(2)^2 - 1
//y3 = 5*x(2)^3 + x(1)^2 - 2*x(1)*x(2) - 4
//function [dy1_x1,dy1_x2,dy2_x1,dy2_x2,dy3_x1,dy3_x2] =df(x)
//dy1_x1 = 8*x(1) - 2*x(2) -6;
//dy1_x2 = 8*x(2) - 2*x(1) -6;
 //dy2_x1 = 3*x(1)^2;
//dy2_x2 = 4*x(2);
//dy3_x1 = 2*x(1) - 2*x(2);
//dy3_x2 = 15*x(2)^2 - 2*x(1);
// Initialisation
iter= 0; max_iter=500; tol = 0.0000000001;
// vecteur initiale
Xk = [0.1 ; 0.1];
// première itération
[y1,y2,y3] = f(Xk);
y =[y1;y2;y3]
[dy1_x1,dy1_x2,dy2_x1,dy2_x2,dy3_x1,dy3_x2]= df(Xk);
J = [dy1_x1,dy1_x2;
dy2_x1,dy2_x2;
dy3_x1,dy3_x2]
// resolution du système J(x).delta(x) = -R(x)
deltax = - J \ y;
Xkplus1 = Xk + deltax;
// itérations suivantes
while norm(Xkplus1 - Xk)/norm(Xk) > tol,
iter=iter+1;
Xk = Xkplus1;

[y1,y2,y3] = f(Xk);
y =[y1;y2;y3];
// Calcul de la jacobienne
[dy1_x1,dy1_x2,dy2_x1,dy2_x2,dy3_x1,dy3_x2]= df(Xk);
J = [dy1_x1,dy1_x2;
dy2_x1,dy2_x2;
dy3_x1,dy3_x2];
// resolution du système J(x).delta(x) = -R(x)
deltax = - J \ y;
Xkplus1 = Xk + deltax;

end;
// Solution obtenue
iter
Xkplus1

b) Méthode de Quasi-Newton.
La méthode de Quasi-Newton apporte une légère modification à la méthode
de Newton en ne réévaluant que tous les itérations, où est déterminé
par le programmeur. Il y a certes une diminution de la quantité d opérations
par contre on perd la convergence quadratique. Nous avons constaté que par
rapport à la méthode de Newton, il fallait deux fois plus d itérations pour en
arriver au même résultat.

c) Méthode de Newton-Raphson.

Cette méthode exige que soit deux fois dérivable car elle utilise

approximation quadratique de au vecteur courant :

Le vecteur suivant est pris de façon à annuler , d où :

 Algorithme de Newton-Raphson.

Choisir le critère d arrêt .

Tant que .

Caculer

Mettre à jour .

Fin de Tant que

d) Méthode de Newton amortie.

Nous avons pu constater dans les méthodes précédentes que la condition

n’était pas souvent réalisée. Force de constater l’échec des

méthodes précédentes pour notre système, nous avons essayé cette méthode qui
permet de ce déplacer dans la direction d’un pas où est choisi tel qu’il

satisfasse la condition .

L’algorithme de Newton devient alors :

avec

3. Méthode de Minimisation.

Le principe des méthodes de Minimisation est basé sur la recherche d’un minimum
absolu de la fonctionnelle , où , au vecteur estimé
qui est solution du système .
 Figure 1 : Vecteur

Soit un vecteur de norme définie dans un espace à trois

dimensions par ses coordonnées x, y et z.

Le calcul du Gradient de la fonctionnel R est :

On en déduit le gradient de R :

Le gradient est donc un vecteur parallèle et dans la même direction que sa

fonctionnelle. Autrement dit le gradient a la particularité de nous indiquer la
direction à suivre.

Figure 2 : Vecteur et son gradient

4. Méthode du Gradient.

La méthode du Gradient ou méthode de la plus grande pente remplace notre

problème de recherche de racines par un problème de minimisation. La fonction à
minimiser est :
Nous calculons ensuite le gradient de :

Ensuite nous passons du vecteur estimé au vecteur estimé suivant dans la

direction de plus grande pente de au pas de descente :

est choisi tel qu’il satisfasse la condition

Le pas de descente est calculé de telle sorte qu’il minimise la fonctionnelle, dans
le cas pratique, il est rarement calculer, on prend généralement un pas de

descente suffisamment petit pour qu’il satisfasse la condition .

algorithme du gradient est le suivant :

Choisir un vecteur initial et le critère d’arrêt .

Tant que .

La direction est

Calculer le pas de descente tel que .

Mettre à jour .

Fin de Tant que

Remarque

La méthode du gradient a une convergence initiale rapide mais la présence de

vallées la fait osciller et rend sa convergence très lente quand nous nous
rapprochons de la solution. Mais l’avantage de cette méthode est la convergence
certaine même avec un vecteur initialement loin de la solution. Suivant les points
de projection de la cible obtenus, cette méthode nous permet d’obtenir une
estimation de la localisation au bout de sept jours d’itérations. Il est vrai que nous
ne pouvons pas implémenter cette méthode dans un processus temps réel. Nous
envisageons donc, pour la résolution de notre système quadrique, un processus
itératif non stationnaire pour accélérer le pas de descente du gradient, c’est à dire
que nous introduirons à chaque itération des informations nouvelles pour
l’estimation du pas de descente.
 Implémentation Scilab du Gradient

// Recherche d'une solution d'un système

// d'équation non linéaire
// par la méthode du Gradient
// d'abord lancer (getf('C:\scliab\fonction.sci'))
// pour la fonction suivante
//function [y] = f(x)
//y = 4*(x(1)^2 + x(2)^2) - 2*x(1)*x(2) - 6*(x(1) + x(2));
//function [dy_x1,dy_x2] = Gradf(x)
//dy_x1 = 8*x(1) - 2*x(2) -6;
//dy_x2 = 8*x(2) - 2*x(1) -6;
// Minimisation de f(X + t.gradf(X))
//f(X+t.gradf(X)) = 4(x1+t.dy_x1)^2 + 4(x2+t.dy_x2)^2
// -2(x1+t.dy_x1)(x2+t.dy_x2)
// -6(x1+t.dy_x1+x2+t.dy_x2)
//
// df/dt = 8(x1+t.dy_x1)+8(x2+t.dy_x2)dy_x2
// -2(x1+t.dy_x1)dy_x2-2(x2+t.dy_x2)dy_x1
// -6(dy_x1+dy_x2) =0
//
// 6(dy_x1+dy_x2)+2(x1.dy_x2+x2.dy_x1)-8(x1*dy_x1+x2*dy_x2)
//t= --------------------------------------------------------
// 8(dy_x1^2+dy_x2^2) - 4.dy_x1.dy_x2
//
// Initialisation
iter= 0; max_iter=500; tol = 0.0000000001;
// dérivée seconde
d2f = [8, -2; -2 8 ];
// vecteur initiale
Xk = [3 ; 2];
// première itération
[y] = f(Xk)
[dy_x1,dy_x2]= Gradf(Xk);Gf = -[dy_x1;dy_x2]
// Determination de t par minimisation de f(x + t Gradf(x))
x1 = Xk(1); x2 = Xk(2);
t = 6*(dy_x1+dy_x2)+2*(x1*dy_x2 + x2*dy_x1)-8*(x1*dy_x1 +
x2*dy_x2);
t = t / ( 8*(dy_x1^2+dy_x2^2)-4*dy_x1*dy_x2)
// Estimation de Xk
Xkplus1 = Xk - t * Gf
// itérations suivantes
while norm(Xkplus1 - Xk)/norm(Xk) > tol,
iter=iter+1;
Xk = Xkplus1;
[y] = f(Xk);
[dy_x1,dy_x2]= Gradf(Xk);Gf = -[dy_x1;dy_x2];
x1 = Xk(1); x2 = Xk(2);
t = 6*(dy_x1+dy_x2)+2*(x1*dy_x2 + x2*dy_x1)-8*(x1*dy_x1 +
x2*dy_x2);
t = t / ( 8*(dy_x1^2+dy_x2^2)-4*dy_x1*dy_x2);
// Estimation de Xk
Xkplus1 = Xk - t * Gf;
end;

// Solution obtenue
iter
Xkplus1

5. Méthode du Gradient conjugué.

La méthode du Gradient Conjugué est la méthode la plus puissante et la plus
fiable utilisée en Optimisation multidimensionnelle sans contrainte. Elle repose sur
le concept de direction conjuguées parce que les gradients successifs sont
orthogonaux entre eux et aux directions précédentes. L’idée initiale était de
trouver une suite de direction permettant de minimiser une fonction Quadratique
ou un système Quadrique de vers .

En effet la fonction Quadrique précédemment étudiée s’écrit ainsi :

ou :

avec :

, et

a est une matrice carré et symétrique (propriété des coniques). Nous remarquons
quelques propriétés intéressantes des fonctions Quadratique :

, le gradient de la fonction Quadrique est une fonction linéaire.

, le Hessien est une constante

, la différence de Gradient est le Hessien de la

différence des positions. Ainsi le centre de symétrie des courbes de F est définie
par :

Les axes de symétrie ont pour directions les vecteurs propres de la matrice a.

La méthode du Gradient conjugué de Fletcher et Reeves dévie la direction de

plus forte pente en lui ajoutant un multiple positif de la dernière directions

conjuguées. Notre fonction à minimiser est .

Algorithme du Gradient Conjugué de Fletcher et Reeves

 Choisir un vecteur initial et le critère d’arrêt et tel qu’il minimise
.

Mettre à jour .

La première direction est

Tant que

Calculer le pas de descente tel qu’il minimise .

Calculer la descente , où

Mettre à jour .

Fin de Tant que

La minimisation de se traduit par la recherche de racine d’un polynôme

du troisième degré par dichotomie.

Le terme est le point essentiel de

l’algorithme de Fletcher et Reeves. Nous avons constaté la convergence rapide vers
la solution en quelques secondes (environ 4000 itérations machine pour un critère de
1E-10 . Par la suite deux autres formules du coefficient ont étédéveloppées :

le coefficient de Polak et Ribière :

La convergence est beaucoup plus rapide pour la méthode de Polak et Ribière que la
méthode de Fletcher et Reeves.

le coefficient de Hestenes et Stiefel :

Avec le coefficient de Hestenes et Stiefel, nous avons pu résoudre notre
système en peu d’itération (environ 300 itérations pour un même critère utilisée dans
les méthodes précédentes).