Matlab4n00bz:
Ou comment faire de Matlab votre meilleur ami.
Version 1.0
Vincent Schellekens et Florimond Houssiau
August 2014
Table des matières
1 Avant de commencer, un peu d’informatique. . .
1.1 Matlab , c’est quoi ? . . . . . . . . . . . . . . . .
1.2 Comment écrire du code en Matlab . . . . . . .
1.2.1 Fichiers : scripts et fonctions . . . . . . .
1.2.2 Commande interactive . . . . . . . . . . .
1.3 Concept clé : la vectorisation . . . . . . . . . . .
1.4 Alternatives gratuites à Matlab . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
4
4
5
5
2 Concepts de base : variables, fonctions, syntaxe, . . .
2.1 Le code, c’est quoi ? . . . . . . . . . . . . . . . . . . . .
2.2 Variables et opérations . . . . . . . . . . . . . . . . . . .
2.2.1 Les variables . . . . . . . . . . . . . . . . . . . .
2.2.2 Opérateurs . . . . . . . . . . . . . . . . . . . . .
2.3 Boucles et instructions conditionnelles . . . . . . . . . .
2.3.1 Les conditions . . . . . . . . . . . . . . . . . . .
2.3.2 Les instructions conditionnelles : if et else . . . .
2.3.3 La boucle while . . . . . . . . . . . . . . . . . . .
2.3.4 La boucle for . . . . . . . . . . . . . . . . . . . .
2.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . .
2.4.1 Syntaxe des fonctions . . . . . . . . . . . . . . .
2.4.2 Plusieurs valeurs de sortie, plusieurs arguments .
2.4.3 Fonctions utiles de Matlab . . . . . . . . . . . .
2.5 Débugger votre code Matlab . . . . . . . . . . . . . . .
2.5.1 Le point-virgule . . . . . . . . . . . . . . . . . . .
2.5.2 Quelques fonctions pour afficher vos résultats . .
2.5.3 Mesurer le temps d’exécution du code . . . . . .
2.5.4 Programmer défensivement . . . . . . . . . . . .
2.6 Un petit commentaire sur l’utilisation de commentaires
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
7
7
8
9
9
10
10
11
11
12
12
14
14
15
15
15
15
16
3 Opérations sur les vecteurs
3.1 Créer ses propres vecteurs . . . . . . . .
3.1.1 Syntaxe propre aux vecteurs . .
3.1.2 Fonctions de création de vecteurs
3.1.3 Adjonction de vecteurs . . . . . .
3.2 Manipuler des vecteurs . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
17
18
18
18
19
19
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
20
21
22
22
22
24
24
. . . . . .
. . . . . .
. . . . . .
de niveau.
. . . . . .
. . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
25
25
27
28
28
28
28
5 Les superpouvoirs de Matlab : ode45, le calcul symbolique, . . .
5.1 Résoudre des équations différentielles ordinaires plus vite que son ombre
5.1.1 Que fait vraiment ode45 ? . . . . . . . . . . . . . . . . . . . . . .
5.1.2 Quels arguments donner à ode45 ? . . . . . . . . . . . . . . . . .
5.1.3 Comment utiliser les valeurs de retour ? . . . . . . . . . . . . . .
5.1.4 Un exemple : le pendule amorti . . . . . . . . . . . . . . . . . . .
5.2 Calculer symboliquement mieux que vous . . . . . . . . . . . . . . . . .
5.3 S’amuser avec Matlab . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Les petites blagues de Matlab . . . . . . . . . . . . . . . . . . .
5.3.2 Oubliez Steam : jouer avec Matlab . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
29
29
29
30
30
31
32
33
33
33
3.3
3.2.1 Accès aux éléments . . . . . . . .
3.2.2 Opérations sur un vecteur . . . .
3.2.3 Opérations entre vecteurs . . . .
3.2.4 Opérations élément par élément .
Les vecteurs Like A Boss . . . . . . . . .
3.3.1 La vectorisation . . . . . . . . .
3.3.2 La préallocation . . . . . . . . .
3.3.3 Les matrices creuses . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4 Dessiner des graphes
4.1 Créer le graphe de base (titre, axes...) . . .
4.2 Plein d’options pour faire joli . . . . . . . .
4.3 Exporter votre chef-d’oeuvre . . . . . . . .
4.4 A trois variables : les surfaces et les courbes
4.4.1 Les courbes de niveau : contourf . .
4.4.2 Les courbes 3-D : surf et plot3 . . . .
.
.
.
.
.
.
.
.
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Introduction
Ce document est destiné aux étudiants de deuxième année en ingénieur civil et ingénieur civil architecte
suivant le cours de Méthodes Numériques. Son objectif est de présenter et d’expliquer les principaux concepts
et fonctionnalités du logiciel Matlab , d’abord pour le cours, mais aussi pour le projet 3 et plus généralement,
pour l’apprentissage personnel.
Ce document n’est pas un guide exhaustif à Matlab. Il contient essentiellement ce que nous avons jugé
important de savoir pour réussir le cours, et en particulier réussir les devoirs hebdomadaires. Le premier
chapitre décrit le logiciel Matlab de manière plus pratique, et est présent à titre strictement indicatif. Le
chapitre 2 introduit la syntaxe du langage Matlab, et est indispensable à quiconque n’a jamais écrit de code
auparavant. Le chapitre 3 se concentre sur l’emploi omniprésent des vecteurs dans Matlab, et est certainement
le plus important du document. Le chapitre 4 explique comment afficher les données en traçant de beaux
graphes. Enfin, le chapitre 5 expose les fonctionnalités les plus puissantes de Matlab, pour ceux qui voudraient
aller plus loin, et faire des choses vraiment utiles avec le logiciel. . .
Ceci n’est pas un syllabus officiel, et il n’est pas obligé de tout lire ! Au contraire, si vous n’avez pas le
temps de tout lire, concentrez vous sur les chapitres 2 et 3, qui contiennent les éléments les plus importants
sur les bonnes pratiques en Matlab.
Si vous avez des remarques concernant le document, si vous y repérez une erreur (il y en a certainement), n’hésitez surtout pas à nous contacter par mail (vincent.schellekens@student.uclouvain.be ou
florimond.houssiau@student.uclouvain.be), ou en personne. Le document est actuellement hébergé sur
ShareLatex, mais devrait être migré sous GitHub bientot, ce qui rendra la distribution et la correction plus
aisées.
Bonne lecture !
1
Avant de commencer, un peu d’informatique. . .
Parce que oui, Matlab , avant tout, c’est de l’informatique. N’ayez pas peur, cette section ne se penche
pas sur toutes ces choses scabreuses que sont les pointeurs, la récursion terminale et le polymorphisme, mais
plutôt sur les quelques petites choses qu’il est bon de savoir sur votre (futur) logiciel favori. Cette partie ne
fait pas partie de la matière d’examination.
Attention, certaines sections de ce chapitre pré-supposent des notions d’informatique : si vous ne comprenez pas de quoi il s’agit, ne vous inquiétez pas, tout sera expliqué en temps utile dans la suite du document.
1.1
Matlab , c’est quoi ?
Matlab , c’est deux choses :
1. un langage de programmation développé par la firme MathWorks
2. un logiciel, développé par cette même firme, qui exécute les fichiers de code Matlab
Le langage Matlab est interprété, c’est à dire que le code n’est jamais transformé en langage machine,
mais plutot lu par un logiciel (dans ce cas, le logiciel Matlab 1 ). Cela rend l’exécution d’un code Matlab
relativement lente, par rapport par exemple à celle d’un langage compilé, comme le C, et dans une certaine
mesure le Java.
Pour pallier cet inconvénient, Matlab est doté d’un nombre important de fonctions toute faites, fournies
pré-compilées (en langage machine) avec le logiciel : ces fonctions, qui s’occupent notament de la gestion des
vecteurs, offrent donc pratiquement les mêmes performances que si on avait écrit le code en C, par exemple.
Par conséquent, pour rendre un code Matlab efficace, il faut employer au maximum ces fonctions (ou en tout
cas, éviter au maximum d’implémenter les opérations vectorielles à la main, on en reparlera), ce qui est une
bonne et une mauvaise nouvelle. Bonne nouvelle : les codes Matlab sont relativement courts. Mauvaise
1. ça porte à confusion, certes, mais Matlab est interprété par Matlab . . .
3
nouvelle : il faut connaitre ces fonctions. . . (Rassurez vous, il n’y en a pas tant que ça à connaitre pour s’en
sortir correctement).
La documentation du langage Matlab se trouve sur le site /www.mathworks.nl/help/matlab/index.
html. Autrement, comme dirait Monsieur Legat, Google est votre ami.
1.2
Comment écrire du code en Matlab
Matlab supporte deux manières d’écrire du code : les fichiers et la commande interactive.
1.2.1
Fichiers : scripts et fonctions
Le logiciel Matlab contient un éditeur de texte assez puissant, qui repère certaines erreurs et comportements à éviter, offre une complétion de texte assez efficace, et colorise le texte en accord avec la syntaxe. Les
fichiers de code Matlab ont pour extension .m. Il existe deux types de fichier : les scripts et les fonctions.
Les scripts contiennent du code exécutable : en lançant un script (en appuyant sur la flèche verte, par
exemple), le code s’exécute tel quel. Il est interdit de définir des fonctions à l’intérieur d’un script, ainsi que
de spécifier des arguments 2 ce rend les scripts très limités. Ils sont utiles pour des codes assez courts destinés
par exemple à tester une fonction.
Les fichiers de fonction ne contiennent que des définitions de fonctions (voir chapitre 2.4 sur les fonctions) :
il est interdit d’écrire du code qui ne soit pas compris entre function ... et le end respectif. Chaque fichier peut
contenir la définition de plusieurs fonctions, mais seule celle portant le même nom que le fichier ne sera
utilisable de l’extérieur. La plus grande majorité des projets en Matlab utilisent exclusivement des fichiers
de fonction, de par leur grande flexibilité.
1.2.2
Commande interactive
Un des atouts de Matlab , qui le distingue particulièrement de Java, est la possibilité d’entrer du code de
manière interactive dans une commande (qui est normalement la première chose qu’on voit lorsque Matlab
se lance). Cette commande permet notamment de :
— tester une de vos fonctions avec plein d’arguments différents (pour voir si ça marche)
— réaliser des petits calculs pour lesquels il est inutile de faire un fichier (par exemple, résoudre un
système linéaire)
— naviguer dans les dossiers via les opérateurs ls et cd (utile dans certains cas)
— consulter la documentation : en tapant help nom_de_la_fonction, la documentation liée est affichée
— tester les fonctions de la doc pour essayer de comprendre ce qu’elles font (parce que lire la doc, ça
prend du temps)
La commande garde en mémoire toutes les variables définies lors de son utilisation ou de l’emploi d’un script
(les variables définies dans une fonction, par contre, disparaissent à la fin de l’exécution de celle-ci).
A titre d’exemple, voici comment calculer facilement la moyenne et la moyenne des carrés des sinus de
tous les entiers entre 1 et 1000 compris (une tache courante de la vie de tous les jours) :
1
2
3
4
5
6
EDU > > x = 1:1000; % on prend tous les entiers de 1 a 1000
EDU > > y = sin ( x ) ;
EDU > > disp ( mean ( y ) ) ; % disp = display = afficher
8.1397 e -004
EDU > > disp ( mean ( y .^2) ) ;
0.5002
2. Concrètement, le script s’exécute dans l’environnement actuel de la commande interactive : il est dont possible de référencer
une variable, qu’on espère définie dans l’environnement. C’est toutefois une mauvaise pratique : il vaut mieux faire appel aux
fonctions !
4
1.3
Concept clé : la vectorisation
Le concept le plus important du langage Matlab est la vectorisation : l’emploi extensif de vecteurs. Toutes
les opérations sur les vecteurs sont gérées par le langage de manière très efficace. Il faut donc à tout prix
éviter de coder par soi-même ces opérations. A titre d’exemple, implémentons le produit scalaire entre deux
vecteurs, nommés x (vecteur ligne) et y (vecteur colonne). Ce code s’implémente naivement comme suit :
1
2
3
4
res = 0;
for i = 1: length ( x )
res = res + x ( i ) * y ( i ) ;
end
En employant les fonctionnalités natives de Matlab, cela devient simplement :
1
res = x * y ;
En mesurant les performances des deux codes écrits ci-dessus, on constate rapidement que le deuxième code
est, pour des vecteurs de grande taille, au moins 10 fois plus rapide 3 !
En outre, la majorité des fonctions mathématiques de base de Matlab (comme, par exemple, sin, cos, exp,
. . .) admettent comme argument des vecteurs. Ainsi, pour calculer le sinus de chaque élément d’un vecteur
x, et stocker le résultat dans un vecteur y, on utilisera simplement :
1
y = sin ( x ) ;
Ce qui combine les avantages d’être à la fois plus rapide et beaucoup plus lisible !
Nous aborderons encore l’importance de la vectorisation dans un chapitre futur. En attendant, retenez
surtout ceci : Tant que possible, il faut éviter la boucle for !
1.4
Alternatives gratuites à Matlab
Le logiciel Matlab est un logiciel propriétaire, ce qui signifie, hélas, qu’il est payant 4 . Toutefois, des
alternatives open-source (donc ouvertes, sures et gratuites) existent. Evidemment, ce n’est jamais aussi bien
que l’original, et souvent pas tout à fait compatible (de nombreuses fonctions n’existent que chez Matlab )
mais elles ont tout de même leurs mérites.
La plus connue de toutes, et la plus proche du logiciel développé par MathWorks, est Octave (http:
//www.gnu.org/software/octave/). La plus grande majorité des fonctionnalités du langage Matlab sont
présentes (il est tout à fait possible de suivre le cours de Méthodes Numériques avec Octave, à condition
de s’assurer de la compatibilité sur les machines des salles info, juste pour être sur !), de manière généralement assez performante. Par contre, Octave est très loin du logiciel Matlab : il ne s’agit que d’une
commande interactive ! Il faut donc utiliser un autre éditeur de texte (comme par exemple Vim 5 , Nano 6 , ou
Notepad++ 7 ).
Une autre possibilité est d’utiliser Freemat (http://freemat.sourceforge.net/), qui se veut un clone
(assez moche) de Matlab, beaucoup moins puissant, mais doté de l’ensemble des fonctionnalités de base du
langage et du logiciel. L’éditeur de texte est assez basique (pas de complétion, par exemple), mais tout
fonctionne bien. Il présente toutefois un très grand avantage par rapport à notre logiciel favori : Freemat est
très léger, et se lance donc très vite. Ce qui vous permet d’éviter de devoir lancer Matlab pour un bête
système matriciel (surtout sur des machines un peu vieilles, sur lesquelles Matlab prend des plombes à se
lancer, et pompe pas mal de mémoire). Malheureusement, il manque à Freemat des fonctions nécessaires
3. Pour un vecteur de 1000000 éléments (ce qui n’est pas si rare que ça !), le code vectoriel est près de 100 fois plus rapide !
4. Enfin, en théorie... On sait tous que ce n’est pas forcément le cas. . . Blague à part, nous vous recommandons fortement
d’avoir une version légale de Matlab quand vous aurez des travaux importants à rendre (mémoire...). Puis bon, l’amende vaut
100 fois la license étudiante, de quoi réfléchir.
5. Editeur à la ligne de commande particulièrement puissant, mais très dur à utiliser au début : http://www.vim.org
6. Autre éditeur à la commande, plus simple à utiliser que Vim : http://www.nano-editor.org/
7. IDE (presque) universel, beaucoup plus simple que les deux autres :http://notepad-plus-plus.org/
5
pour le cours de Méthodes Numériques (notamment contourf), et sa syntaxe n’est pas tout à fait compatible
avec notre bon vieux Matlab . . .
Il existe plein d’autres programmes (Scilab, Sage, . . .), plus ou moins proches de Matlab , plus ou moins
bons (et pour être honnête, on n’a pas tout testé ;-), donc à vous de voir. . . Reste que Matlab n’est pas
trop trop cher (pour rire, allez comparer avec Mathematica, ou SolidWorks), mais pour des ordis pas super
puissants (par exemple, si vous avez un petit ordi d’appoint), les deux programmes ci-dessus devraient suffire
pour le cours.
2
Concepts de base : variables, fonctions, syntaxe, . . .
Cette section s’adresse à tout ceux qui ne savent pas trop ce que c’est, le code informatique (par exemple,
les ARCH), ou qui ont un peu oublié (INFO 1, c’était il y a au moins 8 mois !), et va vous apprendre tout
ce qu’il faut savoir pour écrire et comprendre du code Matlab.
2.1
Le code, c’est quoi ?
Cette sous-section s’adresse aux étudiants qui n’ont jamais programmé de leur vie et qui ne savent pas
trop ce que c’est, écrire du code, à part taper très vite sur un clavier et écrire plein de choses bizarres à
l’écran qui sont incompréhensibles pour le commun des mortels.
Certains d’entre vous ont peut-être une haute estime de leur ordinateur. Après tout, celui-ci peut effectuer
de nombreuses tâches que nous serions bien incapables d’effectuer, et peut par exemple en même temps
télécharger les épisodes de votre série favorite, ainsi que jouer de la musique, afficher ce document et vous
faire part des avis de vos amis sur votre photo de profil. Et tout cela, en même temps ! Ce qui laisse à supposer
que votre ordinateur est un être absolument génial. Hé bien, ce n’est pas le cas. Au contraire même, votre
ordinateur n’est qu’un ensemble de circuits électroniques dénués de la moindre capacité d’interprétation ou
once d’intelligence. Un ordinateur est en fait une simple machine qui fait exactement ce qu’on lui dit :
rien de plus, rien de moins. Mais dans quel langage parle l’ordinateur ?
La réponse est simple, et pas très utile : en binaire (représenté par des courants électriques et des charges
de condensateurs). Heureusement, l’époque oú l’on écrivait les programmes en binaire est révolue, et on
peut désormais employer des langages de programmation, qui sont compréhensibles par les humains, et
peuvent être traduits de manière non-ambigües en langage machine (le binaire). Matlab est un langage de
programmation (c’est aussi le nom du programme qui traduit le langage Matlab en langage machine).
Le principe d’un ordinateur est très simple : un être doté d’une intelligence supérieur (le programmeur,
c’est-à-dire, vous) va donner toute une série d’instruction (le code, écrit en un certain language, ici Matlab ) à
l’ordinateur pour qu’il effectue une certaine tâche. Comme, nous l’avons dit, l’ordinateur est stupide, il faudra
être extrêmement précis durant l’écriture de la susnommée séquence d’instructions, de sorte à ce qu’aucune
ambiguïté ne soit possible pour le pauvre ordinateur qui ne possède aucune capacité d’interprétation. Tour
l’art d’écrire du code constiste donc à expliquer à l’ordinateur ce qui est attendu de lui, de manière à ce qu’il
puisse ensuite (durant l’éxécution) effectuer la tâche souhaitée avec brio. Les trois premières sections de ce
chapitre introduisent les concepts nécessaires à l’écriture d’un code Matlab qui fonctionne.
Par contre, si vous n’êtes pas assez clair ou que vous faites quelque chose que vous n’avez pas le droit de
faire, Matlab vous insultera gentiment avec des messages (en rouge pour faire peur) du genre :
Figure 1 – Un gentil message d’erreur de Matlab .
A votre avis, d’ou vient l’erreur 8 ?
8. Comme vous le signale plus ou moins explicitement Matlab , les vecteurs ne sont pas compatibles pour le produit matriciel :
6
La mauvaise nouvelle, c’est que quand Matlab vous insulte, c’est une bonne nouvelle. Les erreurs les plus
dures à corriger sont celles qui n’entrainent pas de messages d’erreur. . . C’est l’objet de la dernière section de
ce chapitre, qui vous expliquera comment faire pour que votre code fonctionne (enfin) comme vous le voulez !
2.2
2.2.1
Variables et opérations
Les variables
Le concept le plus important de toute la programmation (non non, nous n’exagérons pas) est sans aucun
doute celui de variable. Une variable est l’équivalent (grosso modo) d’une adresse dans la mémoire de
l’ordinateur, à laquelle se trouve une donnée : il s’agit d’un lien vers une donnée. Une variable porte un nom,
appelé identifiant (par exemple x), et une valeur (par exemple 42). Pour créer une variable, on utilise le
symbole = :
1
x = 42 % creation d ’ une variable x initialisee a 42
Contrairement à Java, il n’est pas nécessaire (ni même permis) de déclarer des variables. Ce qui signifie que
les variables sont crées à l’initialisation, c’est à dire quand on leur assigne une valeur pour la première fois.
Il est tout-à-fait possible de modifier la valeur d’une variable : cela se fait également avec le symbole =.
Pour accéder à une variable définie, il suffit d’utiliser l’identifiant. En fait, on peut toujours substituer
l’identifiant à sa valeur. Par exemple, pour assigner à y le double de x, on écrira :
1
y = 2 * x
Attention, la variable y dans le code ci-dessous n’est pas liée à x : si on change la valeur de x après, la
valeur de y reste inchangée. C’est la valeur de la variable x au moment de l’instruction qui est utilisée.
Ceci est vrai partout : si on change la valeur d’une variable, cela n’a aucun effet sur les autres variables.
Ceci permet de faire quelque chose d’extrêmement intéressant : modifier une variable en fonction d’ellemême ! Par exemple, pour incrémenter (augmenter d’une unité la valeur) d’une variable x, on utilisera le
code :
1
x = x + 1; % ligne de code ultra - courante
Types de données Les variables peuvent contenir des données de différents types. En Matlab , les types
les plus courants sont :
1. Les nombres : soit entiers (1, 2, -1, . . . ), soit à virgule (1.2, 3.14159, -1e-4, . . . )
2. les matrices : appelées vecteurs, il s’agit juste de tableaux de nombres
Les booléens de Java n’existent pas : on utilise ici des nombres (0 = false, 1 = true). Idem pour les chaines
de caractères, qui sont des tableaux de nombres (mais cela ne rentre pas dans le cadre de ce document).
La syntaxe pour créer des nombres est très simple, puisque très proche de la notation habituelle. Le signe
moins se note par un tiret -, et la virgule séparant partie entière des décimales par un point . (notation
américaine).
La notation scientifique s’utilise comme ceci : <chiffre>.<décimales>e<exposant>. Ainsi, pour écrire
4.2 · 10−9 , on utilisera 4.2e-9. √
Le nombre imaginaire i = −1 se note simplement i ou j, mais Matlab préfère une notation un peu
différente : 1i, afin d’éviter une confusion possible avec une variable i déjà existante (i est un nom courant
pour une variable, en particulier dans les itérations).
Matlab supporte deux valeurs particulières pour les nombres : Inf (l’infini, éventuellement négatif si on
met un tiret devant) et NaN (Not a Number, résultat de la division de l’infini par l’infini, le plus souvent).
il s’agit de deux vecteurs lignes ! Cette erreur est sans aucun doute la plus courante (si vous la rencontrez, transposez (’)
intelligemment vos vecteurs, ça marche toujours bien).
7
La constante π est également définie par Matlab , sous le symbole pi. La constante e ne bénéficie par du
même privilège, mais peut être obtenue avec exp(1) (la valeur de l’exponentielle en 1).
Nous aborderons la syntaxe propre aux vecteurs dans le prochain chapitre.
Les commentaires : Vous l’avez sans doute remarqué, les codes de ce document contiennent souvent
un % suivi de texte en vert. C’est ce qu’on appelle un commentaire, autrement dit du texte qui sera
totalement ignoré par Matlab lors de l’exécution du code. Les commentaires permettent d’expliquer ce
que vous faites, et de faciliter la compréhension du code. Il est impératif de mettre des commentaires
lorsque vous remettez du code pour un cours, ou un projet. . . Nous y reviendrons dans la section 2.6.
2.2.2
Opérateurs
Nous savons à présent comment créer et stocker de l’information, sous forme de variables. Voyons à
présent comment manipuler cette information.
Comme en maths, il existe ce qu’on appelle des opérateurs, comme l’addition ou la multiplication. Le
tableau 1 présente les opérateurs les plus courantes :
Symbole
+
*
/
ˆ
Effet
Addition
Soustraction
Multiplication
Division
Exposant
Exemple
42 + 42 = 84
42 - 42 = 0
42 * 42 = 1764
42 / 42 = 1
42 ˆ 42 = 1.5013e+68
Table 1 – Opérateurs principaux de Matlab
Avec ces opérateurs, il est déjà possible de se servir de Matlab comme d’une très puissante calculatrice
de bureau :
1
2
3
4
5
6
7
8
9
10
11
EDU > > 123456789 ^ 9
ans =
6.6625 e +72
EDU > > 72 /0.000212121
ans =
3.3943 e +05
EDU > > (1+2 i ) ^ 10
ans =
2.3700 e +02 - 3.1160 e +03 i
A quoi sert le point-virgule ? En Matlab, le point-virgule détient deux roles. Premièrement, il
permet de séparer les instructions, et est en cela équivalent à un retour à la ligne (il est possible d’écrire
plusieurs instructions en une ligne en Matlab, mais ça rend en général le code illisible). Deuxièmement, il
permet de réguler l’affichage des variables. Lorsqu’on assigne une valeur à une variable (éventuellement
nouvelle), en omettant le point-vigule (x = 42), Matlab affiche la valeur assignée. L’usage d’un pointvirgule permet de supprimer cet affichage. La plupart du temps, il faut impérativement utiliser le pointvirgule (en particulier quand vous manipulez des grosses matrices. . . ) !
8
2.3
Boucles et instructions conditionnelles
Le véritable intérêt d’un ordinateur par rapport à un humain, outre sa vitesse de calcul des opérations,
est sa capacité à exécuter la même opération un nombre important de fois. Cela se fait grace aux boucles et
aux instructions conditionnelles.
2.3.1
Les conditions
Les instructions conditionnelles et les boucles reposent le plus souvent sur l’évaluation d’une condition.
Une condition est une valeur, la plupart du temps dépendant de variables, qui est soit vraie, soit fausse. En
Matlab , il n’existe pas de booléens, autrement dit de valeur spécifique pour vrai ou faux : un nombre est
vrai s’il est différent de zéro, et un vecteur est vrai s’il ne contient aucun zéro (mais c’est moins important).
En pratique, on définit les conditions à l’aide des opérateurs logiques, qui retournent 0 ou 1 :
A == B
A > (resp. <) B
A >= (resp. <=) B
A ~= B
~A
A && B
A || B
égalité : vrai si A et B sont égaux.
ordre : vrai si A est plus grand (resp. petit) que B.
ordre et égalité : vrai si A est plus grand (resp. petit) ou égal à B.
différence : vrai si A est différent deB.
NON logique : vrai si A est faux.
ET logique : vrai si A et B sont vrais.
OU logique : vrai si A ou B est vrai.
Table 2 – Opérateurs logiques de Matlab
Attention, notez que si A et B dont des vecteurs de même dimension 9 dans les opérations ci-dessus, le
résultat est un vecteur dont l’élément i correspond au résultat de A(i) <opération> B(i). L’exemple ci-dessous
illustre ces opérations :
1
2
3
4
5
6
7
8
9
10
11
EDU > > pi > 3
ans =
1
EDU > > [1 2 3] ~= [0 2 2]
ans =
1
0
1
EDU > > [1 2 3] >= 2
ans =
0
1
1
L’égalité entre nombres réels : il faut faire extrêmement attention lorsqu’on utilise == entre
deux nombres réels (dits à virgule flottante). Pour des raisons informatiques, les nombres à virgule ne
sont pas parfaitement stockés dans la mémoire. Ainsi, deux expressions qui sont mathématiquement
équivalente, comme 0.3 et 0.1 + 0.1 + 0.1 sont différentes dans Matlab (faites le test !). Une solution
est d’employer des inégalités quand c’est possible. La vraie solution académique est de vérifier que la
différence des valeurs à comparer est inférieure en valeur absolue à une certaine tolérance :
1
abs ( A - B ) < tol ; % tol = 1e -6 , par exemple
9. B peut éventuellement être un scalaire.
9
2.3.2
Les instructions conditionnelles : if et else
Une instruction conditionnelle est l’équivalent d’un si dans le code : si une certaine condition est
vraie, alors fais ceci ; sinon, fais cela. La syntaxe est élémentaire :
1
2
3
4
5
6
7
if condition1
% (1) faire quelque chose
elseif condition2
% (2) faire autre chose
else
% (3) dernier recours
end
L’instruction (1) ne sera exécutée que si condition1 est vrai. Si condition1 est fausse, alors le code continue
dans l’instruction conditionnelle, et évalue condition2. Si celle-ci est vraie, alors l’instruction (2) est exécutée.
Sinon, l’instruction (3) est exécutée. Il est possible de mettre plusieurs instructions elseif à la suite. L’instruction else finale n’est pas obligatoire, pas plus que les elseif. Notez que les clauses sont exclusives : elles
ne peuvent jamais s’exécuter en même temps.
Voici, pour illustrer les instructions conditionnelles, un code assignant à la variable M le maximum entre
A et B :
1
2
3
4
5
if A > B
M = A;
else
M = B;
end
Petite note sur l’indentation Le code à l’intérieur d’une instruction conditionnelle est indenté :
on a ajouté des espaces (ou une tabulation) devant le code, pour bien faire comprendre que ce code est
à l’intérieur d’une partie du code total. Cette pratique augmente grandement la lisiblité du code,
et est presque obligatoire !
2.3.3
La boucle while
Une boucle est un mécanisme extrêmement important en programmation. Elle se compose de deux
éléments :
1. Une série d’instructions, qui seront exécutées à chaque itération de la boucle.
2. Une condition d’arrêt régissant la boucle : celle-ci se termine lorsque la condition devient fausse.
Cela se traduit simplement dans la syntaxe de la boucle while :
1
2
3
while condition
% instructions
end
Cette boucle est très utile pour les méthodes itératives.
Boucles infinies : si la condition d’arrêt est toujours vraie, alors la boucle peut ne jamais s’arrêter
(en pratique, il suffit d’appuyer sur Control + C dans la commande interactive pendant l’exécution du
code pour interrompre celle-ci). Les boucles infinies sont évidemment très ennuyantes, et parfois très
difficiles à dépister. Voici deux exemples de boucles infinies, l’une évidente, l’autre moins :
10
1
2
3
4
5
6
7
while 1
end % 1 est toujours vrai !
a = 0.1;
while a ~=1.0
a = a + 0.1;
end
La seconde boucle infinie résulte du problème concernant l’égalité entre réels, que nous avons abordé
plus haut. Une bonne pratique pour éviter les boucles infinies est d’utiliser une variable contenant le
nombre d’itérations effectuées, et vérifier que ce nombre est inférieur à une certaine valeur :
1
2
3
4
5
n = 0;
while conditon && n < NMAX % NMAX = 1000 , par exemple
% instructions
n = n + 1;
end
2.3.4
La boucle for
La boucle for est l’autre mécanisme de boucles de Matlab . Elle est très différente de la boucle while, et
est beaucoup plus simple. Elle se limite à une opération très simple : parcourir un vecteur. La syntaxe est
élémentaire :
1
2
3
for x = vecteur
% instructions , ou x prend successivement la valeur des elements du
vecteur
end
La boucle for est en fait équivalente à cette boucle while :
1
2
3
4
5
6
i = 1;
while i <= length ( vecteur )
x = vecteur ( i ) ;
% instructions
i = i + 1;
end
Cette boucle permet très facilement de réaliser des opérations sur les vecteurs. Malheureusement, elle
n’est pas toujours optimale, et il est souvent plus efficace de manipuler directement les vecteurs plutot que de
les traiter élément par élément. Nous aborderons la syntaxe propre aux vecteurs dans le prochain chapitre :
dans un premier temps, savoir manipuler la boucle for est amplement suffisant.
2.4
Les fonctions
Une fonction, en Matlab , est en quelque sorte l’équivalent d’une fonction mathématique : une entité
qui, pour une certaine entrée (les arguments), sort des valeurs (les valeurs de retour). Tout comme les
variables, les fonctions portent un nom.
11
2.4.1
Syntaxe des fonctions
Quand vous créez une nouvelle fonction avec le logiciel Matlab , vous obtenez déjà un gentil code de base
qui révèle directement la syntaxe à respecter. Vous devriez avoir un truc du genre :
1
2
3
4
5
function [ output_args ] = Untitled ( input_args )
% UNTITLED Summary of this function goes here
%
Detailed explanation goes here
end
Une fonction commence toujours par le mot-clé function et finit toujours par end. Après function on met
le nom de la/des variable(s) retournée(s), séparées par une virgule. Suit ensuite le signe = puis le nom de
la fonction suivie à son tour du nom des variables d’entrée, séparées par une virgule. Cet ensemble forme la
définition de la fonction.
Pour finir, il y a un paragraphe de commentaires qui donne des explications sur l’utilisation de la fonction
(un peu comme le mode d’emploi). Ce texte n’est pas indispensable en théorie pour que la fonction fonctionne
correctement, mais il est quand même recommandé de l’écrire : il s’agit de la documentation sur votre fonction
(plus de détails là-dessus dans la section 2.6 sur les commentaires).
Tout le code compris entre la définition de la fonction et le end final est le code de la fonction : il est
exécuté à chaque appel de la fonction. Un appel de fonction est l’utilisation de cette fonction : cela se fait
en adjoignant des parenthèses contenant
√ les valeurs que vous voulez donner aux arguments au nom de la
fonction. Par exemple, pour calculer 2, on appelle la fonction sqrt avec l’argument 2 : result = sqrt(2).
Tout le code de la fonction est exécuté à chaque appel : contrairement à de nombreux langages de
programmation, l’exécution ne s’arrête pas lorsqu’on assigne une valeur de retour (il n’y pas vraiment de
return en Matlab ). Les valeurs de retour doivent être créées (ce sont des variables) lors de l’exécution.
A titre d’exemple, voici une fonction qui prend en argument deux nombres (ou vecteurs) et les additionne :
1
2
3
4
function [ C ] = addition ( A , B )
% ADDITION retourne la somme de A et B
C = A + B;
end
Un appel à cette fonction pourrait se faire comme ceci :
1
R = addition (1 , 2) ;
Il est de bonne pratique d’indenter le code à l’intérieur des fonctions, pour augmenter la lisibilité.
2.4.2
Plusieurs valeurs de sortie, plusieurs arguments
Il est possible de fournir plusieurs valeurs de sortie à la fonction : cela se fait en définissant plusieurs
identifiants de variables, séparés par des virgules, entre les crochets suivant function. Par exemple, on pourrait
modifier la fonction addition pour qu’elle retourne en plus le produit des deux nombres :
1
2
3
4
5
function [ C , D ] = addition ( A , B )
% ADDITION retourne la somme et le produit de A et B
C = A + B;
D = A * B;
end
Pour récupérer plusieurs valeurs de sortie, il faut utiliser des crochets autour des identifiants des variables
de sortie :
1
[ Somme , Produit ] = addition ( 1 , 2 ) ;
12
Si on emploie pas assez d’arguments à l’entrée, et que l’argument est utilisé par le code de la fonction
(s’il ne l’est pas, c’est anormal !), Matlab soulève une erreur. De même, si on essaye de récupérer une valeur
de sortie qui n’est pas définie par la fonction (par exemple, si le programmeur s’est trompé), Matlab soulève
également une erreur.
Des arguments spéciaux : les options De nombreuses fonctions de Matlab prennent comme argument des options, c’est à dire des arguments facultatifs composés d’un nom (une chaine de caractère)
et une valeur (notez donc qu’il s’agit de deux arguments distincts). Par exemple, la fonction plot (qui
dessine des graphes, voir chapitre 4) permet de spécifier le style des lignes avec l’option LineStyle, de la
manière suivante :
1
plot (x , y , ’ LineStyle ’ , ’ -- ’) ;
Pour aller plus loin
Il est possible de savoir quel est le nombre d’arguments fournis à l’entrée et le nombre de valeurs de retour
demandées lors d’un appel à la fonction, via les variables nargin et nargout. Ceci sort un peu du cadre de ce
document, et est fourni à titre strictement indicatif. Notez que de très nombreuses fonctions Matlab emploient
ces techniques pour plus de flexibilité.
Nous allons modifier la fonction addition de sorte que :
— Elle accepte de n’avoir qu’un seul argument. Elle calcule alors le double et le carré de son argument.
— Elle ne calcule pas le produit si on ne récupère pas explicitement cette valeur.
Le code de la fonction devient donc :
1
2
3
4
5
6
7
8
9
10
11
function [ C , D ] = addition ( A , B )
% ADDITION retourne la somme de A et B
% si B n ’ est pas fourni , la fonction considere que B = A
if nargin == 1
B = A
end
C = A + B;
if nargout == 2
D = A * B;
end
end
Voici quatre appels différents à cette nouvelle fonction, tous valides :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
EDU > > S =
S =
7
EDU > > [S ,
S =
7
P =
12
EDU > > S =
S =
10
EDU > > [S ,
S =
10
addition (3 , 4)
P ] = addition (3 , 4)
addition (5)
P ] = addition (5)
13
15
16
P =
25
Et les appels récursifs ? Matlab ne supporte pas la récursion terminale. Les appels récursifs (lorsque
la fonction s’appelle elle-même) sont à éviter tant que possible.
Fonctions utiles de Matlab
2.4.3
Pour conclure cette section sur les fonctions, voici une petite liste de fonctions qui vous seront utiles dans
le cadre du cours de Méthodes Numériques, et/ou par la suite. Les explications fournies pour chaque fonction
sont très courtes, et décrivent un seul des comportements possibles de la fonction. Pour plus d’information,
nous vons invitons à consulter la documentation (help nom_de_la_fonction dans la commande interactive).
Identifiant
cos(X), sin(X), tan(X)
sqrt(X)
abs(X)
acos(X),
atan(X)
asin(X),
polyfit(X, Y, N)
polyval(P, X)
spline(X, Y, t)
roots(P)
fzero(FUN, X0)
[V, D] = eigs(A, K)
ode45(ODEFUN, TSPAN, Y0)
Description
Les fonctions trigonométriques classiques. Leur argument peut être un vecteur de
complexes.
La racine carrée (SQuare RooT ). Son argument peut être un vecteur de complexes, éventuellement négatifs.
La valeur absolue. Pour les complexes, ceci calcule la norme de chaque complexe (à ne pas confondre avec norm(X) qui retourne la norme totale du vecteur !).
L’inverse des fonctions trigonométriques. Leur argument peut être un vecteur
de complexes (notez que Matlab manipule très facilement les complexes, et donc
utiliser des valeurs sortant des domaines réels de ces fonctions ne provoque pas
d’erreur : essayez acos(2)).
Retourne les coefficients d’un polynome de degré N passant au mieux (au sens des
moindres carrés) par les points (X, Y). Si N < length(X), le polynome retourné
passe exactement par les points.
retourne la valeur du polynome représenté par les coefficients P en les points X.
retourne la valeur de l’interpolation par splines cubiques des points (X, Y) en les
abscisses t
Retourne un vecteur contenant toutes les racines complexes du polynome représenté les coefficients P. Les racines multiples sont présentes plusieurs fois, de sorte
que la taille du vecteur est toujours le degré du polynome moins un.
Retourne une racine de la fonction FUN (passée en argument sous forme de function handle : mettez un @ devant le nom), en commençant la recherche à partir
de l’abscisse X0.
Recherche de valeurs propres (eigenvalues) : la matrice D contient les K plus
grandes valeurs propres de A dans sa diagonale, et V contient K vecteurs propres
correspondants à ces valeurs propres.
Résolution d’équations différentielles ordinaires. Son utilisation est décrite dans
le chapitre 5.1.
Table 3 – Quelques fonctions utiles de Matlab
2.5
Débugger votre code Matlab
Vous découvrirez malheureusement vite qu’un code Matlab ne fonctionne quasi jamais (correctement) du
premier coup, même pour le meilleur des informaticiens ! Une fois que vous aurez constaté avec consternation
que votre joli code ne donne pas le résultat attendu, il va falloir se mettre à la recherche des erreurs de
14
programmation commises, communément appelées bugs. La mauvaise nouvelle, c’est qu’un code est parfois
long et complexe et il est difficile de trouver ou se cachent ses failles en regardant juste le résultat final
du code. La bonne nouvelle, c’est que le logiciel Matlab offre de nombreux outils permettant de faciliter la
recherche de bugs.
2.5.1
Le point-virgule
D’habitude, toutes les lignes Matlab se terminent par un point-virgule ( ;). Pourtant, ces points-virgules
(semicolon en anglais) ne sont pas indispensables au bon fonctionnement du programme 10 : elles permettent
par contre de masquer le résultat de l’opération. Si vous enlevez ce point-virgule, Matlab affichera le résultat
numérique de l’opération concernée dans la console.
Souvent, tous ces résultats intermédiaires ne nous intéressent pas (d’où l’habitude de mettre un pointvirgule à la fin de chaque instruction). Mais dans une traque au bugs, on peut utiliser ces résultats intermédiaires pour vérifier le bon fonctionnement de chaque petit bout de code étape par étape (plutôt que de devoir
vérifier le fonctionnement de tout le code d’un coup), ce qui permet de localiser rapidement l’emplacement
du bug. Attention toutefois de ne pas oublier de remettre les point-virgules que vous avez supprimé avant
de rendre votre code. . .
2.5.2
Quelques fonctions pour afficher vos résultats
Afficher le résultat de chaque calcul effectué par Matlab c’est bien, mais ce n’est pas toujours la valeur que
l’on souhaite vérifier (et en plus, c’est un peu moche comme manière de procéder). Bonne nouvelle, Matlab
regorge de fonctions diverses permettant de vérifier le bon déroulement d’une suite de calculs.
Une fonction qui est extrêmement utile est disp. Comme son nom l’indique très bien, disp(var) affiche le
contenu de la variable var.
Comme on travaille souvent avec des matrices assez grandes, il est parfois difficile de conclure quelque
chose en faisant un simple disp sur ladite matrice : 3 tonnes de chiffres qui se suivent peuvent être compliqués
à interpréter. Pour de telles matrices, on peut utiliser spy. spy affiche dans une jolie petite image la matrice
de la manière suivante : les entrées non-nulles sont représentées par un petit point, tandis que les entrées
nulles restent une case blanche. Ce qui permet de rapidement visualiser quelles entrées de la matrice sont
non-nulles, et comprendre ce qui s’y passe.
2.5.3
Mesurer le temps d’exécution du code
Parfois, il arrive que vous finissiez votre code, que celui-ci marche et soit paré à toute entrée vicieuse. . . à
ce moment, vous vous demanderez sans doute ce que vous allez faire de votre vie maintenant que tout
est fini. . . Mais j’ai une bonne nouvelle pour vous ! Une fois votre code terminé, vous pourrez améliorer
les performances de celui-ci pour le rendre encore plus rapide ! Alléchant n’est-il pas ? Blague à part, les
performances temporelles d’un programme sont un critère important et il est donc important de rendre
votre programme le plus rapide possible !
Pour cela, il faut savoir mesurer le temps d’exécution de votre code pour voir comment ce temps évolue
avec les modifications que vous apportez à votre code. Pour cela, Matlab possède une fonction (en fait, deux
fonctions) pour chronométrer votre temps et battre tous les records : tic et toc. Quand Matlab rencontre
l’instruction tic, il lance un chronomètre. Quand il rencontre toc, il arrête le chronomètre et renvoie le temps
écoulé entre tic et toc.
2.5.4
Programmer défensivement
Programmer défensivement, c’est écrire du code tel qu’il est protégé des attaques des utilisateurs. Les
attaques, ce sont des arguments invalides : un vecteur colonne à la place d’un vecteur ligne, un entier négatif
au lieu d’un entier positif. . .
10. Rien à voir donc avec les points-virgules indiquant la fin d’une instruction en Java ou en C par exemple.
15
Un code est dit robuste si, lorsqu’on lui fournit un argument invalide, le code ne crashe pas, autrement dit,
agit de manière controlée. En Matlab, le plus simple est d’ajouter des clauses if au début du code, vérifiant la
validité des arguments. S’ils ne le sont pas, il suffit d’employer la fonction de base error, assortie d’une chaine
de caractères informant l’utilisateur de l’erreur qu’il a commise. Si c’est possible, ce peut être une bonne idée
de corriger l’erreur : l’exemple le plus simple est l’emploi d’un vecteur ligne à la place d’un vecteur colonne,
résolu par une simple transposition.
Notez que, pour vérifier si un vecteur ligne ou colonne, il existe deux fonctions : isline et iscolumn.
2.6
Un petit commentaire sur l’utilisation de commentaires
Ecrire du code qui fonctionne, c’est bien. Mais écrire du code qui fonctionne et qui est compréhensible
facilement, c’est mieux, surtout quand ce code va être lu, par exemple par un correcteur. . . Il existe un certain
nombre de réflexes qui rendent votre code plus agréable à lire, et permettent de rendre votre tuteur/tutrice
plus heureux/heureuse.
Les commentaires : partout, toujours Un code sans commentaire est un code incompréhensible. Les
commentaires doivent accompagner le code, expliquer de manière simple ce qu’il fait, décrire le role des différentes variables et fonctions définies. Attention qu’il ne faut pas verser dans l’excès ! Trop de commentaires
rend le code illisible, parce que trop chargé. En particulier, évitez de mettre un commentaire entre chaque
instruction : groupez les instructions et les commentaires, afin de permettre une visualisation plus facile de
l’exécution.
Les commentaires décrivant une fonction, qui suivent directement la signature de la fonction (son nom),
sont obligatoires. Il s’agit du seul moyen pour celui qui utilise votre fonction de comprendre ce qu’elle fait.
Ces commentaires doivent décrire le role de la fonction, quels arguments sont attendus (par exemple, deux
vecteurs de même taille et un entier positif), et quelles seront le ou les valeur(s) de sortie.
Nommez vos variables convenablement Le nom (l’identifiant) d’une variable doit permettre de comprendre facilement ce que représente cette variable. Un nom de variable comme var, ou fonction est donc à
proscrire !
Aussi, il vaut mieux, en général, éviter les noms de variables en un seul caractère, mais en Matlab,
cela ne cause pas de réel problème, les codes étant relativement courts. Aussi, les noms de variable comme
currentIterationNumber peuvent paraitre une bonne idée sur papier, mais sont en pratique beaucoup trop
lourds. Comme pour les commentaires, il faut trouver un juste milieu entre trop court et trop long.
Toutefois, en Matlab, les codes sont souvent fortement liés à des formules mathématiques : les variables
correspondent donc à des variables mathématiques. Utiliser comme identifiant le nom de la variable mathématique (u, x, theta, . . . ) est une bonne pratique, car cela facilite le parallèle entre les formules et le code.
N’oubliez pas, cependant, de préciser à quoi correspondent les variables par des commentaires.
Ainsi, pour l’angle d’un pendule, par exemple, il vaut mieux employer theta, plutot que a ou angleDuPendule. Bien nommer ses variables est le plus souvent une simple question de bon sens !
L’indentation : son absence est un crime Pour rappel, indenter du code consiste à mettre des espaces
(ou des tabulations) devant les lignes de code se trouvant dans un bloc de code (if, while, function, for, . . . ).
L’indentation permet de distinguer immédiatement le code appartenant au bloc, et facilite énormément la
lecture du code ! Comme l’éditeur de Matlab indente automatiquement le code, vous n’avez donc aucune
excuse pour ne pas indenter votre code !
Aérez votre code Les espaces, en Matlab, ne changent rien : ainsi, x=0 ; est strictement équivalent à
x = 0 ; . Ajouter des espaces permet d’aérer le code, donc augmenter la lisibilité, sans rendre le code plus
difficile à comprendre.
16
Les lignes vides ne modifient pas le comportement du code, et permettent de diviser le code en paragraphes, pour simplifier la lecture. Par exemple, il est intelligent de regrouper les déclarations de variables,
en les séparant des opérations.
Aussi, même si Matlab le permet, évitez d’écrire plusieurs instructions en une ligne (en les séparant par
des point-virgules) : cela rend le code assez difficile à lire.
N’oubliez pas vos point-virgules . . . Vérifiez toujours que vous n’avez pas oublié des point-virgules
quand vous assignez une valeur à une variable : sauf si explicitement précisé, vos fonctions ne doivent jamais
afficher quoi que ce soit lorsque vous les lancez (à part éventuellement un warning).
Un petit exemple Voici, pour vous convaincre que ces règles sont essentielles (et devraient être un
réflexe !). Essayez de comprendre le code suivant, qui est écrit de la façon la plus illisible possible :
1
2
3
4
5
6
7
8
9
function [ res ] = fonction1 ( x1 , x2 , x3 )
a = x2 * x2 ; b =4* x1 * x3 ;
if a == b
res =[ - x2 /(2* x1 ) ]
else
v = sqrt (a - b )
res =[( - x2 - v ) /(2* x1 ) ,( - x2 + v ) /(2* x1 ) ]
end
end
Et voici le code corrigé, en tenant en compte les règles :
1
2
3
4
5
6
7
8
9
10
11
12
function [ x0 ] = polynome2roots (a , b , c )
% trouve les racines du polynome a * x ^2 + b * x + c
% ceci retourne un vecteur contenant les racines distinctes
rho = b * b - 4* a * c ;
% si racine double : une seule valeur
if rho == 0
x0 = [ - b /(2 * a ) ];
else
sqrho = sqrt ( rho ) ; % calcul unique de la racine de rho
x0 = [ ( - b - sqrho ) /(2* a ) , ( - b + sqrho ) /(2* a ) ];
end
end
Plus clair, n’est-ce-pas ?
3
Opérations sur les vecteurs
Les vecteurs, c’est un des plus gros points forts de Matlab : il est très facile 11 de créer et manipuler ceux-ci
(et pour cause ! Matlab est l’acronyme de Matrix Laboratory).
Nous ne vous feront pas l’affront de vous rappeler ce qu’est un vecteur en mathématiques, mais avec
Matlab , le mot "vecteur" désigne uniquement les structures de données (en d’autres mots, les matrices).
Plus concrètement, on peut voir un vecteur comme comme un tableau à deux dimensions de nombres.
Comme pour les variables classiques (qu’on peut voir comme les plus petits vecteurs possibles), il n’est
pas nécessaire de déclarer un vecteur 12 , il sera crée automatiquement la première fois qu’on lui assigne une
valeur.
11. Essayez un peu de traduire un code Matlab en C, par exemple. Le nombre de lignes de codes est multiplié par 10. . .
12. Même si il convient parfois de faire de la pré-allocation, on y reviendra.
17
3.1
3.1.1
Créer ses propres vecteurs
Syntaxe propre aux vecteurs
Matlab propose une syntaxe simple pour créer des vecteurs, qui se compose de trois (en fait, quatre)
symboles :
1. les crochets [ ] : ils délimitent le début et la fin du vecteur
2. la virgule , : elle sépare les éléments d’une ligne
3. le point-virgule ; : il sépare les différentes lignes
Ainsi, pour créer la matrice (de la vie de tous les jours)


π
217.3
√1

A =  2 42
i
−1 1042 6.626 · 10−34
On utilisera le code :
1
A = [1 , pi , 2^17.3; sqrt (2) , 42 , 1 i ; -1 , 1 e42 , 6.626 e -34]
La syntaxe est même plus simple que ça : la virgule est en fait facultative. On peut tout à fait la remplacer
par un espace, ce qui augmente la lisibilité du code dans certains cas. Il est aussi possible d’effectuer un retour
à la ligne (touche ENTER) à la place de mettre un point-virgule.
3.1.2
Fonctions de création de vecteurs
Cette manière de faire fonctionne bien pour des petits vecteurs (par exemple, si vous voulez résoudre un
petit système linéaire). Toutefois, elle s’avère très vite fastidieuse si vous devez manipuler des vecteurs plus
grands (et donc, plus intéressants). Imaginez créer une matrice unité de taille 20 fois 20. . . De plus, il arrive
souvent qu’on ne puisse déterminer la taille d’un vecteur que lors de l’exécution du code. Par exemple, cette
syntaxe de permet pas de créer une fonction retournant une matrice unité de taille n passée en argument.
Heureusement, Matlab offre une solution à ce problème : un ensemble de fonctions permettant de créer
des vecteurs particuliers. Ces fonctions sont très largement utilisées et il n’y pas d’autre solution que de les
mémoriser. . .
Voici, en vrac, une série de fonctions qui vous seront éventuellement utiles (surtout les trois premières) 13 :
Fonction
linspace(a, b, n)
zeros(l, c)
ones(l, c)
eye(l, c)
diag(V, k)
magic(n)
rand(m, n)
Valeur de retour
Vecteur ligne dont les n éléments sont répartis linéairement entre a et b inclus
Matrice l × c remplie de zéros.
Matrice l × c remplie de uns.
Matrice l × c dont la diagonale est remplie de uns (matrice unité si l=c).
Si V est un vecteur de taille n, une matrice n + k × n + k dont la ki`eme diagonale est le
vecteur V.
Un carré magique de taille n × n
Matrice m × n rempli de nombres aléatoires entre 0 et 1.
Table 4 – Fonctions essentielles pour créer des vecteurs
Notez qu’il existe une syntaxe alternative à linspace : [a : dx : b], qui génère un vecteur contenant toutes
b
les valeurs a + i · dx, 0 ≤ i ≤ dx
(autrement dit, toutes les valeurs entre a et b séparées de dx). Faites
attention que si l’écart entre a et b n’est pas un multiple de dx, b ne sera pas inclus dans le vecteur. La valeur
13. Un carré magique de taille n est une matrice n×n contenant exactement une fois tous les nombres de 1 à n2 , dont la
somme de chaque ligne, colonne ou diagonale est toujours la même. Hé oui, c’est magique. Essayez un peu magic(20000).
18
par défaut de dx est 1, ce qui permet très facilement de créer des vecteurs de nombres entiers (par exemple,
1:5 contient les entiers entre 1 et 5 inclus). Les crochets sont facultatifs, ici, mais il est recommandé de les
ajouter.
3.1.3
Adjonction de vecteurs
Un dernier outil pour créer des vecteurs est l’adjonction de vecteurs. Ceci est similaire aux opérations par
blocs en mathématiques : on peut représenter une matrice par les différentes sous-matrices qui la composent.
Le bonne nouvelle, c’est que la syntaxe est exactement la même que pour la création de matrices : des
virgules pour séparer les blocs horizontalement, et des point-virgules pour les séparer verticalement. Voici
un exemple :
1
2
3
4
A
B
C
R
=
=
=
=
[2 ,
[4;
[5 ,
[1 ,
3]; %
7]; %
6; 8 ,
A; B,
vecteur ligne
vecteur colonne
9]; % matrice carree
C ]; % adjonction
La mauvaise nouvelle, c’est qu’il faut prendre beaucoup de précautions quant aux dimensions des
vecteurs concernés. Ça parait simple, mais les erreurs sont très fréquentes, et les insultes de Matlab qui
s’ensuivent ne sont pas très explicites. Si on échange A et B dans la dernière ligne du code ci-dessus, Matlab
nous dit ceci :
3.2
3.2.1
Manipuler des vecteurs
Accès aux éléments
L’accès aux éléments d’un vecteur est une opération extrêmement courante, et la syntaxe qui l’implémente
est à la fois simple et très puissante. Par accéder à un élément, on entend lire la valeur d’un élément, ou d’un
sous-groupe d’éléments, d’un vecteur, mais également la modifier.
Tout d’abord, pour accéder au i e`me élément d’un vecteur à une dimension (indifféremment ligne ou
colonne), il suffit d’adjoindre une paire de parenthèses contenant l’indice de l’élément à l’identifiant du
vecteur : x(i). Ceci est appelé un accès en lecture.
Attention, contrairement à la plupart des langages de programmation, Matlab numérote ses vecteurs à
partir de 1, et non de 0. Le premier élément est donc celui d’indice 1, et le dernier d’indice égal à la longueur
du vecteur.
Pour assigner la valeur du ie`me élément d’un vecteur x à 42, on emploiera le code :
1
x ( i ) = 42;
Nous appelerons ceci un accès en écriture. Notez que cette syntaxe est la même que celle utilisée pour
assigner une valeur à une variable. On peut en fait traiter les éléments d’un vecteur comme des variables.
Accès aux éléments. . . pas dans le vecteur ! Lorsqu’on tente d’accéder en lecture à un élément
dont l’indice est plus grand que la taille du vecteur, Matlab soulève une erreur : Index exceeds matrix
dimensions.
Par contre, si on accède en écriture à un élément, il n’y a pas de problème : Matlab agrandit le
vecteur, ajoutant des zéros entre la fin du vecteur et l’emplacement désiré (qui sera lui assigné à la
valeur demandée). Cette pratique permet de créer plus simplement des vecteurs via des boucles mais est
toutefois à éviter, pour des raisons que nous aborderons plus loin.
19
Cette syntaxe fonctionne également avec les matrices, mais de manière plus obscure, et rarement utile.
Les éléments d’une matrice sont numérotés en partant du haut à gauche, en descendant le long de la première
colonne, puis de la deuxième, et ainsi de suite :


1 4 7
 2 5 8 
3 6 9
Pour les matrices, on peut accéder à un élément en spécifiant simplement sa ligne et sa colonne,
séparées d’une virgule. C’est la forme d’accès la plus utilisée sur les matrices. Elle est illustrée par le code
ci-dessous :
1
2
3
4
5
6
7
EDU > >
EDU > >
EDU > >
EDU > >
A = eye (3) ;
A (1 , 2) = 42;
A (3 , 1) = -1;
disp ( A )
% affichage de A
1
42
0
0
1
0
-1
0
1
Une forme d’accès plus sophistiquée consiste à accéder à des sous-matrices à l’intérieur des matrices
(des groupes d’éléments). Cela se fait en utilisant des vecteurs d’indice. En d’autres termes, si x est un
vecteur de nombres entiers, alors A(x) retourne un vecteur contenant les éléments de A aux indices spécifiés
par x. Employer un vecteur x quelconque n’est que rarement utile, et en pratique on emploie souvent des
vecteurs de la forme a:b, avec a le premier indice et b le dernier. Cela permet d’obtenir tous les éléments
d’indice compris entre a et b. Notez qu’on peut également employer cette forme d’accès sur les lignes et les
colonnes d’une matrice.
1
2
3
4
5
6
7
8
9
10
11
12
EDU > > A = eye (3) ;
EDU > > B = [1 2 3 4 5];
EDU > > disp ( B (2:4) ) ;
2
3
4
EDU > > disp ( A (2:3 , 1:2) )
0
1
0
0
EDU > > disp ( A (2:3 , 1) )
0
0
Enfin, il existe une syntaxe spéciale pour deux situations :
1. L’accès à tous les éléments de i au dernier : A( i:end )
2. L’accès à tous les éléments : deux points A(:) (équivalent à A( 1:end ) )
Cette syntaxe permet d’accéder facilement à une colonne ou une ligne d’une matrice :
1
2
A ( i , : ) % acces a la ligne i
A ( : , i ) % acces a la colonne i
3.2.2
Opérations sur un vecteur
Opérations spéciales Des multiples opérations sur un seul vecteur que Matlab supporte, trois sont particulièrement utiles :
20
— A’ : la transposition. Les matrices de mauvaise dimension causent très souvent des erreurs en Matlab
, et la plupart du temps une simple transposition suffit à résoudre les problêmes. D’ou l’emploi d’une
syntaxe facile : le guillemet.
— inv(A) : l’inversion. Bien qu’à éviter pour résoudre les systèmes en Matlab , l’inversion reste une
opération capitale. Attention que si la matrice n’est pas inversible, Matlab affiche un Warning et
renvoie une valeur absurde.
— reshape(A, M, N) : changement de forme d’une matrice. Ceci permet de passer d’une matrice à un
vecteur, et inversément, et sera utile pour le cours de méthodes numériques. La matrice résultante
comprendra M lignes et N colonnes.
Dimension d’un vecteur A ce stade, on peut s’intéresser à la façon de récuperer la dimension d’un
vecteur. Deux fonctions sont à notre disposition : size et length.
size retourne deux valeurs : le nombre de lignes et de colonnes du vecteur passé en argument. On peut
donc récupérer le nombre de lignes de A en faisant x = size(A) pour stocker la taille de A dans le vecteur x,
puis en écrivant x(1).
length devrait être utilisée exclusivement sur les vecteurs à une dimension (des vecteurs lignes ou colonne) :
il donne le nombre d’éléments d’un tel vecteur à une dimension. Mais si on donne à length un vecteur à
plusieurs dimensions, il retournera le nombre de lignes de ce vecteur. C’est pourquoi nous vous conseillons
d’utiliser length pour les vecteurs à une dimension et size sinon. En conclusion, voici un petit bout de code
qui montre le comportement de ces deux fonctions.
1
2
3
4
5
6
7
8
9
10
>> A = [[1 5 3];[7 8 9];[2 8 9];[2 3 2]] ;
>> B = 8:11 ;
>> disp ( size ( A ) )
% 4 lignes et 3 colonnes
4
3
>> disp ( size ( B ) )
% La valeur retournee est un VECTEUR
1
4
>> disp ( length ( A ) )
% !! A est a 2 dimensions = > pas ideal
4
>> disp ( length ( B ) )
% Il s ’ agit du nombre de colonnes de B !
4
Fonctions agrégatives On désigne par fonctions agrégatives toutes les fonctions qui, pour un vecteur à
une dimension en argument, sortent un nombre. Les plus utiles sont illustrées dans le code suivant :
1
2
3
4
max ( X ) ;
min ( X ) ;
mean ( X ) ;
sum ( X ) ;
%
%
%
%
maximum des elements
minimum des elements
moyenne des elements
somme des elements
Si on donne une matrice en argument à ces fonctions, elles retournent un vecteur ligne contenant le résultat
de l’opération sur chaque colonne. Pour faire la somme de tous les éléments d’une matrice, il faut donc faire
sum( sum( A ) ).
3.2.3
Opérations entre vecteurs
En général, c’est ici que beaucoup d’erreurs vont apparaître, et pour cause : les vecteurs impliqués dans
l’opération courante n’ont pas les bonnes dimensions. Ca parait idiot, mais c’est sans aucun doute l’erreur la
plus courante sur Matlab. Faites donc toujours bien attention à la compabilité entre vecteurs avec l’opérations
que vous utilisez (un bout de papier et un crayon font parfois des miracles pour ça).
Voici les opérations de base entre vecteurs supportées par Matlab. La dernière commande est l’une des
plus utiles de Matlab : elle permet de résoudre un système linéaire A*x = b.
21
1
2
3
4
5
A + B;
A - B;
A * B;
x = A\b;
%
%
%
%
%
addition de A et B ( etonnant non ?)
! A et B doivent avoir la meme taille
multiplication MATRICIELLE entre A et B
il faut que # col de A = # lin de B
x est une colonne contenant la solution de A * x = b
Petite note sur A\b : Cet opérateur est sans aucun doute celui que vous utiliserez le plus souvent
sur Matlab . . . Mais que fait-il vraiment ?
x = A\b résoud l’équation A * x = b de la manière la plus efficace possible. Toutefois, cela n’est vrai
que si le système admet une et une seule solution ! Il est en cela équivalent à x = inv(A) * b, qui est à
éviter à tout prix. Pourquoi ? Tout d’abord, c’est contre-efficace : il faut faire plus d’opérations en
inversant puis en multipliant qu’en résolvant. Ensuite, inverser une matrice est numériquement instable,
et conduit à des erreurs. Enfin, pas de résolution si la matrice n’est pas inversible !
En utilisant A\b, Matlab se comporte intelligemment si le système n’est pas régulier. Si le système
n’admet pas de solution, Matlab le résoud au sens des moindres carrés (Ce qui est bien souvent ce
que l’on recherche) ! Par contre, si le système admet plusieurs solutions, Matlab vous affiche un Warning :
Matrix is singular to working precision, et vous sort un vecteur rempli de NaN (ou avec quelques nombres,
s’ils sont les mêmes pour toutes les solutions). . .
3.2.4
Opérations élément par élément
Parfois, on aimerait effectuer une opération entre les éléments de deux vecteurs plutôt qu’entre les deux
vecteurs : par exemple, on souhaite multiplier le premier élément d’un vecteur avec le premier élément d’un
autre vecteur, puis le second élément du premier vecteur avec le second élément du deuxième, etc. . . Cela est
possible avec Matlab en utilisant les element-wise operations, les opérations "élément par élément". Attention,
il faut bien sûr que les deux vecteurs soient de même dimension. Ces opérations s’obtiennent facilement en
rajoutant un point devant le symbole de l’opération. Quelques exemples :
1
2
3
4
5
x = [1 3 5]; y = [2 0 1];
x .* y ;
y ./ x ;
x .^ y ;
x .^2;
3.3
%
%
%
%
%
quelques vecteurs pour s ’ amuser
calcule [1*2 3*0 5*1] = [2 0 5]
[2 0 0.2]
[1 1 5] ( exposant element par element )
[1 9 25] : cela fonctionne aussi !
Les vecteurs Like A Boss
Pour employer Matlab de la manière la plus efficace (avec des codes les plus rapides) possible, il est
essentiel de savoir utiliser les vecteurs correctement. C’est l’objectif de cette section : apprendre à employer
les vecteurs Like A Boss.
3.3.1
La vectorisation
La première étape pour apprendre à employer Matlab correctement est de penser en termes de vecteurs.
L’emploi extensif de vecteurs s’appelle la vectorisation, et se base sur 4 concepts clés :
1. toutes les fonctions à une variable prennent en argument un vecteur (sqrt, exp, sin, . . . )
2. l’emploi des fonctions agrégatives (sum, mean, . . . )
3. l’emploi du produit matriciel et des opérations élément par élément
4. l’emploi de fonctions de création de vecteurs pour générer efficacement des vecteurs
22
Plus simplement, il existe une règle (presque) d’or : employer le moins possible de boucle for. Bien
souvent, une boucle for a pour but de parcourir les éléments d’un vecteur, ce qui est une opération assez lente
qui peut la plupart du temps (mais pas toujours) se remplacer par une ou plusieurs opérations vectorielles.
Les codes vectorisés sont souvent plus courts, et presque toujours plus rapides, mais en général, plus
compliqués à écrire et à comprendre. Ecrire du code vectoriel demande une certaine pratique.
Pour illustrer cette idée, voici quelques exemples de codes Matlab résolvant une tache plus ou moins
simple, le code de gauche étant l’implémentation naive, et celui de droite l’implémentation vectorisée.
Calculer le sinus des éléments d’un vecteur X
1
2
3
4
Y = zeros ( size ( X ) ) ;
for i = 1: length ( X )
Y ( i ) = sin ( X ( i ) ) ;
end
1
Y = sin ( X ) ;
Calculer la racine carrée de la moyenne du carré des éléments d’un vecteur X Une opération
courante (si, si !) : il s’agit du RMS en électricté
1
2
3
4
5
Y = 0; % resultat
for elem = X
Y = Y + elem * elem ;
end
Y = sqrt ( Y / length ( X ) ) ;
1
Y = sqrt ( mean ( X .^ 2 ) ) ;
Calculer la valeur maximale d’un polynome sur un vecteur X d’abscisses Pour l’exemple, nous
choisirons le polynome x3 + 2x + 1.
1
2
3
4
5
6
7
Y = - Inf ; % maximum actuel
for elem = X
val = ( elem ^3 + 2* elem + 1) ;
if val > Y
Y = val ;
end
end
1
Y = max ( X .^3 + 2* X + 1 ) ;
Créer une matrice N × N tridiagonale de 1, avec des 2 sur la diagonale Un exemple un peu
sophistiqué qui repose sur l’emploi de diag. Ici, la vectorisation n’est pas absolument nécessaire, puisque la
création d’un vecteur n’est en général pas une opération critique (puisque réalisée une seule fois).
1
2
3
4
5
6
7
8
A = zeros (N , N ) ;
A (1 , 1) = 2;
A (N , N ) = 2;
for i = 2: N -1
A (i , i ) = 2;
A (i -1 , i -1) = 1;
A ( i +1 , i +1) = 1;
end
1
2
23
D = diag ( ones (1 , N -1) , 1) ;
A = diag ( ones (1 , N ) *2) + D + D ’ ;
Calculer le sin(n * X), pour n = 1..N, et X un vecteur colonne Le résultat sera donc une matrice.
Ce genre de problèmes peut paraitre absurde et tordu, et pourtant, vous serez amenés à faire pire dans le
cadre du cours. . .
1
2
3
4
5
6
res = zeros ( length ( X ) , N ) ;
for i = 1: length ( X )
for j = 1: N
res (i , j ) = sin ( X ( i ) * j ) ;
end
end
3.3.2
1
Y = sin ( X * [1: N ] ) ;
La préallocation
Comme mentionné plus haut dans ce chapitre, Matlab supporte un accès en écriture aux éléments d’un
vecteurs avec un indice supérieur à la taille du vecteur : le vecteur est alors agrandi en ajoutant des zéros
jusqu’à la position désirée, qui est elle assignée à la valeur spécifiée. Cela permet relativement facilement de
créer des vecteurs. Voici, par exemple, une fonction équivalente à [1:N] qui se base sur cette technique :
1
2
3
4
5
6
7
8
function X = entiers ( N )
X = [];
i = 1;
while i <= N
X(i) = i;
i = i + 1;
end
end
Malheureusement, cette technique est à éviter à tout prix ! D’ailleurs, l’éditeur Matlab souligne en orange
le code X(i) = i, et nous informe que : Variable ’X’ appears to change size on every loop iteration. Consider
preallocating for speed. En d’autres termes, le vecteur change de taille à chaque itération, ce qui est précisément
ce que l’on cherche à faire. Pourquoi Matlab se plaint-il ? C’est une question de performance. Le code dans
sa version actuelle est terriblement lent, et peut être optimisé facilement.
La raison de ce manque d’efficacité est en fait bêtement informatique : lorsque Matlab augmente la taille
d’un vecteur, il se passe un véritable déménagement en mémoire. Matlab cherche en mémoire un bloc vide de
la taille du nouveau vecteur, et y copie alors tout le contenu de l’ancien vecteur (en y adjoignant la nouvelle
valeur). Et ceci, à chaque opération. Autrement dit, Matlab doit chercher de la place et copier son vecteur
N fois de suite, ce qui prend de plus en plus de temps, lorsque la taille du vecteur augmente !
La solution est très simple : préalloquer, autrement dit définir au préalable un vecteur de la même taille
que le vecteur de sortie. Les valeurs contenues à l’origine dans le vecteur ne sont d’aucune importance,
puisqu’elles seront de toute façon supprimées. En général, on utilise la fonction zeros pour créer une matrice
pleine de zéros de bonne dimension. Pour améliorer le code ci-dessus, il suffit donc de remplacer X = [ ] par
X = zeros(1, N), et le tour est joué !
En mesurant les performances des deux programmes, on s’aperçoit que le code avec préallocation est au
moins dix fois plus rapide que l’autre (parfois même cent fois plus !), ce qui représente un gain considérable !
3.3.3
Les matrices creuses
L’emploi de matrices creuses permet d’améliorer les performances de certains programmes de manière
vraiment importante, mais uniquement dans certaines circonstances. Tout d’abord, expliquons ce qu’est une
matrice creuse : il s’agit d’une matrice contenant beaucoup de zéros, donc assez peu d’éléments réellement
importants. De telles matrices apparaissent dans de nombreux problèmes en sciences de l’ingénieur.
24
Matlab permet de stocker ces matrices sous une forme plus avantageuse, avec l’emploi de la fonction
sparse. Cette fonction prend en argument une matrice, et retourne cette matrice sous forme creuse (sparse
en Anglais). Voici un exemple :
1
2
3
4
5
6
EDU > > A = [0 0 0 1; 0 1 0 0; 2 0 0 0];
EDU > > sparse ( A )
ans =
(3 ,1)
2
(2 ,2)
1
(1 ,4)
1
Quel est l’intérêt d’utiliser des matrices creuses ? Accélérer la résolution de systèmes linéaires.
Il existe des algorithmes très rapide pour cette opération sur des matrices creuses (algorithmes qui sont
évidemment supportés par Matlab).
Cela a un prix, évidemment : assigner des éléments dans une matrice creuse est une opération couteuse,
plus couteuse que d’assigner dans une simple matrice. Aussi, l’opération sparse est relativement lente pour
de grandes matrices. Un bon compromis est de créer la matrice sous forme classique, et de la transformer en
matrice creuse une fois que la création de la matrice est terminée. Le gain de temps total, sur des matrices
de grande taille, est alors considérable.
Les matrices creuses sont un sujet assez complexe, qui sort du cadre de ce document. Toutefois, l’emploi
de la fonction sparse avant la résolution de systèmes linéaires est en général amplement suffisant pour la
plupart des taches classiques.
4
Dessiner des graphes
Vous voilà donc maître des fonctionnalités principales de Matlab , et vous avez écrit un super code
performant qui marche à merveille... et qui vous donne une tonne de chiffres à virgule flottante absolument
indigestes et impossibles à interpréter ! Heureusement, il est très simple de créer des graphes avec Matlab.
4.1
Créer le graphe de base (titre, axes...)
Le code suivant permet de créer un graphe contenant les informations essentielles. Analysons celui-ci
ligne par ligne. 14
1
2
3
4
5
6
7
8
9
figure () ;
% Nouvelle figure
plot (x , y )
% Le graphe en question
hold on ;
% On va rajouter un deuxieme graphe par - dessus
plot (x ,z , ’g ’)
% On precise ici la couleur souhaitee
title ( ’ Population ␣ mondiale ␣ de ␣ Koalas ␣ et ␣ de ␣ Pelicans ␣ en ␣ fonction ␣ de ␣ la ␣
temperature ’)
xlabel ( ’ Temperature ␣ [ K ] ’)
ylabel ( ’ Population ␣ animale ␣ en ␣ millions ␣ [/] ’)
legend ( ’ koalas ’ , ’ pelicans ’)
hold off ;
% Pour les graphes suivants
14. Vous aurez remarqué que la population de pélicans peut être négative : il s’agit d’anti-pélicans. Leurs collisions fréquentes
avec les pélicans normaux dégage une quantité énorme d’énergie, énergie qu’absorbent les koalas (des vrais). Ce phénomène
explique la croissance golbale de koalas, qui oscille en fonction de l’oscillation de la population de pélicans.
25
4
5
x 10
Population mondiale de Koalas et de Pelicans en fonction de la temperature
koalas
pelicans
Population animale en millions [/]
4
3
2
1
0
−1
260
280
300
320
Temperature [K]
340
360
380
Figure 2 – Le résultat du code d’exemple.
Ligne 1 : création de la figure Avant de pouvoir dessiner votre graphe, il faut indiquer à Matlab
que vous souhaitez placer celle-ci dans une nouvelle fenêtre. Si vous ne le précisez pas, Matlab prendra la
dernière fenêtre ouverte 15 , écrasant un éventuel graphe important dedans... Nous vous recommandons donc
de toujours créer une nouvelle figure avant chaque nouveau graphe. Vous pouvez éventuellement donner en
argument de cette fonction un numéro associé à la fenêtre. Vous pourrez plus tard revenir à cette fenêtre en
retapant la même commande avec le même numéro, et modifier ainsi plusieurs fenêtres à tour de rôle.
Ligne 2 : le graphe Il s’agit de la commande la plus importante (en effet, pour les minimalistes, il est
possible de créer un graphe avec uniquement cette ligne de code) : on plot les valeurs contenues dans y (les
ordonnées) en fonction de celles contenues dans le vecteur x (les abscisses). En fait, Matlab ne fait que tracer
les points contenus dans les vecteurs en les reliant ensuite un à un par une droite. Il est donc important que
les éléments contenus dans le vecteur abscisse soient ordonnés : sinon Matlab va tout mélanger.
Ligne 3 et 9 : la commande hold On souhaite parfois afficher plusieurs couples de données sur un même
graphe, ce qui est possible grâce à la commande hold 16 . Celle-ci, une fois activée par une commande hold on,
indique à Matlab que tous les plot suivant se feront par-dessus le dernier plot réalisé, sans l’effacer. On arrête
ensuite le hold avec hold off. Notons aussi qu’on a rajouté ici une couleur au second plot, pour différencier
les deux courbes. On verra cela en détail dans la sous-section suivante.
Ligne 5, 6 et 7 : Le titre, les axes Cela devrait être assez explicite, ce sont les commandes pour mettre
un titre au graphe et pour commenter les axes (attention à ne pas oublier d’en profiter pour donner les
unités !).
Ligne 8 : la légende Dans le cas de plusieurs courbes sur un seul graphe comme ici, il est quand même
relativement pratique de savoir à quelles données correspond chaque courbe : cette commande-ci permet de
rajouter le cadre en haut à droite 17 qui permet de différencier les courbes. On lui donne en argument les
noms à donner aux courbes dans l’ordre dans lequel elles ont été plottées.
15. Si aucune fenêtre pouvant accueillir des graphes n’est ouverte, Matlab en créera une nouvelle.
16. Il est aussi possible d’afficher plusieurs groupes de données en un seul plot en écrivant par exemple plot(x,y,x,z).
17. Si la position ne convient pas (par exemple, ici, elle gêne la lecture de la courbe de la population de koalas), il est possible
de changer sa position en rajoutant des arguments. Voir la doc pour plus d’informations.
26
4.2
Plein d’options pour faire joli
Une fois votre graphe de base crée, vous avez à votre disposition une tonne d’option pour modifier son
apparence comme bon vous semble. Une simple recherche sur la doc permet de trouver rapidement ce que
vous recherchez, mais voici un aperçu (loin d’être exhaustif) des possiblités.
La fonction plot est extrêmement riche, et possède de très nombreuses options. Les deux dernières
lignes illustrent l’usage de cette fonction avec des options permettant de modifier l’apparence des courbes.
Nous vous invitons à consulter la documentation (http://www.mathworks.nl/help/matlab/ref/plot.
html) pour plus d’informations.
1
2
3
4
5
6
7
8
9
10
11
xlim ([0 10]) ;
% Change les limites du graphe : ici on affiche
uniquement les abscisses entre 0 et 10
ylim ([ -10 10]) ;
% On affiche que les ordonnees entre -10 et 10
loglog (x , y ) ;
% Equivalent a plot , mais x et y seront affiches en
echelle logarithmique
semilogx (x , y ) ;
% Ici , seul x sera en echelle logarithmique
semilogy (x , y ) ;
% A vous de decouvrir
stem (x , y ) ;
% graphe en batonnets ( pour donnees discretes )
plot (x ,y , ’ Color ’ , ’r ’) ;
% On donne une couleur au plot , ici rouge ( Red
) = > ’r ’
plot (x ,y , ’ LineStyle ’ , ’ -- ’) ; % Le trait de la courbe dessinee sera en
pointilles
Une dernière option est assez utile et est assez particulière : parfois, on souhaite avoir plusieurs graphes
l’un à côté de l’autre (pour les comparer par exemple). La commande subplot est parfaite pour ça : elle
permet de créer un "quadrillage" (non visible), dont chaque case peut accueilir un graphe. Elle prend en
entrée 3 arguments : le nombre de lignes du quadrillage, le nombre de colonnes et l’emplacement dans le
quadrillage ou le prochain plot sera effectué (les "cases" sont numérotées de gauche à droite puis de haut en
bas). Un exemple vaut mieux qu’un long discours :
1
2
3
4
5
6
7
8
9
x = linspace (0 , 1 , 1000) ;
figure () ;
subplot (3 ,2 , 1) ;
% 3 lignes , 2 colonnes , case 1
plot (x , x .^2) ;
subplot (3 ,2 , 4) ;
% case 4 ( deuxieme ligne deuxieme colonne )
plot (x , x .^3) ;
subplot (3 ,2 , 5) ;
% case 5 (3 eme ligne , 1 ere colonne )
plot (x , sqrt ( x ) ) ;
title ( ’ Exemple ␣ ultra ␣ stupide ’) ; % ATTENTION : le title ne s ’ applique qu ’
au subplot courant !
27
1
0.5
0
0
0.5
1
1
0.5
0
0
0.5
1
Exemple ultra stupide
1
0.5
0
0
0.5
1
Figure 3 – Le résultat du code d’exemple.
4.3
Exporter votre chef-d’oeuvre
Dans la fenêtre créée lors d’une commande figure ou plot, vous avez à votre disposition des tas de jolis
boutons rigolos qui permettent de faire plein de manipulations diverses sur votre figure (par exemple, zoomer
sur une partie intéressante) que nous vous laissons explorer (vous devriez vous en rendre compte petit
à petit, le logiciel Matlab possède (à l’instar du language Matlab) des milliards d’options, et quand on
pense commencer à connaître, on découvre un nouveau menu avec dix mille nouveaux boutons. . . il serait
extrêmement fastidieux d’en faire le tour). Il est extrêmement pratique de pouvoir sauver l’image d’un graphe
(pour le mettre dans votre joli rapport par exemple), ce qui se fait bêtement via "File > Save As", ou vous
choisirez votre format préféré (Dans ce document, nous utilisons le format EPS, qui s’intègre très bien dans
les documents LATEX).
4.4
A trois variables : les surfaces et les courbes de niveau.
Deux dimensions, c’est bien pour afficher des fonctions à une variable. Trois dimensions, c’est mieux
pour les fonctions à deux variables. Matlab propose plusieurs façons de visualiser un tel type de données
tridimensionnel.
4.4.1
Les courbes de niveau : contourf
Sans surprise, cette fonction permet de créer une représentation type "courbes de niveau" de données à
deux variables (les données seront donc stockées dans une matrice plutôt que dans un vecteur unidimensionnel).
contourf(x,y,z,k) crée, à la manière d’un plot, une nouvelle fenêtre avec k courbes de niveau des données
contenues dans z (une matrice n ∗ m) en fonction des variables x (de taille m : l’axe x correspond donc aux
colonnes de z) et y (de taille n).
4.4.2
Les courbes 3-D : surf et plot3
Il existe aussi des fonctions pour avoir un véritable graphe en 3 dimensions.
28
surf(x,y,z) permet de créer la surface 18 formée par la donnée z en fonction des variables x et y. Son
fonctionnement est tout à fait similaire à celui de contourf, le résultat final sera juste en trois dimensions
plutôt que deux.
plot3(x,y,z) quant à elle fonctionne de manière très similaire à plot (d’où le nom) mais avec une variable en
plus. Concrètement, Matlab relie dans une image 3D les points de l’espace (x(1), y(1), z(1)), (x(2), y(2), z(2))...
Les superpouvoirs de Matlab : ode45, le calcul symbolique, . . .
5
Maintenant que vous êtes devenus des Dieux du calcul numérique, que les vecteurs et les graphes n’ont
plus de secret pour vous, il est temps de vous dévoiler les superpouvoirs de Matlab , les arcanes ultimes qui
vont rendre votre vie plus facile (surtout si vous avez à résoudre régulièrement des équations différentielles
ordinaires). Ce chapitre est présent à titre strictement indicatif, pour les étudiants qui voudraient en savoir
plus.
5.1
Résoudre des équations différentielles ordinaires plus vite que son ombre
Bien que le cours de méthodes numériques soit essentiellement destiné à, précisément, résoudre des EDO,
on s’aperçoit surtout très vite que ce n’est pas si simple que ça (d’ailleurs, on fait toujours Euler Explicite
quand doit résoudre des EDO, parce que c’est la seule méthode vraiment super facile à implémenter et à
retenir). Heureusement, Matlab contient un outil formidable de résolution d’EDO : la sacro-sainte fonction
ode45 (pour Ordinary Differential Equations 45 ).
C’est en tapant help ode45 dans la commande qu’on se dit vite que l’outil doit en effet être très puissant, vu
la quantité de texte qui s’affiche. La page de la documentation (http://www.mathworks.nl/help/matlab/
ref/ode45.html) est encore plus complète, et plus agréable à lire. Nous nous limiterons dans ce texte à un
usage assez limité (mais déjà plus que suffisant, je vous rassure !) de la fonction, qui permet de faire vraiment
plein de choses. Pour ceux que ça intéresse, ode45 utilise une méthode explicite adaptative appelée méthode
de Dormand-Prince 19 (Ce n’est pas une blague !), de la famille des méthodes de Runge-Kutta (d’ou le 45 :
on combine ici une méthode d’ordre 4 et une méthode d’ordre 5).
5.1.1
Que fait vraiment ode45 ?
ode45 résoud l’équation différentielle ordinaire classique u (t) = f(t, u(t)), pour une fonction f et une
condition initiale donnée, sur un intervalle de temps donné. Attention, la fonction f peut être vectorielle,
c’est-à-dire de R × Rn −→ Rn (concrètement, elle accepte comme arguments un scalaire, le temps, et un
vecteur, et retourne un vecteur).
La fonction retourne deux vecteurs, appelés TOUT et YOUT dans l’aide de Matlab , qui contiennent
respectivement les temps et les valeurs de la solution en ces temps (notez que ce deuxième vecteur est. . . une
matrice, puisqu’il contient une liste de valeurs vectorielles). Le nombre de temps dépend entre autres de la
stiffness (raideur) du problème. Il est possible d’obliger à Matlab de ne retourner les valeurs qu’en certains
temps spécifiés.
Précision des résultats : ode45 possède deux options, RelTol et AbsTol, qui définissent les tolérances d’erreur commise respectivement relativement (10−3 par défaut) et absolument sur chaque composante du vecteur de retour (un vecteur aux composantes initialisées à 10−6 par défaut). Les réglages
par défaut sont un bon compromis entre efficacité et précision, et il n’est pas, en général, nécessaire ou
recommandé de les modifier.
18. D’où le nom surf (rien à voir avec le sport donc).
19. Kids, don’t try this at home : http://en.wikipedia.org/wiki/Dormand%E2%80%93Prince_method
29
5.1.2
Quels arguments donner à ode45 ?
Dans sa version la plus simple, la fonction admet trois arguments :
1. ODEFUN La fonction f(t, x) de l’EDO. Celle-ci doit être passée en argument sous forme d’une function
handle. En pratique, il suffit de mettre une arobase (@) devant le nom de la fonction, et le tour est joué. Il
est aussi possible d’utiliser des fonctions anonymes, de la forme @(< arguments >) < expression >. Par
exemple, une fonction a deux arguments calculant le cosinus du premier et le sinus du deuxième s’écrirait :
1
@ (x , y ) [ cos ( x ) sin ( y ) ]
Attention, si l’argument x de la fonction est un vecteur (autrement dit, si la solution est une fonction à valeur
vectorielles), la valeur retournée doit être un vecteur de même taille !
2. TSPAN L’intervalle de temps sur lequel résoudre l’EDO. Cet argument peut prendre deux formes :
1. un vecteur a deux éléments contenant le début et la fin de l’intervalle, le plus petit élément étant
considéré comme le début. Ainsi, [0, 1] et [1; 0] donnent les mêmes résultats. ode45 retourne alors la
valeur de la solution en des points compris dans cet intervalle et en les bornes. C’est la méthode la
plus efficace.
2. un vecteur contenant plus de deux éléments. Les valeurs de la solution sont alors calculées exclusivement en ces points (la fonction ne retourne pas de points intermédiaires). C’est donc l’équivalent de
l’évaluation de la solution en une série de temps donnés.
3. Y0 La solution initiale, autrement dit la valeur de la solution en le plus petit point de l’intervalle. Si la
solution est une fonction à valeur vectorielle, alors cette solution initiale doit être un vecteur de même taille
que la solution (évidemment), et que le second argument et la valeur de retour de ODEFUN.
5.1.3
Comment utiliser les valeurs de retour ?
Si vous ne récupérez pas explicitement la valeur de retour d’ode45 (si vous ne définissez pas une variable
égale à la sortie), la fonction dessine automatiquement la solution en fonction du temps dans la dernière
figure créée (ou en crée une au besoin) ! Ce comportement par défaut est extrêmement pratique, et est
suffisant, dans la plupart des cas.
Si vous désirez récupérer explicitement les temps et valeurs de la solution en ces temps, il faut utiliser
deux valeurs de retour (appelées TOUT et YOUT dans la documentation) :
1
[ TOUT , YOUT ] = ode45 (...) ;
Format de YOUT : En raison du caractère vectoriel de la solution, YOUT est une matrice. Chaque
colonne de la matrice correspond au valeurs d’une composante de la solution en fonction du temps. Pour
accéder à la valeur de (toutes les composantes de) la solution en l’instant t, qui correspond au ni`eme
élément de TOUT, on utilise donc le code :
1
y_en_t = YOUT (n ,:) ;
Il est intéressant de noter que ces deux lignes sont équivalentes (ou ODEFUN, TSPAN et Y0 ont été
correctement définis au préalable), à l’exception que la seconde stocke les valeurs de retour dans les vecteurs
t et y :
1
2
ode45 ( ODEFUN , TSPAN , Y0 ) ; % comportement par defaut
[t , y ] = ode45 ( ODEFUN , TSPAN , Y0 ) ; plot (t , y ) ; hold on ; plot (t , y , ’o ’) ;
30
Si on stocke la valeur de retour dans une seule variable, la fonction retourne une structure, qui contient
beaucoup plus d’informations (comme le nombre de pas), mais ceci dépasse du cadre de ce document.
5.1.4
Un exemple : le pendule amorti
Afin de terminer cette section sur ode45, utilisons cette fonction pour résoudre une des équations les plus
célèbres de la mécanique, celle du pendule amorti :
θ (t) = −
g
· θ(t) − λθ (t)
L
Le coefficient λ correspond au coefficient de frottement dans l’air, g est l’accélération de la pesanteur et L
la longueur de la corde du pendule.
Notre but est de réaliser une fonction qui affiche θ(t), pour un temps correspondant à 4 périodes (en
faisant l’approximation qu’une période est de durée 2π Lg ), pour une position initiale correspondant à un
angle initial de 90◦ à droite et une vitesse initiale nulle. Les paramètres de cette fonction correspondront aux
trois paramètres de l’équation.
Tout d’abord, il faut transformer l’équation actuelle du second ordre en équation vectorielle du premier
ordre. Cela se fait en posant u1 = θ et u2 = θ . On a alors :

u (t) =
u2 (t)


 1
u2 (t) = − Lg u1 (t) − λ · u2 (t)
u1 (0) =
π/2



u2 (0) =
0
La fonction ODEFUN s’écrit donc, si g, lambda et L sont définis dans son environnement 20 :
1
2
3
function dudt = odefun (t , u )
dudt = [ u (2) ; -g / L * u (1) - lambda * u (2) ];
end
On peut donc écrire le code de la fonction pendulum comme ceci :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
function pendulum (g , L , lambda )
% fonction qui trace la solution a l ’ equation du pendule
% arguments : ( gravite , longueur , frottement )
function dudt = ODEFUN (t , u ) % acces aux arguments possible ici
dudt = [ u (2) ; -g / L * u (1) - lambda * u (2) ];
end
TSPAN = [0 , 4 * 2* pi * sqrt ( L / g ) ]; % de 0 a 4 periodes
Y0 = [ pi /2 , 0]; % vitesse initiale nulle
[t , u ] = ode45 ( @ODEFUN , TSPAN , Y0 ) ;
% on affiche uniquement la position ( pas la vitesse angulaire )
plot (t , u (: ,1) ) ; hold on ; xlim ( TSPAN ) ;
title ( ’ angle ␣ du ␣ pendule ␣ en ␣ fonction ␣ du ␣ temps ’) ;
end
La figure 4 ci-dessous montre un exemple d’exécution.
20. Matlab supporte les variables contextuelles : toutes les variables définies avant une fonction dans le même bloc de code
sont accessibles depuis cette fonction.
31
angle du pendule en fonction du temps
2
1.5
1
0.5
0
−0.5
−1
−1.5
0
1
2
3
4
5
6
7
8
Figure 4 – Résultat pour pendulum(9.81, 1, 0.8) ;
5.2
Calculer symboliquement mieux que vous
Le calcul symbolique, c’est l’ordinateur au service du mathématicien : pas pour l’aider dans ce qu’il ne sait
pas faire (par exemple, mille itérations de Runge-Kutta 4), mais dans ce qu’il sait très bien faire, autrement
dit, faire de l’analyse. En d’autres termes, manipuler des fonctions exactes, analytiques (avec une formule,
comme en maths), afin de pouvoir les dériver et les intégrer de façon analytique.
L’idée essentielle est de définir une ou plusieurs variables symboliques, variables qui ne prendront pas
une seule valeur comme c’était le cas jusqu’à présent : il s’agira de variables au sens mathématique, pouvant
prendre toutes les valeurs réelles. On les définit en faisant syms <variable>. Toute variable définie en fonction
d’une variable symbolique est une variable symbolique (y = 2 * x). Ensuite, on peut traiter la variable déclarée
symbolique (ici x) telle quelle dans tous les calculs possibles et imaginables.
Avant d’aller plus loin, il faut préciser que le calcul symbolique de Matlab a ses limites. Il n’a pas la
meilleure réputation dans le monde académique pour multiples raisons, dont par exemple sa lenteur. Si, par
exemple, vous devez employer la dérivée d’une fonction complexe dans votre code, il vaut mieux la calculer
à part et copier le résultat dans le code plutot que de la calculer à chaque appel de la fonction. . . De plus, si
vous cherchez un logiciel spécialisé dans le calcul symbolique, il vaut mieux se tourner vers Mathematica 21
ou Maple 22 . De toute façon, il vaut mieux faire les calculs à la main quand ils sont faisables en plus, cela
permet d’avoir un double-check.
Voici un exemple d’usage du calcul symbolique :
1
2
3
EDU > > syms x
EDU > > disp ( sqrt ( 4* x ^2 ) )
2*( x ^2) ^(1/2)
% le calcul symbolique dans toute sa splendeur
Pour calculer la dérivée d’une fonction (par exemple la terrible fonction f (x) = x2 ), il suffit d’utiliser
diff :
21. http ://www.wolfram.com/mathematica/
22. http ://www.maplesoft.com/
32
1
2
EDU > > disp ( diff ( x ^2) )
2* x
% qui l ’ eut cru ?
Plus sérieusement, vous l’aurez deviné, diff(fonction,variable) permet de dériver l’expression fournie en
premier argument par rapport à la variable fournie en second (non donnée dans l’exemple mais il n’y avait
qu’une variable donc Matlab a deviné tout seul comme un grand).
Il est également possible d’intégrer symboliquement, toujours aussi facilement :
1
2
EDU > > disp ( int ( x ^2)
x ^3/3
Il existe beaucoup d’options qui s’ouvrent à vous, même si la différenciation et l’intégration sont les
opérations les plus courantes. Matlab factorise, simplifie, et bien d’autres choses encore. Comme cela sort
légèrement du cadre du cours, à vous de découvrir tout cela par vous-mêmes.
5.3
S’amuser avec Matlab
Matlab, à l’instar de nombreux logiciels (en particulier le moteur de recherche Google) possède des Easter
Eggs, autrement dit des petites blagues, qui font souvent référence à la culture populaire. . . Les Easter Eggs
changent d’une version à l’autre, donc il est possible que quelques unes de ces perles ne fonctionnent pas
chez vous (hélas).
Nous remercions Antoine de Comité de nous avoir initié aux fonctionnalités ludiques de Matlab.
5.3.1
Les petites blagues de Matlab
Les fonctions sans arguments Quelques unes des fonctions de base de Matlab (qui sont utiles en vrai)
ont un comportement spécial si on ne leur donne pas d’arguments. . . En particulier, essayez avec spy (oui
oui, le spy qui affiche les matrices !) et image. Dans la catégorie image, penny vous montre un cent américain
en 3D ! Pour un logo Matlab en 3D, essayez surf(membrane), ou plus simplement logo.
Un peu d’aide philosophique La fonction why vous fournit des excuses. Elle sélectionne une excuse
aléatoire, sauf si vous spécifiez un numéro.
De la musique ! Les instructions successives load handel et sound(y, Fs) ; jouent un célèbrissime morceau
de musique (c’est mon Easter Egg préféré, personnellement).
5.3.2
Oubliez Steam : jouer avec Matlab
Derrière ce titre un peu racoleur, se cache une réalité : Matlab regorge de petits jeux cachés. Bon, d’accord,
ça ne vaut pas un Zelda ou un League of Legends, mais il y a peut-être moyen de tenter de s’amuser !
Les jeux stars de votre nouvelle console de jeux sont au nombre de trois : xpbombs, life et fifteen ! Bon
amusement !
(Plus sérieusement, il parait qu’il est possible de développer un jeu en Matlab, mais bon, franchement,
est-ce que ça en vaut la peine ? ;-)
33

ww ~m ~m - Mathizi

PDF (510.3 KB) - MATEC Web of Conferences

TP 1 : Corrigé - Mathématiques en ECE 2

2015_2016_TS__DNS_9_corrige

TD 2014

Transformations de Householder

JM`10 - Ecole Militaire Polytechnique

Mais qui vit là ?

Développement de systèmes paramétriques physiques pour l

Document 5414552

Physique - Saints-Coeurs Tripoli

Bac blanc obligatoire – Spécialité . TS2. Lycée Moissan

Biologie - Saints-Coeurs Tripoli

République Tunisienne Ministère de l`Enseignement Supérieur et