Module AP-45 : Outils informatiques

Polycopié du Cours : Initiation à Matlab

M. Heyouni1

1. ENSA d'Al-Hoceima, Université Mohammed Premier, Oujda.

Email : mohammed.heyouni@gmail.com
Ch 1 : Présentation de Matlab.

1.1. Introduction.

Matlab est un logiciel commercial de calcul numérique spécialisé dans le calcul matriciel. Ce logiciel est un
système interactif qui peut être utilisable comme une « super calculette » et qui dispose d’un grand
nombre de fonctions, d’un langage de programmation et d’outils de visualisation graphique.
Le logiciel Matlab est développé par la société MathWorks depuis 1984. Le nom Matlab provient de
l’abréviation en Anglais de « Matrix laboratory ». Tous les objets en jeu sont des matrices, y compris les
scalaires (matrices 1×1). De nombreuses bibliothèques (toolboxes) complètent le noyau de base. Les
domaines d’applications sont nombreux : mathématiques appliquées, statistiques, analyse numérique,
automatique, traitement du signal et des images, etc. Des produits concurrents et libres existent
également, comme Scilab ou Octave.

1.2. Les premier pas avec Matlab.

Lorsqu’on lance Matlab, nous sommes en présence de l’invite de commande (ou d’instruction) qu’on
appelle prompt : >>

Cela indique que le logiciel Matlab est prêt à recevoir nos instructions. Commençons alors par quelques-
unes comme celles-ci-dessous :

>> 1+1
 ans =

Remarque : Tout ce qui vient après le symbole % est un commentaire.

La réponse fournie est bien sûr 2 et nous concluons également que Matlab a affecté le résultat de notre
instruction à une variable appelée ans ! (ans pour dire answer qui veut dire réponse !)

Si on veut que le résultat de notre instruction soit affecté à une variable dont nous voulons fixer nous
même le nom, on procède de la façon suivante

>> som=1+1 >> som=1+1; % ici le résultat n’est pas affiché

% vu que on a mis un ; après l’instruction !
som =
>> alpha=sqrt(-1) % ici le résultat est affiché
2 % car il n’y a pas de ; après l’instruction !

>> alpha=sqrt(-1)
alpha =
alpha =
0.0000 + 1.0000i
0.0000 + 1.0000i

Au cours des chapitres suivants, nous reprendrons et développerons plus en détail d’autres exemples
d’instructions.

1.3. Accès à l’aide en ligne.

Etant donné le nombre important de fonctions (dites encore commandes) présentes dans Matlab, il est
fortement conseillé d’apprendre à utiliser l’aide en ligne de Matlab ! A noter, aussi qu’il faut également
savoir se débrouiller avec la langue de Shakespear.

Supposons pas exemple que l’on veuille déterminer les valeurs propres d’une matrice, on peut alors utiliser
la commande lookfor suivie du mot eigenvalues (qui veut dire valeurs propres en Anglais)
>> lookfor eigenvalues
eigshow - Graphical demonstration of eigenvalues and singular values.
expmdemo3 - Matrix exponential via eigenvalues and eigenvectors.
condeig - Condition number with respect to eigenvalues.
eig - Eigenvalues and eigenvectors.
ordeig - Eigenvalues of quasitriangular matrices.
ordqz - Reorder eigenvalues in QZ factorization.
ordschur - Reorder eigenvalues in Schur factorization.
qz - QZ factorization for generalized eigenvalues.
eigs - Find a few eigenvalues and eigenvectors of a matrix
dsort - Sort complex discrete eigenvalues in descending order.
esort - Sort complex continuous eigenvalues in descending order.
drum1 - One of the two model files, which solves the eigenvalues for two isospectral
drum2 - One of the two model files, which solves the eigenvalues for two isospectral
pdeeigx - Exact calculation of eigenvalues for a 2-by-2 matrix.
Après une rapide lecture, on s’aperçoit que la fonction Matlab recherchée est soit eig ou eigs. Pour avoir
plus de détails sur l’une de ces deux fonctions il suffit d’utiliser l’aide en ligne via la commande help comme
ci-dessous :

>> help eig

eig Eigenvalues and eigenvectors.
E = eig(A) produces a column vector E containing the eigenvalues of
a square matrix A.

[V,D] = eig(A) produces a diagonal matrix D of eigenvalues and

a full matrix V whose columns are the corresponding eigenvectors
so that A*V = V*D.

…. etc.

E = eig(A,B) produces a column vector E containing the generalized

eigenvalues of square matrices A and B.

… etc.

See also condeig, eigs, ordeig.

Other functions named eig

Reference page in Help browser

doc eig

En parcourant les informations fournies par Matlab, on voit qu’effectivement c’est la fonction eig qui va
nous permettre de calculer les valeurs propres d’une matrice donnée. On remarque également qu’il y’a
plusieurs façons d’utiliser cette fonction. Ainsi :

 si on ne veut que les valeurs propres, on écrira : >> E = eig(A). Les valeurs propres seront alors
stockées dans un vecteur colonne E.
 si on veut en même temps les valeurs et vecteurs propres, on écrira : >> [V, D] = eig(A). Dans ce
cas, les valeurs propres correspondent aux éléments diagonaux de la matrice D et les vecteurs
propres vont être stockés dans les colonnes de la matrice V.
 …

 Si on cherche à résoudre un problème généralisé de valeurs propres ou interviennent deux

matrices A et B, on utilisera plutôt l’instruction : >> E = eig(A,B) …

La commande help propose également d’autres fonctions en rapport avec la fonction recherchée. Dans le
cas ci-dessus, on peut se référer également aux fonctions condeig, eigs, ordeig.

A noter que si on tape simplement la commande help, on obtient une longue liste de sujets.

>> help
HELP topics:

matlabhdlcoder\matlabhdlcoder - (No table of contents file)

matlabxl\matlabxl - (No table of contents file)
matlab\demos - Examples.
matlab\graph2d - Two dimensional graphs.
matlab\graph3d - Three dimensional graphs.
….
 …. % Dans la version Matlab 2015, il y’a environ 500 sujets !
….
build\xpcblocks - (No table of contents file)
build\xpcobsolete - (No table of contents file)
xpc\xpcdemos

Pour avoir plus de détails sur un sujet donné on doit le préciser (ou simplement cliquer sur le sujet (lien
hypertext présent dans les récentes versions de Matlab), on obtient alors une suite de sous sujets, …etc.
Ainsi, si par exemple, on veut s’informer sur le sujet graphisme 2D « graph2d » (4ème sujet de la liste
précédente affichée ci-dessus), il suffit de taper :

>> help matlab\graph2d

Two dimensional graphs.

Elementary X-Y graphs.

plot - Linear plot.
…
plotyy - Graphs with y tick labels on the left and right.

Axis control.
axis - Control axis scaling and appearance.
….
subplot - Create axes in tiled positions.

Graph annotation.
plotedit - Tools for editing and annotating plots.
….
gtext - Place text with mouse.

Hardcopy and printing.

print - Print graph or Simulink system; or save graph to MATLAB file.
printopt - Printer defaults.
orient - Set paper orientation.

See also graph3d, specgraph.

A noter que dans les versions récentes de Matlab, l’aide en ligne peut être également consulté à l’aide
d’une interface graphique. Ainsi, pour obtenir des détails sur la fonction eig, il suffit d’utiliser la case
« Search Documentation » (qu’on peut repérer à l’aide d’une loupe dans le coin droit supérieure de la
fenêtre principale de Matlab.
1.4. Historique des commandes.

Pour gagner du temps et ne pas avoir à retaper des commandes ou instructions qu’on aurait saisies
auparavant, le logiciel Matlab dispose d’une fonctionnalité très utile. En effet, au cours d’une session
donnée, toutes les commandes qu’on aurait pu taper peuvent être retrouvées et rééditées grâce aux
touches de direction. Plus précisément, on appuiera sur la touche ⇑ (haut) pour remonter dans les
commandes précédentes, sur la touche ⇓ (bas) pour redescendre et on utilisera les touches ⇒ (droite), ⇐
(gauche), et/ou la touche «Backspace» pour rééditer une commande. Enfin, pour relancer une
commande, il est inutile de remettre le curseur à la fin, on se contentera d’appuyer directement sur la
touche «Entrée».
On peut également retrouver toutes les commandes commençant par un groupe de lettres. Ainsi, pour
retrouver par exemple toutes les commandes commençant par plot, on tape plot puis on appuie plusieurs
fois sur ⇑.
Ch 2 : Calculs élémentaires, fonctions élémentaires prédéfinies.

2.1 Calculs élémentaires.

Les opérations et calculs élémentaires si font à l’aide des opérateurs classiques : + (addition), -
(soustraction), * (multiplication), / (division), ^ (puissance). Les parenthèses s’utilisent également de
manière classique. Comme cela a été déjà signalé, si on ne précise pas la variable à laquelle va être affectée
le résultat de notre calcul, ce résultat sera affecté automatiquement à la variable ans. Nous rappelons
également que par défaut les calculs se font en double précision et que le résultat sera affiché avec 5
chiffres significatifs. Si on veut avoir un autre affichage, on utilisera les instructions, format short, format
long, format short e, format long e, … etc.

Exemple : Si 𝑛 = 10, 𝑥 = 1.205 , alors pour calculer

𝑛𝑥 𝑛(𝑛 − 1)𝑥 2
𝛼 =1+ + ,
5 7
on doit procéder ainsi :

>> n = 10 ; x = 1.205 ; alpha = 1+(n*x)/5 + (n*(n-1)*x^2)/7

alpha =

22.0789

>> format long

>> alpha

alpha =

22.078892857142858

Tous d’abord, nous signalons qu’il suffit de mettre un ; (point-virgule) après une instruction si l’on souhaite
éviter l’affichage des résultats de cette instruction. Nous ajoutons également qu’un des avantages de
travailler avec un logiciel interactif est que nous obtenons une réponse immédiate. Notons également un
avantage par rapport aux langages classiques tels que Fortran ou C/C++ puisqu’il n’a pas été nécessaire de
déclarer le type ou la taille des variables n, x, et alpha.

A noter que le nombre complexe i (i2 = 1) est prédéfini en Matlab et est stocké dans les deux variables i et
j. Nous faisons aussi remarquer que i et j sont des variables et que leur contenu peut être changé. C’est
aussi le cas des variables : pi, eps, realmin, realmax, inf et nan.

pi 3.1416
i, j Nombres complexes tels que i2=1, (i=j)
eps Précision du type à virgule flottante (eps = 2.2204e-16)
realmin Valeur minimale à virgule flottante (realmin = 2.2251e-308)
realmax Valeur maximale à virgule flottante (realmax = 1.7977e+308)
inf Infini, (réponse donnée si division par zéro)
nan Nombre nvalide = Not-a-number, (réponse donnée si division 0/0 ou Inf-Inf par exemple)
Dans les deux instructions ci-dessous, nous utilisons la fonction Matlab rand pour affecter une matrice
carrée aléatoire de taille 3 x 3 à la variable A, puis nous utilisons une autre fonction prédéfinie det pour
calculer le déterminant de la matrice A et l’affecter à la variable a.

>> A = rand(3) % on affecte à A une matrice carrée aléatoire de taille 3.

A =

0.814723686393179 0.913375856139019 0.278498218867048

0.905791937075619 0.632359246225410 0.546881519204984
0.126986816293506 0.097540404999410 0.957506835434298

>> a = det(A) % on calcule le déterminant de la matrice A (qu’on affecte à la variable

a)

a =

-0.276653966272994

Les instructions ci-dessus nous donnent l’occasion de faire remarquer que Matlab fait la distinction entre
MAJUSCULES et minuscules et de rappeler que Matlab dispose de fonctions prédéfinies sur lesquelles nous
reviendrons plus tard.

A l’aide des instructions ci-dessous, on liste quelles sont les variables mémorisées par Matlab puis on
vérifie, ce que contiennent ces variables :

>> whos % pour lister les variable mémorisées par matlab

Name Size Bytes Class Attributes

A 3x3 72 double
a 1x1 8 double
alpha 1x1 8 double
n 1x1 8 double
x 1x1 8 double

>> format short, A, a

A =

0.8147 0.9134 0.2785

0.9058 0.6324 0.5469
0.1270 0.0975 0.9575

a =

-0.2767

On remarque ainsi que Matlab non seulement liste le contenu de la mémoire mais donne également
d’autres informations qui sont :

 Le nom de la variable.
 La taille de la variable (nous rappelons que chaque variable est représentée par Matlab à l’aide
d’une matrice).
 La taille en « Bytes » de la variable mémorisée.
 La classe de la variable (dans l’exemple : un nombre réel double précision)
  Les attributs (ou caractéristiques) de la variable utilisé.

Nous faisons remarquer également que l’on peut modifier le format d’affichage des variables en utilisant
l’instruction format. Les exemples ci-dessous expliquent l’usage de cette commande.

Format par défaut : format Format long

>> format long
>> pi >> pi

ans = ans =
3.1416 3.141592653589793

>> eps >> eps

ans = ans =
2.2204e-16 2.220446049250313e-16

Format short e Format long e

>> format short e >> format long e
>> pi >> pi

ans = ans =
3.1416e+00 3.141592653589793e+00

>> eps >> eps

ans = ans =
2.2204e-16 2.220446049250313e-16

On notera que le format d’affichage n’affecte en rien la manière dont sont effectués les calculs réalisés
par Matlab.

Nous terminons cette partie consacrée aux premiers pas avec Matlab en insistant sur les points suivants :

 En Matlab, une variable est créée dès qu’elle est utilisée. On n’est pas obligé de la déclarer comme
dans d’autres langages de programmation (Fortran, C/C++, …).
 Dans le cas où une variable du même nom existe déjà, son contenu est remplacé par la nouvelle
valeur. (Attention : il convient de ne pas créer une variable qui porte le même nom qu’une
fonction !).
 L’affectation se fait à l’aide du symbole = (et non pas := comme avec MAPLE).
 Si on ne précise pas la variable à laquelle va être affecté le résultat d’une instruction, alors par
défaut le calcul sera affecté à la variable ans.
 Le résultat de tout calcul ou affectation dans une instruction est affiché sauf si cette instruction
est suivie d’un ;
 Matlab fait la distinction entre MAJUSCULES et minuscules.
 Le premier caractère d’une variable doit être une lettre. Le nom d’une variable peut contenir des
lettres, chiffres, tirets-bas.
 Les variables i, j, pi, eps, realmax, realmin, inf, nan sont déjà affectées. Cependant, on peut
réaffecter les variables i et j. (Conseil : il vaut mieux ne pas réaffecter les autres variables
prédéfinies)
 La commande format permet de modifier l’affichage du format des différentes variables utilisées
lors d’une session de Matlab.
  Les commandes who, whos permettent de lister l’ensemble des variables actives (utilisées) et de
donner des informations sur ces variables.
 La commande clear efface le contenu de tous les variables utilisées.

2.2 Fonctions élémentaires prédéfinies.

Matlab dispose de toutes les fonctions mathématiques élémentaires classiques. Il dispose également de
fonctions moins classiques. Comme le type de base d’une variable est le nombre complexe, la plupart de
ces fonctions peuvent être appliquées à des nombres complexes.

Ci-dessous, un tableau contenant une liste non exhaustive de ces fonctions :

Fonctions élémentaires Fonctions Matlab

Trigonométriques cos, sin, tan, cot, …
Trigonométriques réciproques acos, asin, atan, acot, …
Hyperboliques cosh, sinh, tanh, coth, …
Hyperboliques réciproques acosh, asinh, atanh, acoth, …
Exponentiel et logarithme exp, log, log10, …
Racine carrée, valeur absolue, signe et factoriel sqrt, abs, sign, factorial
Modulo, reste, arrondir, partie entière, … mod, rem, round, floor, ceil, fix.
pour manipuler les nombres complexes abs, complex, real, imag, conj, …

Matlab dispose également d’autres fonctions « non élémentaires » telles que celles de Bessel (besselj,
bessely, besseli, besselk, besselh, … etc). De plus, la notion de fonction est plus générale et certaines
fonctions peuvent avoir plusieurs entrées et/ou plusieurs sorties.
Ch 3 : Manipulation de tableaux (vecteurs et matrices).

3.1 Vecteurs.

Pour définir un vecteur, on peut utiliser l’une des deux syntaxes suivantes :

>> u = [1, 6, 1/4, -5, 45, -14], v = [2; -5; 6; 5-1/8; 17] % u est un vecteur ligne et
v est un vecteur colonne

u =
1.0000 6.0000 0.2500 -5.0000 45.0000 -14.0000

v =
2.0000
-5.0000
6.0000
4.8750
17.0000

Vous aurez remarqué que l’on n’a pas été obligé de déclarer la taille des deux vecteurs u et v et que
certaines composantes de ces deux vecteurs ont étés calculées lors de l’affectation (u3 = 1/4 = 0.25 et v4 =
5-1/8 = 4.875). Les composantes sont séparées par des blancs (non recommandé) ou de préférence par
des virgules pour les vecteurs lignes et par des points-virgules pour les vecteurs colonnes.

Ci-dessous quelques opérations élémentaires sur les vecteurs :

>> p=[1,2,-5,15,0]; q=[-5,8,4,1,-4];

>> s=p+q % s est la somme des deux vecteurs p et q
s =
-4 10 -1 16 -4

>> p(3) % pour accéder à la composante 3 de p

ans =
-5

>> t=p*q
Error using *
Inner matrix dimensions must agree.

>> t=p.*q % t est le produit « composante par composante » des deux vecteurs p et q
t =
-5 16 -20 15 0

>> t=p/q % l’op. / ne permet pas de faire la division d’un vecteur par un vecteur !
% t=p/q signifie que t = [(pT*p)-1*p]*q
t =
0.0492

>> t=p./q % t est le quotient « composante par composante » des deux vecteurs p et q
t =
-0.2000 0.2500 -1.2500 15.0000 0

>> r=q./p % r est le quotient « composante par composante » des deux vecteurs q et p
r =
-5.0000 4.0000 -0.8000 0.0667 -Inf

>> p.^2 % chaque composante de p est élevée au carrée

ans =
1 4 25 225 0
 >> p^2
Error using ^
Inputs must be a scalar and a square matrix.
To compute elementwise POWER, use POWER (.^) instead.

>> sp=sqrt(p), cq=cos(q)

sp =

1.0000 + 0.0000i 1.4142 + 0.0000i 0.0000 + 2.2361i 3.8730 + 0.0000i

0.0000 + 0.0000i

cq =

0.2837 -0.1455 -0.6536 0.5403 -0.6536

Ainsi, on voit que pour appliquer la même opération élémentaire sur chacune des composantes d’un
vecteur ou entre les composantes des deux vecteurs, on doit mettre un point devant l’opération voulue.
De même, si on applique une fonction élémentaire à un vecteur, cette fonction est alors appliquée sur
chacune des composantes.

Nous donnons ci-dessous quelques exemples commentés

>> a=-1:0.5:3 % vecteur a incrément constant, l’incrémentation étant de 0.5

a=
-1.0000 -0.5000 0 0.5000 1.0000 1.5000 2.0000 2.5000 3.0000

>> a26=a(2 :6), % on affiche les composantes 2, 3, 4, 5 et 6 de a !

a26 =
-0.5000 0 0.5000 1.0000 1.5000

>> ap=a(2 :2 :end), % on affiche les composantes paires de a !

ap=
-0.5000 0.5000 1.5000 2.5000

>> b=zeros(1,4), c = ones(1,3), d = 10*ones(1,3) % vecteur ne contenant que des 0 (ou 1) !

b=
0 0 0 0
c=
1 1 1
d=
10 10 10

On utilise la fonction prédéfinie ones (respectivement zeros) pour créer un vecteur dont toutes les
composantes valent 1 (respectivement valent 0). On doit alors spécifier le nombre de composantes ! Ainsi :

 ones(n,1) crée une vecteur colonne ayant n composantes toutes égales à 1, (idem pour zeros).
 ones(1,n) crée une vecteur ligne ayant n composantes toutes égales à 1, (idem pour zeros).
 rand(n,1) (respectivement rand(1,n)) crée une vecteur colonne (respectivement ligne) de taille n
dont toutes les composantes sont aléatoires et uniformément distribuées entre 0 et 1.
Pour obtenir les vecteur transposé ou trans-conjugué d’un vecteur donné, on utilise respectivement les
deux caractères : .’ (point-apostrophe) ou le caractère : ’ (apostrophe) comme illustré ci-dessous :

>> v = [1, 2-i, 13+2*i], u = [2 ; 11+3*i; 2*i-3]

v =
1.0000 + 0.0000i 2.0000 - 1.0000i 13.0000 + 2.0000i

u =
2.0000 + 0.0000i
11.0000 + 3.0000i
-3.0000 + 2.0000i

>> tcv = v', tcu = u', tv = v.', tu = u.', % tc pour trans-conjugué et t pour transposé
tcv =
1.0000 + 0.0000i
2.0000 + 1.0000i
13.0000 - 2.0000i

tcu =
2.0000 + 0.0000i 11.0000 - 3.0000i -3.0000 - 2.0000i

tv =
1.0000 + 0.0000i
2.0000 - 1.0000i
13.0000 + 2.0000i

tu =
2.0000 + 0.0000i 11.0000 + 3.0000i -3.0000 + 2.0000i

Remarque : pour un vecteur x à composantes réelles, les instructions x’ et x.’ sont similaires !

Il est également possible d’accoler des vecteurs comme le montre les instructions suivantes :

>> a = 1 : 5, b = 10:10:50 % dans a, on incrémente par 1 (par défaut) et dans b, on

incrémente par 10
a =
1 2 3 4 5

b =
10 20 30 40 50

>> c = [a, b] % on accole les vecteurs a et b (idem que c = [a b])

c =
1 2 3 4 5 10 20 30 40 50

>> d = [a(5:-1:1), b(2:2:end)] % à vous de deviner ce qui a été effectué !

d =
5 4 3 2 1 20 40

Remarque : Les chaînes de caractères se manipulent comme des vecteurs. Elles sont déclarées avec des
guillemets simples ’ comme le montre les instructions suivantes :

>> r = 'nhar zin, mchemesse !' % Belle journée ensoleillée

r =
nhar zin, mchemesse !

>> r(5)
 ans =

>> r(6)

ans =
z

>> r(9)

ans =
,

>> r(end)

ans =

3.2 Matrices.

Opérations élémentaires sur les matrices : Pour définir une matrice, on procède comme pour les vecteurs
en utilisant l’une des deux syntaxes suivantes :

>> A = [1, 2, 3 ; 4, 5, 6] % les lignes sont séparées par un point-virgule

A =
1 2 3
4 5 6

>> B = [7, 8, 9 % on revient à la ligne lorsque on a fait entrer une ligne donnée !
10, 11, 12
-1, -2, -3]

B =
7 8 9
10 11 12
-1 -2 -3

>> A(2,2)+B(2,3),

ans =
17

Dans la première instruction, on a séparé les 2 lignes de la matrice A par une ; (point-virgule) et les
éléments de chaque ligne de A par une , (virgule) (ou par des espaces, mais cela n’est pas recommandé)
Dans la deuxième instruction, on a séparé les 3 lignes de la matrice B par une un retour à la ligne (retour-
chariot). Pour accéder à l’élément (i,j) d’une matrice, on doit indiquer l’ ligne puis

Lorsque les dimensions le permettent, les opérations matricielle élémentaires peuvent être réalisées à
l’aide des opérateurs : + (addition), – (soustraction), * (multiplication de deux matrices ou d’une matrice
par un vecteur), ^ (puissance d’une matrice). Nous rappelons que comme pour les vecteurs, si les
opérateurs *, / et ^ sont précédés par un . (point) (c'est-à-dire, si on utilise les opérations : -* , ./ ou .^)
alors les opérations *, / et ^ sont appliquées aux composantes des deux matrices. Pour s’en convaincre,
observez les exemples ci-dessous :
 >> som = A+A

som =
2 4 6
8 10 12

>> prod_elt = A.*A

prod_elt =
1 4 9
16 25 36

>> A^2 % Noter que la matrice A n’est pas carrée !

Error using ^
Inputs must be a scalar and a square matrix.
To compute elementwise POWER, use POWER (.^) instead.

>> BB = B^2 % La matrice B est carrée !

BB =
120 126 132
168 177 186
-24 -24 -24

>> BB_elt = B.*B

BB_elt =
49 64 81
100 121 144
1 4 9

>> BB_elt = B.*B, onretrouveB = BB_elt./B

BB_elt =
49 64 81
100 121 144
1 4 9
onretrouveB =
7 8 9
10 11 12
-1 -2 -3

>> pr_BA = B*A

Error using *
Inner matrix dimensions must agree.

>> pr_AB = A*B

pr_AB =
24 24 24
72 75 78

Les opérateurs / (division matricielle à droite) ainsi que l’opérateur \ (division matricielle à gauche)
correspondent respectivement à une multiplication par une matrice inverse à droite et à une multiplication
par une matrice inverse à gauche, i.e., A/B = A*B-1 et A\B = A-1*B.

Remarque : Souvent (en analyse numérique par exemple), on a besoin de déterminer la solution x du
système linéaire A*x = b, où A et b sont respectivement une matrice et un vecteur données. Il est évident
qu’on peut déterminer cette solution en écrivant : >> x = A\b. Nous faisons remarquer que même si la
division matricielle à droite x = A\b est équivalente à x = A-1*b = inv(A)*b (où inv est la fonction Matlab
qui détermine l’inverse d’une matrice inversible), il est préférable d’utiliser x = A\b au lieu de x = inv(A)*b.
En effet, d’une part on évite de calculer l’inverse d’une matrice qui généralement est une opération
couteuse en termes de nombre d’opérations (surtout pour les matrices de grande taille), d’autre part
l’opération A\b (est basée sur la méthode de Gauss pour la résolution d’un système linéaire) est plus stable
et donne généralement de meilleurs résultats que l’opération x = inv(A)*b.

Matrices et sous matrices : Il est souvent utile d’extraire des blocs d’une matrice (ou d’un vecteur) donnée.
Dans ce cas on peut utiliser le caractère : en indiquant pour chaque indice (qu’il soit un indice de ligne ou
un indice de colonne) la valeur de début et la valeur de fin. Les instructions ci-dessous illustrent différents
exemple d’extraction de sous-matrices

>> A = rand(5,10) % on crée une matricé aléatoire de taille 5 x 10

A =
0.8147 0.0975 0.1576 0.1419 0.6557 0.7577 0.7060 0.8235 0.4387 0.4898
0.9058 0.2785 0.9706 0.4218 0.0357 0.7431 0.0318 0.6948 0.3816 0.4456
0.1270 0.5469 0.9572 0.9157 0.8491 0.3922 0.2769 0.3171 0.7655 0.6463
0.9134 0.9575 0.4854 0.7922 0.9340 0.6555 0.0462 0.9502 0.7952 0.7094
0.6324 0.9649 0.8003 0.9595 0.6787 0.1712 0.0971 0.0344 0.1869 0.7547

>> B = A(2:4,1:2:end) % B est formée de l’intersection des lignes 2, 3 et 4 et colonnes

impaires de A

B =
0.9058 0.9706 0.0357 0.0318 0.3816
0.1270 0.9572 0.8491 0.2769 0.7655
0.9134 0.4854 0.9340 0.0462 0.7952

>> b = B(2,:) % on affiche le vecteur ligne formé de la deuxième ligne de B

b =
0.1270 0.9572 0.8491 0.2769 0.7655

>> A789 = A(:,7:9) % on affiche la matrice formée des colonnes 7, 8 et 9 de A

A789 =
0.7060 0.8235 0.4387
0.0318 0.6948 0.3816
0.2769 0.3171 0.7655
0.0462 0.9502 0.7952
0.0971 0.0344 0.1869

On peut également, à condition que les dimensions des tableaux le permettent, former à partir de
« petites » matrices une plus « grande » matrice comme c’est le cas dans l’exemple suivant :

Soient N une matrice de taille p x q, u et v deux vecteurs lignes de taille q et p respectivement et

𝛼 un scalaire réel (ou complexe). Les instructions ci-dessous permettent de créer la matrice

𝑁 𝑣
𝑀=( ).
𝑢 𝛼
>> N = [1, 2, 3 ; 4, 5, 6 ; 7, 8, 9], u = [-10, -20, -30], v = [-40, -50, -60],
alpha = 100, M = [N, v' ; u, alpha],
N =
1 2 3
 4 5 6
7 8 9

u =
-10 -20 -30

v =
-40 -50 -60

alpha =
100

M =
1 2 3 -40
4 5 6 -50
7 8 9 -60
-10 -20 -30 100

3.3 Quelques fonctions utiles pour manipuler les tableaux.

Dans cette section, nous listons et décrivons quelques fonctions qui souvent très utiles pour manipuler les
tableaux (vecteurs ou matrices) :

 La fonction size appliquée à un tableau donne la taille de ce tableau. Appliquée à une matrice ou
un vecteur, cette fonction renvoie un vecteur ligne formé de deux entiers : le premier est le
nombre de lignes, le second correspond à celui des colonnes.
 La fonction length appliquée à une matrice donne la taille maximale de ce tableau. On préférera
donc la fonction length à la fonction size lorsque le tableau est un vecteur !
 La fonction flipud (flip up-down) appliquée à une matrice A ayant n lignes renvoie la matrice B
dont la ligne k de B correspond à la ligne n-k+1 de A. (flipud = inverser de haut en bas).
 La fonction fliplr (flip left-right) appliquée à une matrice A ayant n colonnes renvoie la matrice B
dont la colonne k de B correspond à la colonne n-k+1 de A. (fliplr = inverser de gauche à droite).
 La fonction rot90 appliquée à un tableau le fait tourner de 90° dans le sens trigonométrique.
 La fonction reshape appliquée à un tableau change la forme de ce tableau (une matrice de taille
m x n peut être changée en une matrice de taille p x q du moment que m x n = p x q, si non un
message d’erreur est affiché.
 La fonction diag appliqué à un vecteur u de taille n crée une matrice diagonale dont les coefficients
diagonaux sont ceux du vecteur u. Si cette fonction est appliquée à une matrice A quelconque, on
obtient un vecteur dont les composantes sont les coefficients de la diagonale de A.
 La fonction tril (tri pour triangular, l pour lower) appliquée à une matrice A génère une matrice
triangulaire inférieure formée par la partie triangulaire inférieure de A (y compris la diagonale).
 La fonction triu (tri pour triangular, u pour upper) appliquée à une matrice A génère une matrice
triangulaire supérieure formée par la partie triangulaire supérieure de A (y compris la diagonale).
 Les fonctions zeros et ones permettent de créer respectivement des tableaux ne contenant que
des 0 ou des 1.
 La fonction eye permet de créer une matrice diagonale unité (ne contenant que des 1).
 La fonction max/min : Pour un vecteur, cette fonction détermine la plus grande/petite
composante d’un vecteur. Pour une matrice A, cette fonction renvoie un vecteur contenant
l’élément maximal/minimal de chaque colonne de A.
  La fonction mean/median détermine la valeur moyenne/médiane des coefficients de la matrice
(ou vecteur) donnée en paramètre.
 La fonction sum/prod détermine la somme/le produit des coefficients de la matrice (ou vecteur)
donnée en paramètre.
 La fonction sort : appliquée à un vecteur, cette fonction trie les coefficients de ce vecteur dans in
ordre croissant. Dans le cas d’une matrice, la fonction sort est appliquée sur chaque vecteur
colonne de cette matrice.
 … etc.

3.4 Quelques fonctions d’algèbre matricielle.

Pour obtenir la liste des fonctions prédéfinies qu’on peut appliquer à une matrice, il suffit d’utiliser l’aide
en ligne en tapant par exemple : >> help matfun.

Dans la suite, nous donnons une liste non exhaustive des principales fonctions Matlab utilisé en algèbre
linéaire :

 Norm (Matrix or vector norm) : calcule la norme d’une matrice ou d’un vecteur.
 rank (Matrix rank) : calcule le rang d’une matrice.
 det (Determinant) : calcule le déterminant d’une matrice.
 trace (Sum of diagonal elements).
 null (Null space) : détermine le noyau d’une matrice (noyau = Ker).
 orth (Orthogonalization) : forme une base orthogonal de l’image de d’une matrice (image = Im).
 inv (Matrix inverse) : calcule l’inverse d’une matrice.
 chol (Cholesky factorization) : détermine la décomposition de Cholesky d’une matrice.
 lu (LU factorization) : détermine la décomposition LU ou PLU d’une matrice.
 ldl (LDLT factorization) : détermine la décomposition LDLT d’une matrice.
 qr (QR factorization) : détermine la décomposition QR d’une matrice.
 eig (Eigenvalues and eigenvectors) : détermine les valeurs/vecteurs propres d’une matrice.
 svd (Singular value decomposition) : détermine la décomposition en valeurs singulières.
 Eigs (A few eigenvalues) : détermine quelques valeurs propres (utile pour de matrices creuses).
 Poly (Characteristic polynomial) : détermine le polynôme caractéristique d’une matrice.
 Expm (Matrix exponential) : détermine l’exponentiel d’une matrice.
 … etc.
Ch 4 : Programmation avec Matlab.

4.1. Structures de contrôle

Commençons par donner un aperçu sur la syntaxe des opérations logiques :

 égalité  ==
 différent  ~=
 supérieur strictement (inférieur strictement)  > ( < )
 supérieur ou égal (inférieur ou égal)  >= ( <= )
 et logique  && (ou &). (on préfèrera utiliser && car plus économique voir help)
 ou logique  || (ou |). (on préfèrera utiliser || car plus économique voir help)
 négation  not

Maintenant, nous abordons la syntaxe des tests :

 concernant la syntaxe du si … alors sinon …, il y’a 3 façons :

if (test ou expression 1 à tester)

if (test ou expression à tester)
suite instructions à exécuter
si expression est vraie
end
if (test ou expression à tester)
suite instructions 1 à exécuter
si expression est vraie
else
suite instructions 2 à exécuter
si expression est fausse
end
suite instructions 1 à exécuter
si expression 1 est vraie
elseif (test ou expression 2 à tester)
suite instructions 2 à exécuter
si expression 2 est vrai
else
suite instructions 3 à exécuter
si expression 2 est fausse
end

Exemple :

>> A=rand(3); B=rand(2,3);

if ( size(A) == size(B) )
disp('la somme de A et B est :') % l’instruction disp sert à afficher le texte
entre ‘ et ‘
somme = A+B;
else
disp('taille A # taille B')
end
taille A # taille B
  De façon équivalente au langage C, on peut également utiliser le switch-case (choix ventilé) :

switch var
case const1,
séquence d’instructions 1
case const 2,
séquence d’instructions 2
…
case constN,
séquence d’instructions N
otherwise
séquence d’instructions par défaut
end

où

 var est une variable numérique ou une variable chaîne de caractères ;

 const1, ..., constN sont des constantes numériques ou des constantes chaîne de caractères ;
 séquence d’instructions k est la séquence d'instructions à exécuter si le contenu de la
variable var est égal à la constante constk (var == constk).

Exemple :

>> n = input('Entrer un nombre: '); % la commande input sert à lire une variable
tapée au clavier (lecture à l’écran)
Entrer un nombre: -1
>> switch n
case -1
disp('minus one, i.e., -1')
case 0
disp('zero, i.e., 0')
case 1
disp('plus one, i.e., +1')
otherwise
disp('other value')
end
minus one, i.e., -1

 concernant la syntaxe des boucles Pour … ainsi que tant que … :

Boucle pour Boucle Tant que

for indice = debut : pas : fin while condition
suite d’instructions séquence d’instructions
end end

où

 indice est une variable appelée indice de la boucle,

 debut et fin sont deux constantes réelles (appelées paramètres de la boucle);
  suite d'instructions est le traitement à effectuer pour les valeurs d'indices variant entre
debut et fin avec une incrémentation égale à pas. On parle du corps de la boucle.
 condition est une expression dont le résultat peut être vrai ou faux,
 séquence d'instructions est le traitement à effectuer tant que condition est vraie.

Remarques :
 Si le pas n’est pas précisé, par défaut il vaut 1.
 Pour sortir d’une boucle ou d’un test, on utilise l’instruction break (voir help).

Exemples : les 2 exemples ci-dessous montre comment calculer n ! (avec n=4) en utilisant une boucle
« for » ou une boucle « while »

On fait remarquer que pour calculer n !, il vaut mieux utiliser l’instruction factorial(n) ou encore prod(1 :n).

>> n = 4; >> n = 4;
>> nfac = 1; >> k = 1; nfac = 1;
>> for k = 1:n >> while k <= n
nfac = nfac*k; nfac = nfac*k;
end k = k+1;
>> nfac end
nfac = >> nfac
24 nfac =
24

Remarque : Afin d’éviter qu’un code Matlab soit lent et pour gagner du temps CPU, il faut éviter le plus
possible les boucles dans les programmes. Pour s’en convaincre, examinons l’exemple suivant qui montre
que le code à gauche donne un résultat immédiat tandis que le code à droite qui utilise une boucle for est
relativement plus lent !

>> x=rand(1,100000) ; y=rand(1,100000) ;

>> x=rand(1,100000) ; y=rand(1,100000) ; >> tic % initialise le temps
>> tic % initialise le temps for i=1 :100000 ;
maxdif = max(x-y) ; dif(i) = x(i)-y(i) ;
toc % affiche le temps écoule end ;
Elapsed time is 0.004099 seconds. maxdif = max(dif) ;
toc % affiche le temps écoule
Elapsed time is 0.047698 seconds.

4.2. Lecture et sauvegarde des données

En programmation, on a souvent besoin de lire des données à partir d’un fichier ou d’enregistrer des
données dans un fichier. Le but de cette section est de vous montrer comment cela peut être réalisé sous
Matlab.

Commençons tout d’abord par rappeler qu’un format est une chaine de caractères spécifiant en lecture le
type de données à lire et que les formats généralement utilisés sont :
  ’%d’ pour un entier
 ’%f’ pour un réel
 ‘%e’ pour un réel flottant (de la forme … xxx. xxx e+xx ou … xxx. xx e-xx ).
 ’%c’pour un caractère.

Afin d’afficher des résultats d’un calcul sur l’écran, il suffit simplement de taper le nom de la variable (ou
des variables) sans la (les) faire suivre d’un ; (point-virgule). Si on veut un format plus lisible, en particulier,
pour afficher plusieurs variables sur la même ligne, on peut utiliser la commande fprintf, comme dans
l’exemple ci-dessous :

>> a=eps; b=pi; c=123456789; d = -123.4567;

>> fprintf('a = %e, a = %f, b = %f, b = %e, c = %d et d = %e \n',a,b,c,d); % \n pour

un retour a la ligne
a = 2.220446e-16, a = 0.000000, b = 3.141593, b = 3.141593e+00, c = 123456789 et d =
-1.234567e+02

>> fprintf('a = %3.2e, b = %5.4f, c = %7.0d et d = %7.2f \n',a,b,c,d);

a = 2.22e-16, b = 3.1416, c = 123456789 et d = -123.46

Soit nom_fichier.txt un fichier dans lequel on a sauvegardé des données numériques et dans lequel chaque
nombre est séparé du précèdent par un espace ou par un retour à la ligne. Pour lire ces données
numériques, on procède comme suit en utilisant la commande dlmread (On pourra obtenir plus de détails
en utilisant l’aide)

Fichier : nom_fichier.txt Code matlab

123 4567 89101 >> M = dlmread('nom_fichier.txt')
6.78 910 -1112 -13141 7
541 M =
0.1 0.2 0.3
123 4567 89101 0 0
6.78 910 -1112 -13141 7
541 0 0 0 0
0.1 0.2 0.3 0 0

Remarques :
 L’exemple précédent montre que, au niveau de la ligne 4 du fichier nom_fichier.txt, le premier
nombre considéré par Matlab est 541 et non pas 0. En effet, l’espace en début de la ligne 4 n’est
pas pris en compte par Matlab et n’est pas considéré comme un 0. Par défaut, Matlab a enregistré
les données numériques du fichier nom_fichier.txt dans une matrice 4 lignes et 5 colonnes. Le
nombre 0 a été affecté par défaut aux entrées non précisées de cette matrice.
 La commande inverse de dlmread est la commande dlmwrite qui permet d’écrire une matrice
dans un fichier, la syntaxe générale étant dlmwrite(monFichier, maMatrice)
 La fonction fopen permet l'ouverture d’un fichier, les différentes permissions autoriseront soit la
lecture, soit l'écriture, soit les deux. La syntaxe la plus générale étant :
fid = fopen(monFichier, <permission>);
 L’usage de la fonction fopen implique obligatoirement la fermeture du fichier une fois les
opérations effectuées dessus terminées, et ceci avec la commande fclose(fid).
 Il existe d’autres commande commandes de lecture (ou écriture) d’un fichier (dans un fichier)
comme par exemple : textscan, fread, fgetl, … etc. Le lecteur intéressé par ces fonctions pourra
consulter l’aide de Maple ou les différents forums présents sur le web.
 Nous terminons cette section en énumérant d’autres commandes qui permettent soit de sauvegarder
les variables enregistrées en mémoire soit de les charger si elles ont été précédemment sauvegardées.

 save(’monfichier’) enregistre toutes les variables dans le fichier monfichier.mat (format

Matlab par défaut);
 save(’ monfichier’,var1,var2,...) enregistre seulement les variables spécifiées.
 load(’monfichier’) charge toutes les variables du fichier monfichier.mat.
 fload(’monfichier.mat ’,var1,var2,...) charge seulement les variables spécifiées.

4.3. Environnement de travail, programmes d’appel et fonctions.

En tant que nouvel utilisateur de Matlab, vous allez vite vous rendre compte que l’’utilisation d’instructions
dans la fenêtre de commandes Matlab (command window) n’est pas très pratique et est limitée. En effet,
la façon la plus convenable consiste à écrire des programmes d’appel que Matlab pourra ensuite exécuter
comme des commandes prédéfinies. De même, afin de disposer de programmes modulaires, vous allez
également vous apercevoir qu’il est pratique de créer ses propres fonctions ?

Avant d’expliquer plus en détails le fonctionnement des programmes d’appel et des fonctions, nous
devons indiquer à Matlab où se trouvent les différents fichiers relatifs à ces programmes et fonctions.

4.3.1. Environnement et répertoire de travail.

Pour que Matlab retrouve les scripts ou fonctions que nous avons-nous même créées, nous pouvons
utiliser les commandes d’environnement suivantes :

 path : permet de savoir quels sont les dossiers auxquels Matlab a accès et d’ajouter de nouveaux
dossiers où se trouvent les nouveaux programmes d’appel ou les nouvelles fonctions. Pour
référencer un nouveau dossier, on pourra taper : addpath /NDossier ce qui indique à Matlab qu’il
peut trouver de nouveaux scripts et/ou de nouvelles fonctions dans le dossier /NDossier.
 cd : cette commande permet de nous positionner dans un dossier donné, par exemple : cd
/NDossier. De cette façon, Matlab utilisera en priorité les programmes d’appels et fonctions se
trouvant dans le dossier courant.
 ls (ou dir) permet lister les différents fichiers du répertoire courant.

4.3.2. Programmes d’appel (scripts)

Il arrive souvent qu’on soit amenés à écrire plusieurs lignes de commandes et d’avoir à répéter l’exécution
de ces commandes soit au cours de la même session de travail ou soit bien plus tard (le lendemain, un
mois plus tard ou …). Pour ne pas avoir à réécrire ces commandes, on a la possibilité d’éditer un fichier
dans lequel seront écrites ces commandes. Un tel fichier s’appelle un script ou encore un programme
d’appel ou encore programme principal. Ce fichier devra être enregistré sous le nom de votre choix mais
obligatoirement avec l’extension .m, par exemple test.m. Pour écrire ce fichier, on peut utiliser l’éditeur
de Matlab auquel on accède en se servant des icônes de la fenêtre principale de Matlab.

Afin d’exécuter les différentes instructions ou commandes que nous avons écrites dans le fichier test.m, il
suffit de taper dans la fenêtre de commandes : >> test
On s’aperçoit ainsi de l’avantage de travailler de cette façon. En effet, en cas d’erreur dans une des
instructions présentes dans le fichier test.m, il n’est pas nécessaire de tout retaper : il suffit de corriger
cette erreur et de relancer la commande : >> test bien sur après avoir fait une nouvelle sauvegarde du
fichier test.m.

Nous terminons cette section en faisant remarquer que les scripts sont exécutés séquentiellement dans le
« workspace », et de ce fait ils peuvent accéder aux variables qui s’y trouvent déjà, les modifier
éventuellement ou bien en créer d’autres, … etc.

4.3.3 Fonctions rédigées par l’utilisateur.

Notons tout d’abord que le concept de fonction en Matlab ressemble à celui d’autres langages de
programmation. A la différence des scripts qui permettent simplement de mémoriser une suite de
commandes, une fonction Matlab est un script qui peut recevoir des arguments d’entrée, et peut
retourner des arguments de sortie. Notons qu’afin de préciser les paramètres d’entrée et de sortie -et de
différentier une fonction d’un programme d’appel- le fichier contenant une fonction définie par un
utilisateur doit obligatoirement commencer par le mot « function ». Ci-dessous, nous précisons les 3
principaux points à respecter lors de l’écriture d’une fonction.

function [s1, s2, ..., sn] = notrefonction(e1,e2, ..., ep)

%
% commentaires décrivant ce que fait notrefonction
%
…
Séquence d’instructions
…..

Les paramètres d’entrée étant e1, e2, …, ep, et les paramètres de sortie étant s1, s2, …, sn. De plus, le
fichier dans lequel a été rédigée notrefonction doit obligatoirement être enregistré sous l’appellation
notrefonction.m. A noter que les paramètres d’entrée –et également ceux de sortie- peuvent être des
scalaires, vecteurs, ou matrices. Notez également qu’il est conseillé de rédiger et placer des commentaires
immédiatement après la première ligne (de déclaration de la fonction). De cette façon, on pourrait
retrouver ce que fait notre fonction en tapant la commande : >> help notrefonction

Nous terminons cette section en précisant que :

 La valeur des variables d’entrée ne peut pas être modifiée à l’intérieur du corps de la fonction.
 On doit affecter une valeur à chaque variable de sortie de la fonction.
 Les variables locales utilisées à l’intérieure de la fonction sont des variables temporaires. Elles
n’ont de sens qu’à l’intérieur de la fonction et ne sont plus reconnues à l’extérieur de la fonction.

Dans la suite, nous terminons cette partie en donnant quelques conseils à respecter lors de la rédaction
d’un script ou d’une fonction :

 Dans la mesure du possible, écrire une seule instruction par ligne.

  Ne pas donner à une fonction ou à un script le nom d’une fonction Matlab. Sinon, ce fichier
d’instructions remplacera la fonction Matlab pour la suite de la session de travail.
 Commentez vos programmes d’appels et vos fonctions. Egalement, aérez vos fichiers en laissant
des lignes vides.
 Dans le cas où une instruction est trop longue pour tenir sur une seule ligne, on peut se continuer
sur une nouvelle ligne (ou plusieurs). Il suffit pour cela de taper ··· (3 points consécutifs sans rien
derrière) à la fin d’une ligne pour indiquer que l’instruction se poursuit sur la ligne suivante.

4.4. Exemples de programmes et de fonctions.

Maintenant, nous allons voir quelques exemples de fonction et programmes d’appel.

Exemple 1.
La fonction ci-dessous décrit une fonction appelée suite_spe qui prend un nombre n en argument et
renvoie le vecteur ligne (1,2, ..., n), lorsque n est positif ou le vecteur ligne (–n, -(n-1), ... 0) si n est négatif.

Fonction Matlab : suite_spe

%
% Usage : u = suite_spe(n)
% En entree
% n : une entier
% En sortie
% u : vecteur, u = [1,2,...,n], si n > 0,
% u = [-n,-(n-1), ..., 0], si n <= 0.
%
% Voir Ex 1 du polycopie Matlab, chapitre 4.
%

if n > 0
u = 1:n;
else
u=n:0;
end

end

Exemple 2.
Ecrire une fonction insertion qui prend en entrée 2 scalaires alpha, beta et un vecteur x et qui renvoie
en sortie les 2 vecteur s= (x1, alpha, x2, alpha, …, xn-1, alpha, xn ), t = (beta, -xn, beta, ..., -x2, beta, -x1)
ainsi que la matrice M = (s, 0)T*t.

Fonction Matlab : insertion

function [s, t, M] = insertion(alpha,beta,X)

%
% Usage : [s, t, M] = insere(alpha,X)
% En entree
% alpha, beta : scalaires
% X : un vecteur (x_1, x_2, ..., x_n).
% En sortie
% s : vecteur, s = [x_1, alpha, x_2, alpha, ..., x_(n-1), alpha, x_n)].
% t : vecteur, t = [beta, -x_n, beta, ..., -x_2, beta, -x_1].
 % M : Matrice, M = Matrice [s, 0]'*t.
%
% Voir Ex 2 du polycopie Matlab, chapitre 4.
%

n = length(X); n2 = 2*n;
s = alpha*ones(1,n2-1); t = beta*ones(1,n2);

s(1:2:n2-1)= X;
t(2:2:n2) = -fliplr(X);
M = [s, 0]'*t;
end

Exemple 3.
Ecrire un programme d’appel pour tester les 2 fonctions suite_spe et insertion.

apEx1_2 :
Programme d’appel pour tester les fonction suite_spe et insertion

clear all, format short

%
% Programme d'appel pour tester les fonctions :
% SUITE_SPE et INSERE relatives aux exemples 1 et 2
% du cours de l'element de module :
% AP45-2 : outils informatique (Matlab)
% %
% Programme d'appel pour tester les fonctions :
% SUITE_SPE et INSERE relatives aux exemples 1 et 2
% du cours de l'element de module :
% AP45-2 : outils informatique (Matlab)
%

n = input('entrer n = ');

disp(' le vecteur SUITE SPECIALE est :')

disp('********************************')
x = suite_spe(n),

u = input('entrer 2 scalaires mu et rho (entre [ et ]) = ');

mu = u(1); rho = u(2);

disp(' ')
disp(' les vecteurs et la matrice INSERE sont :')
disp('*****************************************')
[y, z, A] = insertion(mu,rho,x),

Ci-dessous le résultat d’exécution avec les variables : n = 4, alpha = rho = 0.1 et beta = mu = 0.2.

>> apEx1_2
entrer n = 4
le vecteur SUITE SPECIALE est :
********************************

x =
 1 2 3 4

entrer 2 scalaires mu et rho = [0.1 0.2]

les vecteurs et la matrice INSERE sont :

*****************************************

y =

1.0000 0.1000 2.0000 0.1000 3.0000 0.1000 4.0000

z =

0.2000 -4.0000 0.2000 -3.0000 0.2000 -2.0000 0.2000 -1.0000

A =

0.2000 -4.0000 0.2000 -3.0000 0.2000 -2.0000 0.2000 -1.0000

0.0200 -0.4000 0.0200 -0.3000 0.0200 -0.2000 0.0200 -0.1000
0.4000 -8.0000 0.4000 -6.0000 0.4000 -4.0000 0.4000 -2.0000
0.0200 -0.4000 0.0200 -0.3000 0.0200 -0.2000 0.0200 -0.1000
0.6000 -12.0000 0.6000 -9.0000 0.6000 -6.0000 0.6000 -3.0000
0.0200 -0.4000 0.0200 -0.3000 0.0200 -0.2000 0.0200 -0.1000
0.8000 -16.0000 0.8000 -12.0000 0.8000 -8.0000 0.8000 -4.0000
0 0 0 0 0 0 0 0

Nous invitons le lecteur à observer que les commentaires rédigés en début des fonctions suite_spe,
insertion et du en début du programme d’appel apEx1_2 peuvent être retrouvés en utilisant la commande
help comme montré ci-dessous !

>> help apEx1_2

Programme d'appel pour tester les fonctions :
SUITE_SPE et INSERE relatives aux exemples 1 et 2
du cours de l'element de module :
AP45-2 : outils informatique (Matlab)
Voir Ex 3 du polycopie Matlab, chapitre 4.

>> help suite_spe

Usage : u = suite_spe(n)
En entree
n : une entier
En sortie
u : vecteur, u = [1,2,...,n], si n > 0,
u = [-n,-(n-1), ..., 0], si n <= 0.
Voir Ex 1 du polycopie Matlab, chapitre 4.

>> help insertion

Usage : [s, t, M] = insere(alpha,X)
En entree
alpha, beta : scalaires
X : un vecteur (x_1, x_2, ..., x_n).
En sortie
s : vecteur, s = [x_1, alpha, x_2, alpha, ..., x_(n-1), alpha, x_n)].
t : vecteur, t = [beta, -x_n, beta, ..., -x_2, beta, -x_1].
M : Matrice, M = Matrice [s, 0]'*t.
Voir Ex 2 du polycopie Matlab, chapitre 4.
Ch 5 : Graphisme avec Matlab

Matlab dispose de puissants outils et propose de nombreuses fonctions graphiques pour tracer des
courbes d’équation y=f(x) ou des surfaces d’équation z=f(x,y). Nous donnons ici les plus utilisées avec un
minimum d’explications. Pour plus de détails, on pourra utiliser la commande help.

5.1. Tracer une courbe.

La fonction plot permet de tracer une ou plusieurs courbes sur le même graphique. En spécifiant certains
paramètres de la fonction plot, on peut choisir le style du trait, sa couleur et éventuellement ajouter un
texte à un endroit donné du graphique.

Pour tracer les courbes représentatives des fonctions f(x)=cos(x)– sin(x) et g(x)=exp(-x^2)+x-1 sur
l’intervalle [-2π, 2π], on procède ainsi :

>> x = -2*pi:0.01:2*pi; % On génère une subdivision régulière de l’intervalle

>> y1 = sin(x)-cos(x);
>> y2 = exp(-x.^2)+x+1 ;
>> plot(x,y1,x,y2) % on trace y1 et y2 en function de x
>> title('courbes des fonctions y1 = sin(x)-cos(x) et y2 = exp(-x^2)+x+1') % on donne
un titre
>> xlabel('axe des x') % on écrit un label sur l’axe horizontal
>> ylabel('y = f(x)') % on écrit un label sur l’axe vertical
>> legend('courbe y1’,'courbe y2’); % on donne une légende à chaque courbe

Apparait alors la fenêtre suivante qui dispose d’une barre d’outils permettant de « customiser » notre
graphique :
 L’utilisation la plus simple de la commande plot est : >> plot(x), où x=[x1 x2, ..., xn] est un vecteur ligne
ou colonne. Dans ce cas, la fonction plot relie les points de coordonnées (i,xi).

 Une autre utilisation simple de la commande plot est : >> plot(x,y), où x=[x1 x2, ..., xn] est le vecteur
des abscisses et y=[y1 y2, ..., yn] est le vecteur des ordonnées. Dans ce cas, la fonction plot relie les
points de coordonnées (xi , yi). A noter que les vecteurs x et y doivent être de même dimension.

Ainsi, pour tracer sin(x) sur l’intervalle [0,2π], on commence par définir une séquence de valeurs
équidistantes sur cet intervalle (NB : le nombre de points de cette séquence doit être suffisant pour la
courbe soit tracée avec régularité) : >> x = 0:0.01:2*pi ; et comme la fonction sin peut s’appliquer
terme à terme au vecteur x, il suffit de faire : >> plot(x, sin(x)).

 Nous faisons remarquer que pour tracer par exemple la fonction exp(-x2)+x+1 en fonction de x, nous
avons dû utiliser l’opérateur .^ (point-chapeau) qui s’applique terme à terme au vecteur x. En effet, la
syntaxe : >> exp(-x^2)+x+1 n’aurait pas été acceptée !

 Pour différentier une courbe d’une autre, on peut imposer un style de ligne, un style de point, une
couleur, … etc. Ainsi, la commande : >> plot(x,y,’-r’,x,z’:g’) permet de tracer la courbe y avec un trait
continu plein et une couleur rouge ‘-r’ et de tracer la courbe z avec un trait en pointillés avec une
couleur verte ‘ :g’.

 Pour, ajouter une légende, un titre, un label sur un des axes, un texte à un endroit donné, on peut
utiliser les instructions : legend, title, xlabel, ylabel, text.

 Par défaut Matlab gère automatiquement la disposition et la taille des axes d’un graphe. Cependant,
afin de contrôler les axes et de recadrer le graphe, on peut utiliser l’instruction : >>
axis([xmin,xmax,ymin,ymax]).

 On utilise la commande : >> hold on ; pour superposer des courbes. Si non, par défaut la fenêtre
graphique est effacée avant chaque commande plot. Ainsi, le script suivant donnera la même figure
que celle donnée par le script précedent.

>> x = -2*pi:0.001:2*pi;
>> y1 = sin(x)-cos(x);
>> y2 = exp(-x.^2)+x+1;
>> plot(x,y1);

>> hold on

>> plot(x,y2)
>> title('courbe des fonctions y1=sin(x)-cos(x) et y2 = exp(-x^2)+x+1')
>> xlabel('axe des x')
>> ylabel('y = f(x)')
>> legend('courbe y1','courbe y2')
  Afin d’afficher plusieurs graphes dans une même fenêtre, on peut utiliser l’instruction : >>
subplot(l,c,i) qui découpe la fenêtre en un tableau de l lignes, c colonnes et sélectionne la i e case
pour afficher un graphe.

x = -2:0.1:2; x1 = -1:0.1:1;
y = sin(x); z = cos(x); t = 1+x-exp(-x.^2);
t1 = exp(-1./(1+x1.^2)); u1 = 1./(1+x1.^2); v1 = sqrt(1+x1.^3);

subplot(2,2,1)
plot(x,y,'o-r',x,z,'x-b',x,t,'*-g') % le 3eme parametres specifie le type
% de symbole et la couleur a utiliser pour chaque courbe
legend('sin(x)','cos(x)','1+x-exp(-x^2)')

subplot(2,2,2)
plot(x1,t1,'o:g',x1,u1,'+-.r',x1,v1,'*-b')
legend('exp(-1/(1+x^2))','1/(1+x^2)','exp(-x^2)')

subplot(2,2,3)
plot(x1,t1,'o--g',x,y-z,'+-.r')
legend('exp(-1/(1+x^2))','sin(x)-cos(x)')

subplot(2,2,4)
plot(x,y.*t,'o--b',x,z.*t,'+-.r')
legend('cos(x)*exp(-x^2)','sin(x)*exp(-x^2)')
  Il est à noter qu’à la place de l’opérateur ": " (utilisé pour créer le vecteur x), on peut utiliser la
commande linspace pour générer le nombre de points voulu dans un intervalle donné. En effet,
nous remarquons que si x=0 :2*pi, alors x(end) la dernière composante de x n’est pas égal à 2π.

>> x1 = 0:1:2*pi % ici on sait qua la distance entre les composantes de x est 1
mais combien a-t-on de points entre 0 et 2*pi?

x1 =
0 1 2 3 4 5 6

>> x2 = linspace(0,2*pi,7) % ici on sait qu’on en a 7, allant de 0 à 2*pi

x2 =
0 1.0472 2.0944 3.1416 4.1888 5.2360 6.2832

5.2. Tracer une courbe paramétrique, une surface.

5.2.1 Courbes paramétriques.

C’est la commande plot3 qui permet de tracer des graphiques tridimensionnels, de type paramétrique.
Ainsi, le script ci-dessous

t = linspace(0,4*pi,1000);
x = (1+t).*cos(2*t);
y = (1+t).*sin(2*t);
z = t;
plot3(x,y,z);
xlabel('(1+t).*cos(2*t)'), ylabel('(1+t).*sin(2*t)'), zlabel('t');
grid on;

Permet d’obtenir le graphe suivant :

5.2.2 Surfaces.

Une surface est définie par la donnée d’un triplé (X, Y, Z) où X = [Xi,j], Y = [ Yi,j] et Z = [Zi,j], (i=1, 2,
…, n et j=1, 2, …, m) sont respectivement appelés tableau d’abscisses, tableau d’ordonnées,
tableau de côtes. Nous faisons remarquer que souvent les points de (X, Y) tracent dans le plan un
maillage régulier mais ce n’est pas une obligation. La commande qui permet de tracer a la syntaxe
suivante : >> surf(X,Y,Z).

Pour tracer par exemple la surface d’équation :

z = f(𝑥, 𝑦) = √𝑥 2 + 𝑦 2

sur le pavé [a, b] x [c, d], on doit tout d’abord définir un quadrillage de ce pavé. Pour cela on génère
une subdivision (régulière) de x et de y. Par exemple : >> x=a :px:b ; y=x :py:d. Ensuite, on construit
les tableaux d’abscisses et d’ordonnées X et Y via l’instruction : >> [X, Y] = meshgrid (x,y). Pour
obtenir le tableau Z, il suffit de faire : >> Z = sqrt(X.^2+Y.^2);

Ainsi le script suivant

a=-2; b=2; px = 0.1;

c=-2; d=2; py = 0.2;
x=a:px:b;
y=c:py:d;
[X, Y] = meshgrid (x,y);
Z = sqrt(X.^2+Y.^2);
mesh(X,Y,Z)
donne

Et si on prend px = 0.01 ; py =0.02, on obtient

A noter qu’il existe d’autres commandes pour tracer des surfaces, les plus utilisées sont :
 mesh : elle permet de tracer une série de lignes entre les points de la surface en mode
«lignes cachées»
 meshc : elle fonctionne comme mesh mais ajoute en plus des courbes de niveau dans le
plan (x,y)
 surf : elle «peint» la surface avec une couleur fonction de la cote.
 surfl : elle «peint» la surface comme si elle était éclairée.
 Surfc : elle fonctionne comme mesh mais ajoute les courbes de niveau dans le plan (x,y).