Vous êtes sur la page 1sur 27

UNIVERSITÉ DU QUÉBEC À CHICOUTIMI

Module d’ingénierie.

ATELIER DE
PROGRAMMATION 3

TESTS, BOUCLES
ET FONCTIONS

Omar Noui, Ph. D.

Chargé de cours au département d’informatique et mathématique .


TABLE DES MATIERES
Table des matières............................................................................................... 2

1. Introduction : ................................................................................................ 3

2. Intéraction Utilisateur-machine: ................................................................. 4

2.1. Options d’affichage : ............................................................................... 4

2.2. Entrée d’informations : .......................................................................... 6

3. Expressions logiques : .................................................................................. 8

4. Structures de contrôle : .............................................................................. 10

4.1. Test if : ................................................................................................ 10

4.2. Boucle while :.................................................................................... 12

4.3. Boucle for : .......................................................................................... 14

4.4. Commande break : .............................................................................. 16

5. Les fonctions : ............................................................................................. 17

6. Exemples du cours : ................................................................................... 22

6.1. Méthode du point fixe :......................................................................... 22

6.2. Factorisation de Cholesky : .................................................................. 25

Références : ........................................................................................................ 27
1. INTRODUCTION :
Dans cet atelier, nous allons présenter les outils de base de la
programmation sur Octave. Premièrement, nous allons exposer les
différentes commandes permettant de faciliter l’interaction utilisateur-
machine. Ensuite, nous allons présenter les outils permettant d’écrire et de
manipuler des expressions logiques (booléennes). Par la suite, nous allons
exposer les syntaxes des différentes structures de contrôles (tests,
boucles…) en illustrant par des exemples simples et d’autres plus élaborés.
Ensuite, nous allons expliquer comment créer des fonctions personnalisées
sur Octave. Finalement, nous allons présenter des exemples d’algorithmes
en analyse numérique en donnant des explications sur toutes les étapes de
leur élaboration.
2. INTÉRACTION UTILISATEUR-MACHINE:
Dans cette section nous allons présenter quelques commandes permettant
une interaction entre l’utilisateur et le logiciel. Dans un programme, il est
possible par exemple d’afficher à l’utilisateur un message d’erreur ou de lui
demander de rentrer manuellement la valeur d’une variable.

2.1. Options d’affichage :


Il existe plusieurs commandes qui permettent d’afficher des informations
ou des messages à l’utilisateur. Voici quelques-unes :

a) Commande disp :
Contrairement au fait d’écrire seulement le nom de la variable, cette
commande n’affiche que son contenu. Voici un exemple illustrant l’affichage
sans et avec la commande disp :

Le résultat dans la fenêtre de commandes s’affiche comme suit :

Il est possible d’utiliser cette commande pour afficher un contenu


quelconque sans qu’il soit affecté à une variable.

b) Commande printf :
C’est une commande permettant d’afficher le contenu d’une ou plusieurs
variables de manière plus élaborée. Par exemple, il est possible de spécifier le
nombre de décimales à afficher ou de retourner un nombre sous la notation
scientifique et plus encore. Le premier argument de la commande peut contenir
une chaîne de caractères. Dans chaque emplacement où on veut afficher le
contenu d’une variable, on met le symbole % suivit du format d’affichage de ce
contenu. Les arguments suivants sont les variables que l’on veut placer saisies
dans l’ordre d’affichage. Voici quelques possibilités de formats possibles :

Affiche le contenu de la variable comme entier


%i
(integer)

Affiche le contenu de la variable comme nombre réel


%f
à virgule flottante (float)

Affiche le contenu de la variable en notation


%e
scientifique en utilisant un exposant

%s Affiche le contenu de la variable comme chaîne de


caractère (string)
%% Affiche le symbole de pourcentage %
\n Précise qu’il faut retourner à la ligne à ce niveau.
Spécifie qu’il faut utiliser 8 colonnes pour l’affichage
%8f
du contenu en virgule flottante
Spécifie qu’il faut utiliser 10 colonnes pour
%10.8f
l’affichage du nombre avec 8 décimales
L’exemple suivant montre comment utiliser les différentes options et
syntaxes proposées pour cette commande.

Notons que la commande de la ligne 7 doit être écrite sur la même ligne (le
retour à la ligne a été effectué seulement pour pourvoir faire la capture
d’écran). Le résultat de la commande s’affiche ainsi :
c) Commandes warning et error :
Ces deux commandes permettent d’afficher un message d’avertissement
(ou d’erreur). La différence entre les deux est que error arrête l’exécution du
reste du script. Ce qui n’est pas le cas avec warning. Le message d’erreur peut
être écrit de la même façon que la commande printf en suivant les mêmes
règles. Ceci nous permet d’inclure le contenu des variables en cas de besoin.
Dans l’exemple qui suit, nous avons utilisé les deux commandes dans le même
script :

Remarquons que les deux messages sont terminés par \n(retour à la ligne).
Ceci nous permet d’éviter qu’Octave affiche un autre message d’erreur. La
commande exécutée sera affichée de la façon suivante :

On peut facilement remarquer que le programme a continué son exécution


après la commande warning. Cependant, la ligne 7 n’a pas été exécutée
puisqu’elle vient après la commande error.

2.2. Entrée d’informations :


Dans plusieurs situations, on peut créer un programme qu’un autre
utilisateur devra utiliser. Dans ce cas, on peut programmer un script ou une
fonction où l’utilisateur devra entrer les valeurs de certaines variables
manuellement. Pour se faire, on utilise la commande input. Une fois la valeur
est saisie par l’utilisateur, elle sera attribuée à une variable spécifique pour
être utilisée dans le programme. Voici un script qui permet de rentrer
manuellement un nombre d’heures et le convertir en minutes :

On demande à l’utilisateur de rentrer un nombre d’heures que nous


attribuant à la variable x. Puis, on lui retourne la valeur en minute en utilisant
printf. Dans la fenêtre de commandes, on voit apparaître la phrase : « Entrez
un nombre d’heures ». L’utilisateur écrit le nombre d’heures qu’il souhaite
convertir (par exemple 31) et puis sur le bouton « Enter ». Le programme
convertit ensuite le nombre d’heures en minutes et utilise la commande printf
pour retourner la chaîne de caractère avec la réponse comme le montre l’image
ci-dessous.

Il est possible de vérifier si l’utilisateur a entré une valeur ou qu’il a


seulement cliqué sur « Enter » sans entrer aucune information. Pour se faire,
on peut utiliser la commande isempty(nom_de_la_variable). Il est aussi
possible d’ajouter un arrêt d’exécution d’un script à un emplacement spécifique
en ajoutant la commande pause à l’emplacement où on veut que le programme
s’arrête. L’utilisateur devra cliquer sur « Enter » pour continuer l’exécution.
3. EXPRESSIONS LOGIQUES :
Les expressions logiques (ou booléennes), sont des énoncés mathématiques
dont on peut répondre par vrai (1) ou faux (0). En programmation, on a souvent
besoin de ce type d’expression pour définir une condition d’application d’un test
ou une condition d’arrêt d’une boucle. Octave reconnaît ces expressions comme
étant de type logical. En général, ces expressions sont sous forme d’égalité,
d’inégalité ou une composition d’expressions. Il est possible de vérifier si une
expression est logique en effectuant le test islogical(expr). Ce dernier
affiche 1 si oui, sinon il affiche 0. Le tableau suivant présente différents
symboles utilisés dans des expressions logiques :

x==y
Teste si x est égale à y.
eq(x,y)
x~=y
Teste si x est différent de y.
ne(x,y)
x<y
Teste si x est inférieur strictement que y.
lt(x,y)
x<=y
Teste si x est inférieur ou égal à y.
le(x,y)
x>y
Teste si x est supérieur strictement que y.
gt(x,y)
x>=y
Teste si x est supérieur ou égal à y.
ge(x,y)

Pour que ces expressions soient logiques, il faut que les variables x et y
soient affectées par une valeur. Sinon, le logiciel ne pourra pas décider si
l’expression est vraie ou fausse. Notons, que deux méthodes sont proposées
pour chaque teste. Le tableau ci-dessous donne les différentes opérations
logiques que nous pouvons effectuer sur des expressions booléennes :

Effectue la négation de l’expression, c.-à-d. inverser


~expr sa valeur de vérité. (Si expr est vraie alors sa
négation est fausse et vice versa).
Effectue l’opération du « ET » logique entre les deux
expr1 & expr2
expressions, c.-à-d. que pour que le résultat soit vrai,
and(expr1,expr2)
il faut que les deux expressions soient vraies.
Effectue l’opération du « OU » logique entre les deux
expr1 | expr2 expressions, c.-à-d. que pour que le résultat soit vrai,
or(expr1,expr2) il faut que soit l’une, soit l’autre, soit les deux soient
vraies.
Effectue l’opération du « OU exclusif » entre les deux
xor(expr1,expr2) expressions, c.-à-d. que le résultat et vrai l’une ou
l’autre et vrai mais pas les deux au même temps.
L’exemple suivant illustre les différentes opérations et commandes vues
dans cette section :

Le lecteur prendra soin de vérifier les réponses dans la ligne de commandes


dans la figure ci-dessous :
4. STRUCTURES DE CONTRÔLE :
Les structures de contrôle sont des instructions spéciales qui permettent
d’exécuter des opérations de manières itératives (boucles) ou sous des
conditions (tests). Les structures de contrôle sont la base de la programmation
d’algorithmes en analyse numérique. Il est important de comprendre leur
fonctionnement et de les utiliser d’une manière appropriée.

4.1. Test if :
C’est une structure qui permet d’exécuter des instructions seulement si une
ou des conditions sont satisfaites. Le tableau suivant présente les syntaxes
possibles de ce test ainsi que leur traduction :

if condition
Si condition (expr logique) est vraie
instruction 1
alors on exécute le bloc d’instructions
else
1. Sinon on exécute le bloc
instruction 2
d’instructions 2.
endif (ou end)
if condition 1
Si la condition 1 est vraie, on exécute
instruction 1
l’instruction 1, sinon si la condition
elseif condition 2
2 est vraie, on exécute l’instruction
instruction 2
2,…, sinon si la condition n-1 est

vraie, on exécute l’instruction n-1,
elseif condition n-1
sinon, on exécute l’instruction n.
instruction n-1
else
instruction n
endif (ou end)

Notons que le elseif peut être répété autant de fois que l’on souhaite. Le
test if vérifie les conditions dans l’ordre dans lequel elles sont écrites. Le
dernier bloc d’instructions ne peut s’exécuter que si aucune des conditions
d’avant n’est satisfaite. L’exemple suivant teste si un nombre est positif,
négatif ou nul :

À chaque fois qu’on modifie la valeur de la variable, le test vérifie d’abord


si elle est positive, si oui il affiche qu’elle est strictement positive et il s’arrête.
Sinon il vérifie si elle est nulle, si oui, il affiche qu’elle est nulle et s’arrête.
Sinon, il affiche qu’elle est strictement négative et s’arrête. Notons que pour ce
dernier cas, on n’a pas besoin de spécifier une condition. Si un nombre n’est ni
strictement positif ni nul, il n’aura pas le choix d’être strictement négatif. Voici
un autre exemple ou des tests sont imbriqués dans le test principal. Le but et
de déterminer si le nombre est positif, négatif ou nul, et de vérifier s’il est pair
ou impair :
À part le cas où x est nul, nous avons implanté un autre test pour vérifier
si x est pair ou impair dans les autres cas. Nous allons voir plus tard, que
combinés à des boucles, les tests if sont très souvent indispensables.

4.2. Boucle while :


La boucle while (tant que) permet d’exécuter en boucle un bloc
d’instructions tant qu’une condition est satisfaite (expression logique vraie). La
boucle ne s’arrêtera que lorsque la condition ne sera plus satisfaite. La syntaxe
de la boucle est présentée dans le tableau suivant :

while condition
Tant que la condition (expr-logique) est
instructions
satisfaite, effectuer les instructions.
endwhile

Il faut être vigilant lors de l’utilisation de cette boucle. Il faut toujours


s’assurer que la condition ne va plus être satisfaite à un certain niveau de
calculs. Sinon, la boucle risque de ne pas s’arrêter et de créer une boucle folle
qu’on sera obligés d’arrêter manuellement. Lorsqu’on utilise la boucle while,
on a souvent besoin d’initialiser les variables utilisées dans la boucle. Ceci
permet de vérifier la condition à la première itération. L’exemple suivant est
un programme qui permet de retrouver les cubes (entiers s’écrivant comme 𝑘 3 )
inférieurs à 1000.

Notons que pour éviter d’afficher les calculs intermédiaires de chaque


itération, il faut utiliser des « ; » à la place des « , » à la fin de chaque ligne dans
la boucle. Ensuite, on affiche seulement la dernière valeur calculée. Le résultat
est alors affiché comme le montre la figure suivante :

L’exemple suivant permet de chercher les 40 premiers nombres premiers


(Rappel : un nombre premier est divisible par 1 et lui-même seulement). Nous
allons utiliser la commande isprime qui vérifie si un nombre est premier ou
non. Le programme doit afficher les 40 nombres premiers ainsi que calculer
leur somme. La figure ci-dessous affiche le script en question avec des
commentaires sur chaque ligne. Le lecteur prendra le soin de bien les lire afin
de comprendre l’utilité de chaque ligne :

Le résultat s’affiche comme suit :


Remarquons que puisque le vecteur ligne P est long (contient 40 éléments),
il s’affiche en plusieurs lignes.

4.3. Boucle for :


À l’instar de la boucle while, la boucle for est très importante en
programmation. Cette boucle est utilisée généralement lorsqu’on connait le
nombre d’itérations à effectuer ou lorsqu’on veut parcourir un ensemble fini
d’éléments connus. Le but de cette boucle est d’exécuter les mêmes instructions
pour différentes valeurs successives d’une variable. Cette dernière peut être
un scalaire ou un vecteur. La syntaxe permettant d’écrire une boucle for sur
Octave est donnée dans le tableau suivant :

for i=valeurs Pour i allant du premier élément de

instructions valeurs au dernier, on effectue les


endfor instructions.

Si valeurs est une vecteur ligne (ou une série), alors i est un scalaire
prenant comme valeurs les éléments successifs du vecteur valeurs. Si
valeurs est une matrice, alors, i est un vecteur prenant comme valeurs les
colonnes successives de la matrice valeurs. L’exemple simple suivant calcule
la somme des nombres pairs entre 1 et 100 en utilisant une boucle for.
Il n’est pas nécessaire d’afficher le résultat de S pour chaque itération. On
utilise le « ; » dans ce cas à la ligne 6. On affichera seulement la valeur du
dernier S calculé qui va donner la somme des éléments. Le résultat donne 2550.

L’exemple suivant concerne la construction d’une matrice carrée dont


chaque élément 𝑎𝑖𝑗 est le produit 𝑖 × 𝑗 . Dans ce cas, nous avons besoin de
parcourir les lignes et les colonnes de la matrice. Pour se faire, nous devons
faire des boucles imbriquées. La première boucle parcourt les lignes de la
matrice et la deuxième boucle parcourt les colonnes. Ainsi, pour chaque valeur
i, on effectue une boucle pour j. Le programme est le suivant :

La matrice générée est donnée dans la figure suivante :


4.4. Commande break :
Lors d’une boucle while ou for, il est possible d’arrêter les itérations
lorsqu’une condition est satisfaite. Pour se faire, on ajoute le mot break à
l’emplacement où on veut que la boucle s’arrête. Par exemple, supposons qu’on
veut créer un programme permettant de vérifier si tous les éléments d’un
vecteur sont positifs. Dans ce cas, si on trouve un seul élément qui est négatif,
on n’est pas obligés de terminer la boucle. On peut s’arrêter dès qu’on trouve
le premier élément négatif. Voici le programme permettant d’effectuer cette
manipulation :

Le logiciel trouve que le 8e élément du vecteur v est négatif et il s’arrête


comme le montre la figure suivante :
5. LES FONCTIONS :
Les fonctions sont des outils indispensables en programmation. Elles nous
permettent de concevoir nos propres commandes personnalisées sur Octave.
Chaque fonction doit être enregistrée seule dans un fichier « .m » situé dans un
dossier accessible par le navigateur du logiciel. Le nom du fichier doit être
identique au nom donné à la fonction. On peut ainsi invoquer la fonction dans
un script ou même dans une autre fonction enregistrée dans le même dossier
(répertoire). On peut aussi l’invoquer à partir de la fenêtre des commandes
directement sans passer par l’éditeur. Cette manipulation n’est pas possible
pour des scripts.

Il est souvent utile de créer un dossier contenant toutes les fonctions


créées afin de pouvoir les chercher et les appeler plus facilement sans modifier
le répertoire source du logiciel à chaque exécution.

En général une fonction possède des variables d’entrées et des variables


de sortie. Les variables d’entrée sont les arguments qu’on fournit à la
fonction lors de l’appel pour qu’elle puisse s’exécuter. Les variables de sorties
sont les variables retournées après exécution de la fonction. De plus, il est
possible d’utiliser d’autres variables intermédiaires à l’intérieur des
instructions de la fonction.

Nous allons énumérer toutes les étapes permettant la création d’une


fonction. Certaines étapes sont indispensables et d’autres sont seulement
optionnelles :

1) Déclaration et variables d’entrée-sortie :


La première étape consiste à donner un nom à la fonction et de
déterminer les variables d’entrée et de sortie. Pour se faire, on écrit :
function[vars_sortie]=nom_de_fonction(vars_entree)
Les variables d’entrées et de sorties sont séparées par des virgules. Le
nom de la fonction doit être au même nom du fichier « .m » de la fonction.
Généralement, on choisit le nom dépendamment de son utilité ou de la
méthode qu’elle représente. Si la fonction ne prend pas de variables
d’entrée, on écrit :
function[vars_sortie]=nom_de_fonction()
Si la fonction n’admet pas de variables de sortie, on écrit:
function[]=nom_de_fonction(vars_entree)
Notons que si la fonction ne possède qu’une seule variable d’entrée, les
crochets ne sont pas obligatoires.

2) Commentaires d’aide :
Cette étape n’est pas obligatoire. Cependant, si une autre personne veut
utiliser la fonction, il devrait avoir des explications sur l’utilisation des
commentaires. Ainsi, après la ligne des déclarations, chaque ligne de
commentaires débute avec un « % ». La première ligne contient le nom
de la fonction suivit de mots clés qui vont permettre de retrouver la
fonction en effectuant une recherche dans l’onglet d’aide ou avec la
commande lookfor mot_clé. On peut ensuite ajouter des lignes de
commentaire pour expliquer le fonctionnement de la fonction. On aura
accès à ces commentaires avec la commande help nom_de_fonction.

3) Déclaration des variables globales ou statiques :


Cette étape n’est obligatoire que si on a besoin de déclarer des variables
intermédiaires comme globales ou statiques. Par défaut, une variable
intermédiaire est déclarée locale. C’est-à-dire qu’elle n’est affectée
qu’à l’intérieur de la fonction. Une fois la fonction exécutée, ces variables
se libèrent automatiquement. On ne peut pas accéder à leur contenu en
dehors de la fonction. Si l’on veut que des variables intermédiaires soient
accessibles en dehors de la fonction, il faut les déclarer comme variables
globales en utilisant la syntaxe global nom_variable. De plus, il va
falloir les déclarer aussi avant l’application de la fonction dans l’autre
fichier. D’autre part, dans le cas où on a besoin d’exécuter une fonction
plusieurs fois et qu’on ne veut pas qu’une variable intermédiaire soit
réinitialisée à chaque exécution, on la déclare comme variable statique.
Dans ce cas, à chaque nouvelle exécution de la fonction, la variable
statique gardera sa dernière valeur attribuée à l’exécution précédente.
La syntaxe permettant de déclarer une variable comme statique est
donnée par : persistent nom_variable. La déclaration des variables
globales et statiques vient juste après la section de commentaire avant
d’écrire le corps du code de la fonction.

4) Corps de la fonction :
Le corps de la fonction est le code permettant de manipuler les variables
d’entrée pour générer les variables de sortie. Le contenu de cette section
dépend des besoins de l’utilisateur. En général c’est à cette étape qu’on
initialise les variables intermédiaires au besoin. Ensuite, on utilise
différentes manipulations nécessaires pour générer les valeurs des
variables de sorties.

5) Fin de la fonction :
Pour fermer la fonction, on utilise généralement return pour retourner
les variables de sortie et on ferme la fonction à l’aide de endfunction
(ou simplement end si on travaille sur Matlab). Cette dernière n’est pas
obligatoire si le fichier « .m » ne contient qu’une seule fonction. Dans ce
cas on va omettre de l’écrire pour que le fichier soit compatible avec
Matlab et Octave.

Le premier exemple est une fonction qui permet de calculer la somme des
entiers entre deux nombres a et b inclusivement. La fonction, nommée somme,
prend comme arguments les entiers a et b et retourne la somme S. La fonction
s’écrit de la manière suivante :

Une fois la fonction est enregistrée dans le fichier « somme.m », il est


possible de l’appeler dans un script ou une autre fonction, enregistrés dans un
fichier « .m ». Nous avons appliqué la fonction pour 4 exemples différents
comme suit :

Après exécution, on obtient les réponses suivantes :

On remarque que pour la variable S4, on a obtenu une erreur puisque l’un
des deux nombres n’est pas entier. Le deuxième exemple montre comment
définir une fonction mathématique en utilisant une fonction .m. Si la fonction
à définir est à une variable, elle prendra une valeur d’entrée comme argument
est une valeur de sortie comme l’image de la valeur d’entrée. Si la fonction est
à plusieurs variables, elle prendra autant d’arguments que de variables et une
seule valeur de sortie. Pour définir la fonction 𝑓(𝑥) = √2𝑥 + 3, nous utilisons la
syntaxe suivante que nous enregistrons dans le fichier « f.m » :

Une fois enregistrée, on peut utiliser la fonction à notre guise. D’autre part,
la fonction à deux variables 𝑓(𝑥, 𝑦) = ln(𝑥 2 + 𝑦 2 + 3𝑥𝑦 − 𝑥 − 𝑦 + 3) est définie
de la manière suivante :

Notons qu’il faut faire attention aux noms des différentes fonctions
élaborées. Les noms doivent être distincts.
6. EXEMPLES DU COURS :
Dans cette section, nous allons montrer les étapes pour écrire deux
algorithmes du cours de méthodes d’analyse de l’ingénieur. Le premier
exemple est l’algorithme du point fixe à une dimension qui est une méthode
itérative. Le deuxième exemple est la factorisation de Cholesky qui permet de
décomposer une matrice symétrique définie positive en produit d’une matrice
et de sa transposée. Le but de cette section est de montrer comment traduire
les algorithmes du cours en langage Octave sous forme de fonction.

6.1. Méthode du point fixe :


La méthode du point fixe est l’une des principales méthodes utilisées pour
résoudre des équations algébriques. L’idée de la méthode est de reformuler un
problème de la forme 𝑓(𝑥) = 0 en un problème de la forme 𝑔(𝑥) = 𝑥. Une fois
la fonction 𝑔(𝑥) est établie, nous l’utilisons pour effectuer les itérations 𝑥𝑛+1 =
𝑔(𝑥𝑛 ). Sous certaines conditions, ces itérations convergeront vers un point fixe
de la fonction 𝑔(𝑥) qui est par la même occasion un zéro de la fonction 𝑓(𝑥).
Nous allons montrer comment construire et utiliser la méthode des points fixes
sur Octave :

La première étape consiste à construire la fonction 𝑔(𝑥), dont on cherche le


point fixe, dans un fichier « g.m ». Ensuite, on construit une autre fonction
nommée « pointfixe.m » qui contient l’algorithme du point fixe du cours
traduit en langage Octave. La fonction prend comme arguments le point initial
𝑥0 , le critère d’arrêt 𝜖𝑎 et le nombre maximal d’itérations 𝑁. La variable de
sortie sera un vecteur 𝑋 contenant les 𝑥𝑛 de chaque itération. Notons que
l’erreur machine sera déclarée comme variable locale et non pas comme
argument puisqu’elle est constante et qu’on n’a pas besoin de la modifier. De
plus, la fonction va afficher le point fixe retrouvé ainsi que le nombre
d’itérations nécessaires pour l’obtenir. L’algorithme est donné dans la capture
suivante avec les commentaires expliquant le choix de chaque ligne :

Notons que la fonction pointfixe tient compte de la fonction


mathématique 𝑔(𝑥) (ligne 7) qui sera enregistrée dans le fichier du même nom
(g.m) et dans le même répertoire que la fonction pointfixe. Comme exemple,
nous prenons l’équation 𝑥 2 − 2𝑥 − 3 = 0. Cette équation peut être reformulée
de la forme 𝑥 = √2𝑥 + 3. Ainsi, on commence par définir la fonction 𝑔(𝑥) =
√2𝑥 + 3 comme suit :

Ensuite, on appelle la fonction pointfixe dans un fichier à part en posant


un point initial 𝑥0 = 4, un critère d’arrêt 𝜖𝑎 = 10−11 et un nombre maximal
d’itérations 𝑁 = 100. Le vecteur de sortie sera enregistré dans une variable 𝑀
comme le montre la figure ci-dessous :
Il est à noter qu’on a précisé le format long pour afficher un grand nombre
de chiffres significatifs. Ceci nous permet de visualiser la progression de la
précision dans les itérations. Dans la fenêtre de commande, on voit apparaître
le contenu de la figure suivante :

Pour cet exemple, la convergence est atteinte en 23 itérations pour une


erreur relative maximale de 10−11 . Le point fixe obtenu est alors 𝑟 = 3. Le
vecteur 𝑀 visualise comment les itérations convergent vers le point fixe
obtenu. Il serait possible d’obtenir le taux de convergence de manière
expérimentale en utilisant ce même vecteur.
6.2. Factorisation de Cholesky :
Cette méthode nous permet de décomposer une matrice 𝐴 symétrique
définie positive en un produit de deux matrices 𝐴 = 𝐿. 𝐿𝑇 où 𝐿 est une matrice
triangulaire inférieure. Cette méthode est dite directe (non itérative). Le
nombre d’opérations à effectuer dépend seulement de la dimension de la
matrice 𝐴. Le but est de construire une fonction « cholesky.m » qui permet
d’effectuer la factorisation de Cholesky. La fonction vérifie d’abord si la matrice
est symétrique définie positive. Ensuite, elle calcule les éléments de la matrice
𝐿 en suivant l’algorithme vu en cours. La fonction doit prendre comme
argument une matrice A quelconque et retourner la matrice 𝐿 comme variable
de sortie. La fonction programmée est donnée dans la figure suivante avec les
commentaires pour chaque étape :

Notons qu’il n’était pas nécessaire d’utiliser un indice 𝑗 dans les sommations
du fait que nous avons utilisé des indices en forme de séries avec la commande
sum. Appliquons la fonction à la matrice 𝐴 donnée par :
11 −2 1 3 2
−2 12 −2 1 −1
𝐴= 1 −2 10 2 2
3 1 2 9 0
[2 −1 2 0 8 ]

Cette matrice est symétrique et définie positive. Nous appliquons, la


fonction sur la matrice 𝐴 pour obtenir la matrice 𝐿 qu’on affecte à la variable
𝑀 . Puis, on multiplie la matrice 𝑀 par sa transposée pour vérifier si on
retrouve la matrice 𝐴.

La figure suivante montre les deux résultats obtenus :

À première vue, la matrice obtenue on multipliant 𝑀 par sa transposée


n’est pas égale à 𝐴 . Cependant, en faisant attention aux exposants, on
comprend que les termes de la diagonale sont à exposant 1, et que les termes
supposés nuls de 𝐴 sont à exposant -17. Ce qui nous laisse dire que ce sont des
valeurs très proches de zéro. Ceci est dû principalement aux erreurs d’arrondi
lors du calcul de la racine carrée dans la factorisation de Cholesky. On peut
remédier à ce problème en exécutant la commande round(M*transpose(M)).
RÉFÉRENCES :
1. https://www.mathworks.com/help/matlab
2. https://nte.mines-albi.fr/MATLAB
3. https://octave.sourceforge.io/
4. A. Fortin (2016) : « Analyse numérique pour ingénieurs », 5e édition, Presses
internationales Polytechnique.
5. O’Donovan B. (2004), « GNU Octave : une introduction ». Gazette Linux 109.
6. O’Donovan B. (2005), « GNU Octave : fonctions et scripts. Gazette Linux
112.

Vous aimerez peut-être aussi