Cours Matlab

Université Cadi Ayyad ‫جامعـة القاضـي عيـاض‬
Ecole Nationale des Sciences Appliquées ‫المدرسـة الوطنيـة للعلـوم التطبيقيـة‬

Safi ‫آسفــي‬
AU: 2016-2017
Cours: Outils informatiques

Pr. Ezzahar Jamal
Equipe de Mathématiques et Traitement de l’Information (MTI),

Ecole Nationale des Sciences Appliquées,
Université Cadi Ayyad, Safi, Morocco
Mail: j.ezzahar@uca.ma
Outils informatiques
Objectifs du cours :
✓ Apprentissage de la programmation avec Matlab

✓ Connaitre et savoir programmer les méthodes numériques classiques
utilisées dans le métier d’ingénieur
Plan du cours
 Chapitre 1: Introduction au calcul scientifique
 Chapitre 2: Présentation du Matlab
 Chapitre 3: Programmation sous Matlab
 Chapitre 4: Initiation au calcul Scientifique

Chapitre 1:
Introduction au calcul scientifique

Calcul numérique approché
Introduction
Les sciences font régulièrement appel aux mathématiques afin de modéliser les
problématiques. Si les mathématiques offrent un cadre formel, riche et puissant, l’ingénieur
a la possibilité d’utiliser des logiciels afin de l’aider à résoudre les problèmes. On
rencontre, pour résumer, deux types de logiciel scientifique :
1- Les logiciels de calcul formels (les plus connus étant Maple et Mathematica) ;
2- Les logiciels de calcul numériques (Matlab est le plus utilisé, mais il existe aussi Scilab,
Python, Octave ……).
Ces deux types de logiciel répondent à deux besoins différents (parfois

complémentaires).
Les premiers vont permettre de calculer symboliquement une dérivée, une
intégrale (si elle est calculable) et plus généralement de manipuler des valeurs
exactes.
Les secondes vont permettre de calculer rapidement de manière numérique (et
donc approchée)
Introduction
Remarque
Il n’y a pas de logiciel meilleur qu’un autre, les deux catégories sont complémentaires et
dépendent de l’application visée.
Les logiciels de calculs numériques sont très répandus dans l’industrie et la recherche,
car ils permettent de faire du prototypage rapide, c’est à dire de pouvoir développer une
application très rapidement afin de l’évaluer, avant de lancer un processus industriel.
L'objet de cette section est de mettre en évidence les principales difficultés liées à la pratique
des calculs numériques sur ordinateur.
Tout calcul numérique devrait s’accompagner d’une estimation des erreurs d’approximation
commises.
Exemple introductif : On cherche à évaluer de manière numérique l’exponentielle
Solution Trouver approchant numériquement z

Une méthode consiste à utiliser les séries de Taylor
En considérant des ressources de calcul limitées, on en est réduit à déterminer
Pour le calcul de l’exponentielle, on commet donc une erreur
Exercice: Calcul approché de π

Sources d’erreur
Erreur relatives aux données d’entrée

Erreur de mesure générée par la différence entre la valeur exacte x et la valeur
mesurée t:
Erreur d’arrondi générée par la différence entre la valeur exacte x et la valeur

arrondie fl(x)= . t:
Exemple :soit un objet valant 100 DH, son vrai prix en dollars est donc de
,
Mais on le trouvera uniquement au prix de =15,24 dollars, l’erreur commise est donc de :
Sources d’erreur
Erreurs résultantes d’un calcul
Erreur de troncature
Exemple: dans le calcul numérique de l’exponentiel, l’erreur de troncature
vaut
Erreur d’arrondi dans les étapes d’un calcul (algorithme, programme)
Exemple : on veut calculer avec une calculatrice la somme entre
x1 = 6,2317 107 x2 = 2,179 102
La valeur exacte du calcul est x = 6,23172179 107 et la valeur calculée est = 6,2317 107.
Sources d’erreur
Erreurs
Soit x un résultat exact et un résultat approché. On définit alors
Erreur absolue
Erreur relative
Si x≠0, l’erreur relative est
/
Chapitre 2:
Présentation du Matlab
Présentation Matlab
1-Introduction : qu’est ce que Matlab ?
✓ Logiciel de calcul scientifique

✓ Langage interprété (pas de compilation)
✓ Développé par la société Mathworks
Avantages
✓ Facilité d’utilisation, prise en main rapide
✓ Existence de toolboxes utiles pour l’ingénieur (réseaux de neurones,
traitement de signal, Optimisation, Contrôle, etc..)
✓ Possibilité de l’interfacer avec d’autres langages (C, C++, Fortran)
✓ Permet de faire du calcul parallèle.
Inconvénients
✓ Limitation en mémoire
✓ Payant
1-Introduction : qu’est ce que Matlab ?
Alternatives libres
✓ Scilab
✓ Octave
✓ Python
Remarque
Contrairement à Maple, Matlab n’est pas un logiciel de calcul formel (pas de calculs exacts)
2-Premières notions : lancement de Matlab
- Current Folder : arborescence et liste de fichiers

- Command history : historique des commandes
- Workspace : contenu des variables
- Command window : fenêtre principale pour l'exécution des instructions
2-Premières notions : documentation Matlab
✓ Commande help
Exemple : pour avoir de la documentation sur la commande plot
help plot
✓ Pour une documentation plus complète : Help/documentation

2-Premiéres notions : ligne de commande, mode immédiat

Matlab est un interpréteur : il propose à l’utilisateur une invite (prompt) à laquelle on peut
répondre par une commande.
Deux type de commandes :
✓ Expression : formule permettant de calculer immédiatement un résultat
Exemples d’expressions :
>> 2*3 >> pi

ans =
6 >> sin(pi/2)
Remarque
Tous les éléments de l’expression doivent être connus au moment de son évaluation par l’interpréteur
✓ Instruction : ensemble structuré d’expressions ou affectation

>> a=2*3 ;
>> test=sin(pi/2)
Remarque : La présence d’un point-virgule empêche « ; » derrière une instructions MATLAB
empêche l’affichage du résultat à l’écran.
2-Premiéres notions : ligne de commande, mode immédiat
✓ Instruction : ensemble structuré d’expressions ou affectation
* input(' ') :
Introduire une ou des variables par l’intermédiaire du clavier.
Exemple :
>>z=input(‘texte’); % demande à l’utilisateur de saisir des données numériques à la
suite d’un message ‘texte’ qui s’affiche à l’écran
>>y=input(‘texte ’ ,’s’); demande à l’utilisateur de saisir des données texte (chaîne

de caractères) à la suite d’un message ‘texte’ qui s’affiche à l’écran
3- Scripts et fonctions
Pour écrire plusieurs instructions à la fois, il est utile d’utiliser 2 types de fichier (qui portent
l’extension .m)
script M-files : ni entrée, ni sortie et utilise les variables de l’espace de travail.
fonction M-files : contient une fonction qui accepte des arguments en entrée et renvoie
des arguments en sortie et les variables internes sont locales à la fonction
Exemple de script
Fichier exempleScript.m
x=1;
y=2;
z=x+y;
Dans la fenêtre de commandes :

>> exempleScript Exécution du script stocké dans le fichier exempleScript.m
>> x
>> y Renvoie les valeurs des variables x,y et z.
>> z
Les variables déclarées dans le script sont connues
Exemples de fonctions
Fichier SommeEtProduit.m
(x,y) arguments d’entrée
Function [s,p]=SommeEtProduit(x,y)
S=x+y
P=x*y (s,p) arguments de sortie
(end fonction)
Dans la fenêtre de commandes : Définition des variables a et b

>> a=1;
>> b=2;
Appel et exécution de de la fonction
>> [c,d] = SommeEtProduit(a,b) SommeEtProduit (c = 3, d=2)
Remarque :
Le fichier SommeEtProduit.m doit être dans le répertoire courant
Le nom du fichier.m et le nom de la fonction doivent être les mêmes
Créer des fichiers scripts ou des fonctions / Editeur Matlab
3- Scripts et fonctions: règles de programmation

Remarque Il est impératif de commenter vos programmes (scripts et fonctions)
Les lignes commentées sont précédées par le caractère %

% ligne de commentaires
En pratique, quelques règles à respecter :
✓Scripts et fonctions : expliquer les différentes étapes de vos programmes (une ligne, un
commentaire)
✓Commentaires additionnels pour les fonctions : décrire les variables d’entrée, les
variables de sortie ainsi que ce que fait votre fonction
4-Variables scalaires
✓ Pas de différents types pour les nombres (Matlab fait lui même les conversions)
✓ Pas de déclaration de variables
>> a=2;
>> b=2.5;
>> c=a*b;
✓ Liste des variables : commande who
>> a=2;
Définition des variables a et b
>>b=5;
>> who ab
✓ Suppression des variables : commande clear

>> clear a Supprime la variable a
>> clear all Supprime toutes les variables
4-Variables scalaires
Pour sauvegarder des variables, utilisez la fonction save. Sauvegarder les variable a, b dans le
fichier svar.mat se fait par :
save svar a b
On les recharge par la commande :
load svar
✓ Variables (constantes prédéfinies) :

pi : 3.1415926535897
i: √−1
j: √−1
eps : précision numérique relative
realmin : plus petit nombre à virgule flottante manipulable
realmax : plus grand nombre à virgule flottante manipulable
inf : infini est obtenu quand on essaie d’évaluer une expression
dont le résultat excède realmax
NaN : not-a-number est obtenu quand on essaie d’effectuer une
opération non définie comme 0/0
5- Format Matlab
Format numérique : commande format pour afficher des nombres en virgule fixe ou
flottante
>> format short, pi^4 % fixe, 5 chiffres

ans =
97.4091
>> format short e, pi^4 % flottante, 5 chiffres

ans =
9.7409e+001
>> format long, pi^4 % fixe, 15 chiffres

ans =
97.40909103400242
>> format long e, pi^4 % flottante, 15 chiffres

ans =
9.740909103400242e+001
6- Calcul matriciel
Soient n et m des entiers positifs. Une matrice à m lignes et n colonnes est un ensemble de m
× n éléments aij, avec i = 1, . . .,m et j = 1, . . ., n, représentée par le tableau
On écrira de manière compacte A = (aij). Si les éléments de A sont des réels, on écrit
× ×
A et A s’ils sont complexes
Les matrices carrées de dimension n sont celles pour lesquelles m = n. Une matrice
n’ayant qu’une colonne est un vecteur colonne, et une matrice n’ayant qu’une ligne est
un vecteur ligne.
6- Calcul matriciel
Pour définir une matrice en MATLAB, on doit écrire ses éléments de la première à la dernière
ligne, en utilisant le caractère ; pour séparer les lignes. Par exemple, la commande :
>> A = [ 1 2 3; 4 5 6]
donne
A=
123
456
c’est-à-dire, une matrice 2 × 3 dont les éléments sont indiqués ci-dessus.
La matrice nulle 0 est celle dont tous les éléments aij sont nuls pour i = 1, . . .,m, j = 1, . . .,
n; on peut la construire en MATLAB avec la commande zeros(m,n).
La commande eye(m,n) renvoie une matrice rectangulaire dont les éléments valent 0
exceptés ceux de la diagonale principale qui valent 1.
La diagonale principale d’une matrice A de taille m×n est la diagonale constituée des éléments
aii, i = 1, . . ., min(m, n).
La commande eye(n) (qui est un raccourci pour eye(n,n)) renvoie une matrice carrée de dimension n
appelée matrice identité et notée I.
Enfin, la commande A = [] définit une matrice vide.
6- Calcul matriciel
Somme et produit de deux matrices
On peut définir les opérations suivantes :
1. Si A = ( ) et B = ( ) sont des matrices m×n, la somme de A et B est la matrice A+B

=( + );
2. Le produit d’une matrice A par un nombre réel ou complexe λ est la matrice λA = (λ );
3. Le produit de deux matrices n’est possible que si le nombre de colonnes de la

première est égal au nombre de lignes de la seconde, autrement dit si A est de
taille m × p et B est de taille p × n. Dans ce cas, C = AB est une matrice m × n dont les
éléments sont
6- Calcul matriciel
Voici un exemple de la somme et du produit de deux matrices :
>> A=[1 2 3; 4 5 6];

>> B=[7 8 9; 10 11 12];
>> C=[13 14; 15 16; 17 18];
>> A+B
ans =
8 10 12
14 16 18
>> A*C
ans =
94 100
229 244
6- Calcul matriciel
Remarquer que MATLAB renvoie un message d’erreur quand on tente d’effectuer des opérations
entre matrices de dimensions incompatibles.
Par exemple :
>> A=[1 2 3; 4 5 6];

>> B=[7 8 9; 10 11 12];
>> C=[13 14; 15 16; 17 18];
>> A+C
??? Error using ==> +
Matrix dimensions must agree.
>> A*B
??? Error using ==> *
Inner matrix dimensions must agree.
6- Calcul matriciel
Inverse d’une matrice
Si A est une matrice carrée de dimension n, son inverse (quand elle existe) est une matrice
carrée de dimension n, notée , qui satisfait relation .
On peut obtenir avec la commande inv(A). L’inverse de A existe si et seulement si

le déterminant de A, un nombre noté det(A), qu’on peut calculer avec la commande
det(A), est non nul. Cette condition est vérifiée si et seulement si les vecteurs colonnes de
A sont linéairement indépendants
Le déterminant d’une matrice carrée est défini par la formule de récurrence (règle de
Laplace)
6- Calcul matriciel
où et est la matrice obtenue en éliminant la i-ème ligne et la
j-ème colonne de la matrice A (le résultat est indépendant du choix de la ligne ou de la
colonne).
En particulier, si A R2×2 on a
det(A) = a11a22 − a12a21;
si A R3×3, on obtient
det(A) = a11a22a33 + a31a12a23 + a21a13a32−a11a23a32 − a21a12a33 − a31a13a22.
Pour un produit de matrices, on a la propriété suivante :

si A =BC, alors det(A) = det(B)det(C).
Pour inverser une matrice 2×2, et calculer son déterminant, on peut
procéder ainsi :
>> A=[1 2; 3 4];
>> inv(A) >> det(A)
ans = ans =
-2.0000 1.0000 -2
1.5000 -0.5000
6- Calcul matriciel
Pour certains types de matrices carrées, les calculs de l’inverse et du déterminant sont très
simples. Par exemple, si A est une matrice diagonale, i.e. telle que seuls les éléments
diagonaux , k = 1, . . ., n, sont non nuls, son déterminant est donné par
.
En particulier, A est inversible si et seulement si pour tout k.

Dans ce cas, l’inverse de A est encore une matrice diagonale, d’éléments
Soit v un vecteur de dimension n. La commande diag(v) de MATLAB produit une matrice

diagonale dont les éléments sont les composantes du vecteur v.
La commande plus générale diag(v,m) renvoie une matrice carrée de dimension

n+abs(m) dont la m-ème diagonale supérieure (i.e. la diagonale constituée des éléments
d’indices i, i+m) contient les composantes de v, et dont les autres éléments sont nuls.
6- Calcul matriciel
Remarquer que cette commande est aussi valide pour des valeurs négatives de m
:dans ce cas, ce sont les diagonales inférieures qui sont concernées.
Par exemple si v = [1 2 3] alors :

>> A=diag(v,-1)
A=
0000
1000
0200
0030
6- Calcul matriciel
Les matrices triangulaires supérieures et triangulaires inférieures
D’autres matrices particulières importantes sont les matrices triangulaires

supérieures et triangulaires inférieures. Une matrice carrée de dimension n est
triangulaire supérieure (resp. inférieure) si tous les éléments situés au-dessous (resp. au-
dessus) de la diagonale principale sont nuls. Son déterminant est alors simplement le produit
des termes diagonaux.
Les commandes triu(A) et tril(A) permettent d’extraire les parties triangulaires

supérieure et inférieure d’une matrice A de dimension n.
Les commandes étendues tril(A,m) ou triu(A,m), avec m compris entre -n et n,
permettent d’extraire les parties triangulaires augmentées, ou privées, des m diagonales
secondaires
6- Calcul matriciel
Les matrices triangulaires supérieures et triangulaires inférieures
Par exemple, étant donné la matrice A =[3 1 2; -1 3 4; -2 -1 3],
la commande L1=tril(A) donne :
>> L1=tril(A)
L1 =
3 0 0
-1 3 0
-2 -1 3
tandis que L2=tril(A,-1) donne :

>> L2=tril(A,-1)
L2 =
0 0 0
-1 0 0
-2 -1 0
6- Calcul matriciel
Pour finir, rappelons que si A ℝn×m, sa transposée AT ℝn×m est la matrice obtenue en
intervertissant les lignes et les colonnes de A.
Quand n = m et A = AT la matrice A est dite symétrique. La notation A’ est utilisée par

MATLAB pour désigner A’ la transposée de A si A est réelle, ou sa transconjuguée (c’est-à-
dire la transposée de sa conjuguée, qu’on note AH) si A est complexe. Une matrice carrée
complexe qui coïncide avec sa transconjuguée AH est appelée matrice hermitienne.
6- Calcul matriciel: Vecteurs
Dans ce cours, les vecteurs sont notés en caractères gras ; plus précisément, v désigne un vecteur
colonne dont la i-ème composante est notée vi. Quand toutes les composantes sont réelles, on écrit v
ℝ n.
Pour définir un vecteur colonne v, on doit indiquer entre crochet ses composantes séparées d’un
point-virgule, tandis que pour un vecteur ligne w, il suffit d’écrire ses composantes séparées par des
espaces ou des virgules.
Exemple:
Les instructions v = [1;2;3] et w = [1 2 3] définissent le vecteur colonne v et le vecteur ligne
w, tous les deux de dimension 3.
La commande zeros(n,1) (resp. zeros(1,n)) définit un vecteur colonne (resp. ligne), qu’on notera
0, de dimension n et de composantes nulles. De même, la commande ones(n,1) définit le vecteur
colonne, noté 1, dont les composantes sont toutes égales à 1.
6.1 Vecteurs
Définition:
Un ensemble de vecteurs {y1, . . ., ym} est dit linéairement indépendant
si la relation : α1y1 + . . . + αmym = 0 implique que tous les coefficients α1, . . .,
αm sont nuls
β= (y1, . . . , yn) de n vecteurs linéairement indépendants de ℝn (ou ₵n) est une base de ℝn (ou
₵n). Autrement dit, tout vecteur de ℝn peut être écrit
et les coefficients {wk} sont uniques. Ces derniers sont appelés les composantes de dans la base β. Par
exemple, la base canonique de ℝn est donnée par (e1, . . . , en), où ei est le vecteur dont la i-ème
composante est égal à 1, et toutes les autres sont nulles. Bien que n’étant pas la seule base de ℝn, la base
canonique est celle qu’on utilise en général.
6.1 Vecteurs
Le produit scalaire de deux vecteurs , ℝn est défini par
{vk} et {wk} étant les composantes de v et w, respectivement
La commande MATLAB correspondante est w’*v, où l’apostrophe désigne la transposition du vecteur,

ou encore dot(v,w)
Pour un vecteur v à composantes complexes, v’ désigne son transconjugué vH, qui est le vecteur ligne
dont les composantes sont les complexes conjugués de
La “longueur” d’un vecteur v est donnée par:
et peut être calculée par la commande Matlab norm(v).

On appelle la norme euclidienne du vecteur v
6.1 Vecteurs
Le produit vectoriel de deux vecteurs v,w ℝ3, noté v×w ou encore vʌw, est le vecteur u ℝ3
orthogonal à v et w dont le module est |u| = |v| |w| sin(α), où α est l’angle le plus petit entre v
et w. On le calcule à l’aide de la commande cross(v,w).
Dans MATLAB, on peut visualiser un vecteur à l’aide de la commande quiver2 dans ℝ2 et quiver3
dans ℝ3 .
Les commandes MATLAB x.*y, x./y ou x.ˆ2 indiquent que les opérations sont effectuées composante
par composante. Par exemple, si on définit les vecteurs :
>> x = [1; 2; 3]; y = [4; 5; 6];

l’instruction
>> y’*x
ans =
32
renvoie le produit scalaire, tandis que :
>> x.*y
ans =
4
10
18 ; renvoie un vecteur dont la i-ème composante est égale à xiyi .
6.1 Vecteurs
Pour finir, rappelons qu’un nombre λ (réel ou complexe) est une valeur propre de la matrice A ℝn×n, si
Av = λv,
pour des vecteurs v ₵n, v ≠ 0, appelés vecteurs propres associés à λ.
En général, le calcul des valeurs propres est difficile. Pour les matrices diagonales et triangulaires, les
valeurs propres sont simplement les termes diagonaux.
7- Fonctions réelles
Cette section traite des fonctions réelles. On cherche en particulier à calculer les zéros (ou
racines), l’intégrale et la dérivée d’une fonction donnée f, définie sur un intervalle ]a,
b[.
La commande fplot(fun,lims) trace le graphe de la fonction fun (définie par une chaîne de
caractères) sur l’intervalle ]lims(1),lims(2)[.
Par exemple, pour représenter f(x) = 1/(1 + x²) sur [ − 5, 5], on peut écrire :
>> fun =’1/(1+x^²)’; lims=[-5,5]; fplot(fun,lims);
ou, plus directement,
>> fplot(’1/(1+x^²)’,[-5 5]);

Le graphe est obtenu en échantillonnant la fonction en des abscisses non équiréparties. Il

reproduit le graphe réel de f avec une tolérance de 0.2%. Pour améliorer la précision, on
pourrait utiliser la commande :
>> fplot(fun, lims, tol, n, LineSpec)
où tol indique la tolérance souhaitée
le paramètre n(≥ 1) assure que la fonction sera tracée avec un minimum de n+1 points.
LineSpec spécifie le type de ligne ou la couleur (par exemple, LineSpec=’–’ pour une
ligne en traits discontinus, LineSpec=’r-.’ une ligne rouge en traits mixtes, etc.).
Pour utiliser les valeurs par défaut de tol, n ou LineSpec, il suffit d’utiliser des matrices
vides ([ ]).
On peut définir la fonction f(x) = 1/(1 + x2) de plusieurs manières : par l’instruction fun=’1/(1+x^2)’
vue précédemment ; par la commande inline avec l’instruction :
>> fun=inline(’1/(1+x^2)’,’x’);
par la fonction anonyme et le handle @ :
>> fun=@(x)[1/(1+x^2)];
ou enfin, en écrivant une fonction MATLAB :

function y=fun(x)
y=1/(1+x^2);
end
La commande inline, dont la syntaxe usuelle est fun=inline(expr, arg1, arg2, ..., argn), définit une
fonction fun qui dépend de l’ensemble ordonné de variables arg1, arg2, ..., argn. La chaîne de
caractères expr contient l’expression de fun. Par exemple,
fun=inline(’sin(x)*(1+cos(t))’, ’x’,’t’) définit la fonction fun(x, t) = sin(x)(1 + cos(t)).
La forme compacte fun=inline(expr) suppose implicitement que expr dépend de toutes les
variables qui apparaissent dans la définition de la fonction, selon l’ordre alphabétique.
Par exemple, avec la commande fun=inline(’sin(x) *(1+cos(t))’),on définit la fonction
fun(t, x)=sin(x)(1 + cos(t)),dont la première variable est t et la seconde x (en suivant l’ordre
lexicographique).
La syntaxe usuelle d’une fonction anonyme est :

fun=@(arg1, arg2,...,argn)[expr]
eval
évaluent la fonction fun au point x
feval
Remarque :
Si la variable x est un tableau, les opérations /, * et ˆ agissant sur elle doivent être
remplacées par les opérations point correspondantes ./, .* et .ˆ qui opèrent composante par
composante
Définition Evaluation Tracé
fun=’1/(1+xˆ2)’ y=eval(fun) fplot(fun,[-2,2])
fun=inline(’1/(1+xˆ2)’) y=fun(x) fplot(fun,[-2,2])

y=feval(fun,x)
fun=@(x)[1/(1+xˆ2)] y=fun(x) fplot(fun,[-2,2])

y=feval(fun,x)
function y=fun(x) y=fun(x) fplot(’fun’,[-2,2])

y=1/(1+xˆ2); y=feval(@fun,x) fplot(@fun,[-2,2])
end y=feval(’fun’,x)
7- Fonctions réelles: Les zéros
Définition :
On dit que α est un zéro de la fonction réelle f si f(α) = 0. Il est dit simple si
f ‘(α) = 0, et multiple sinon.
On peut déterminer les zéros réels d’une fonction à partir de son graphe (avec une certaine
tolérance). Le calcul direct de tous les zéros d’une fonction donnée n’est pas toujours
facile.
Pour les fonctions polynomiales de degré n à coefficients réels, c’est-à-dire de la forme:
On peut calculer le zéro unique α = −a0/a1, quand n = 1 (le graphe de p1 est une ligne
droite), ou les deux zéros α+ et α− C, éventuellement confondus, quand n = 2 (le
graphe de p2 est une parabole):
Mais il n’y a pas de formule explicite donnant les racines d’un polynôme quelconque pn quand
n ≥ 5.
Nous noterons Pn l’espace des polynômes de degré inférieur ou égal à n,
où les ak sont des coefficients donnés, réels ou complexes.
En général, le nombre de zéros d’une fonction ne peut pas être déterminé a priori. Dans le cas
particulier des fonctions polynomiales, le nombre de zéros (complexes et comptés avec leurs
multiplicités) est égal au degré du polynôme. De plus, si le complexe α = x+iy est racine d’un
polynôme à coefficients réels de degré n ≥ 2, son conjugué ¯α = x − iy l’est aussi.

On peut utiliser fzero dans MATLAB la commande fzero(fun,x0) permet de calculer une
valeur approchée du zéro de la fonction fun au voisinage d’une valeur donnée x0, réelle ou
complexe. Le résultat est une valeur approchée du zéro et l’intervalle dans lequel la
recherche a été effectuée.
En utilisant la commande fzero(fun,[x0 x1]) permet de calculer un zéro de fun dans
l’intervalle d’extrémités x0, x1, à condition que f change de signe entre x0 et x1
Exemple :
Soit la fonction f(x) = x2−1+ex.
En regardant son graphe, on voit qu’elle a deux zéros dans ] − 1, 1[. Pour les calculer, on
exécute les commandes suivantes :
>> fun=@(x)[x^2 - 1 + exp(x)];
>> fzero(fun,-1)
ans =
-0.7146
>> fzero(fun,1)
ans =
5.4422e-18
A l’aide de la fonction plot, on remarque qu’il y a un zéro dans l’intervalle [−1,−0.2] et un

autre dans [−0.2, 1]. On peut alors écrire alternativement :
>> fzero(fun,[-1 -0.2])
ans =
-0.7146
>> fzero(fun,[-0.2 1])
ans =
-5.2609e-17
Remarque :
Le résultat obtenu pour le second zéro est légèrement différent du précédent car
l’algorithme implémenté dans fzero est initialisé différemment dans ce cas.
Dans le Chapitre 4, nous présenterons plusieurs méthodes pour calculer de manière

approchée des zéros d’une fonction arbitraire.
7- Fonctions réelles: Les polynômes
Les polynômes sont des fonctions très particulières auxquelles MATLAB dédie la toolbox
polyfun. La commande polyval, permet d’évaluer un polynôme en un ou plusieurs points. Ses
arguments en entrée sont un vecteur p et un vecteur x, où les composantes de p sont les
coefficients du polynôme rangés en ordre des degrés décroissants, de an à a0, et les
composantes de x sont les points où le polynôme est évalué. Le résultat peut être stocké dans
un vecteur y en écrivant :
>> y = polyval(p,x)
Par exemple, les valeurs de p(x) = x7 +3x2 − 1, aux points équirépartis xk = −1 + k/4 pour
k = 0, . . ., 8, peuvent être obtenus en procédant ainsi :
>> p = [1 0 0 0 0 3 0 -1]; x = [-1:0.25:1];
>> y = polyval(p,x)
y=
Columns 1 through 5:
1.00000 0.55402 -0.25781 -0.81256 -1.00000
Columns 6 through 9:
-0.81244 -0.24219 0.82098 3.00000
Présentation Matlab:

La commande roots donne une approximation des racines d’un polynôme et ne nécessite que le
vecteur p en entrée.
Par exemple, on peut calculer les zéros de p(x) = x3 −6x2 +11x− 6
en écrivant :
>> p = [1 -6 11 -6]; format long;
>> roots(p)
ans =
3.00000000000000
2.00000000000000
1.00000000000000
Indiquons qu’avec la commande p=conv(p1,p2) on obtient les coefficients du polynôme

résultant du produit de deux polynômes dont les coefficients sont contenus dans les vecteurs
p1 et p2. De même, la comdmande [q,r]=deconv(p1,p2) renvoie les coefficients du
quotient et du reste de la division euclidienne de p1 par p2, i.e. p1 = conv(p2,q) + r.
Considérons par exemple le produit et le quotient de deux polynômes

p1(x) = x4 − 1 et p2(x) = x3 − 1 :
>> p1 = [1 0 0 0 -1];
>> p2 = [1 0 0 -1];
>> p=conv(p1,p2)
p=
1 0 0 -1 -1 0 0 1
>> [q,r]=deconv(p1,p2)
q=
10
r=
0 0 0 1 -1
On trouve ainsi les polynômes p(x) = p1(x)p2(x) = x7 − x4 − x3 + 1, q(x) = x et r(x) = x − 1 tels
que p1(x) = q(x)p2(x) + r(x).
Enfin, les commandes polyint(p) et polyder(p) fournissent respectivement les coefficients
de la primitive s’annulant en x = 0 et de la dérivée du polynôme dont les coefficients sont
donnés dans le vecteur p.
Si x est un vecteur contenant des abscisses et si p (resp. p1 et p2) est un vecteur contenant les
coefficients d’un polynôme P (resp. P1 et P2), les commandes précédentes sont résumées
7- Fonctions réelles: Intégration et dérivation
La toolbox diff, int et taylor qui fournissent respectivement l’expression analytique de la

dérivée, de l’intégrale indéfinie (i.e. une primitive) et le polynôme de Taylor d’une fonction
donnée. En particulier, si on a défini une fonction avec la chaîne de caractères f, diff(f,n) donne
sa dérivée à l’ordre n, int(f) son intégrale indéfinie, et taylor(f,x,n+1) son polynôme de Taylor
de degré n en x0 = 0. La variable x doit être déclarée comme symbolique en utilisant la
commande syms x. Cela permettra de la manipuler algébriquement sans avoir à spécifier sa
valeur.
Pour appliquer ceci à la fonction f(x) = (x2 + 2x+ 2)/(x2 − 1), on
procède ainsi :
>> f = ’(x^2+2*x+2)/(x^2-1)’;
>> syms x
>> diff(f)
(2*x+2)/(x^2-1)-2*(x^2+2*x+2)/(x^2-1)^2*x
>> int(f)
x+5/2*log(x-1)-1/2*log(1+x)
>> taylor(f,x,6)
-2-2*x-3*x^2-2*x^3-3*x^4-2*x^5
Chapitre 3:
Programmation sous Matlab
Opérateurs de comparaison et opérateurs logiques
Les entrées-sorties
Structures de contrôle
Graphisme
1-Opérateurs de comparaison et opérateurs logiques
Les opérateurs de comparaison sont :

==: égal à (x == y)
>: strictement plus grand que (x >y)
<: strictement plus petit que (x <y)
>=: plus grand ou égal à (x ≥ y)
<=: plus petit ou égal à (x ≤ y)
˜= : différent de (x ˜= y)
Les opérateurs logiques sont :

&: et (x & y)
|: ou (x | y)
˜: non (˜ x)
2 Les entrées-sorties
2.1 Affichage simple, la commande disp
La commande disp permet d’afficher un tableau de valeurs numériques ou de

caractères.
>> A = magic(4);
>> disp(A)
16 2 3 13
5 11 10 8
9 7 6 12
4 14 15 1
On utilise fréquemment la commande disp avec un tableau qui est une chaîne de
caractères pour afficher un message. Par exemple :
disp(’Calcul du déterminant de la matrice A’).
On utilise également la commande disp pour afficher un résultat. Par exemple :
disp([’Le déterminant de la matrice A vaut ’, num2str(det(A))]).
2.1 Affichage simple, la commande disp
Remarque
On remarque que l’usage de la commande disp est alors un peu particulier. En effet un
tableau doit être d’un type donné, les éléments d’un même tableau ne peuvent donc être des
chaînes de caractères et des valeurs numériques. On a donc recours à la commande num2str
(« number to string ») pour convertir une valeur numérique en une chaîne de caractères.
2.2 Impressions dirigées par format
La commande sprintf permet l’impression de variables selon un modèle donné. Un modèle

d’édition se présente sous la forme du symbole pourcent (%) suivi d’indications permettant
de composer le contenu du champ à imprimer, en particulier sa longueur en nombre de
caractères
La syntaxe de la commande sprintf est :
sprintf(format, variables)
Modèle d’édition de caractères
format= % L s
% est le symbole de début de format

s le symbole précisant que la donnée est de type chaîne de caractères.
L est un entier donnant la longueur total du champ (en nombre de caractères).
Modèle d’édition de caractères
>> sprintf(’%s’, ’il fera beau a Safi’)

ans =
il fera beau a Safi
Modèle d’édition des réels
format= % L.Dt
% est le symbole de début de format,

L est un entier donnant la longueur total du champ (en nombre de caractères, point
virgule compris),
D est le nombre de décimales à afficher
t spécifie le type de notation utilisée.
Modèle d’édition des réels
Les principales valeurs possibles pour t sont les suivantes :

d : pour les entiers
e : pour une notation à virgule flottante où la partie exposant est délimitée par un e
minuscule (ex : 3.1415e+00)
E : même notation mais E remplace e (ex : 3.1415E+00)
f : pour une notation à virgule fixe (ex : 3.1415)
g : la notation la plus compacte entre la notation à virgule flottante et la notation à virgule
fixe est utilisée
Exemple 1:
>> x = pi/3; y = sin(x);
>> sprintf('sin(%8.6f) = %4.2f', x,y)
ans =
sin(1.047198) = 0.87
Exemple 2: La commande sprintf est << vectorielle >> : si la variable n'est pas scalaire le
format d'impression est réutilisé pour tous les éléments du tableau, colonne
par colonne.
>> x = [1:10];
>> sprintf(' %d ,',x)
ans =
1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ,
Il est possible d'utiliser les symboles suivant dans les chaînes de caractères :
\n: provoque le passage à une nouvelle ligne

\t: insère une tabulation horizontale
\b: décale l'impression du champ suivant d'un caractère vers la gauche
\r: saut horizontal
Remarque :
La commande fprintf est l'analogue de sprintf pour imprimer de variables selon
un modèle donné dans un fichier.
exp.txt
Exemple x exp(x)
0.00 1.00000000
0.10 1.10517092
0.20 1.22140276
x = 0:.1:1; 0.30 1.34985881
A = [x; exp(x)]; 0.40 1.49182470
0.50 1.64872127
fileID = fopen('exp.txt','w'); 0.60 1.82211880
fprintf(fileID,'%6s %12s\r\n','x','exp(x)'); 0.70 2.01375271
fprintf(fileID,'%6.2f %12.8f\r\n',A); 0.80 2.22554093
0.90 2.45960311
fclose(fileID); 1.00 2.71828183
3: Structures de contrôle
3.1 Boucle for: parcours d’un intervalle
Une première possibilité pour exécuter une séquence d’instructions de manière répétée
consiste à effectuer une boucle pour les valeurs d’un indice, incrémenté à chaque itération,
variant entre deux bornes données. Ce processus est mis en œuvre par la « boucle for ».
Syntaxe :
for indice = borne_inf : borne_sup
séquence d’instructions
end
où
indice est une variable appelée l’indice de la boucle ;
borne_inf et borne_sup sont deux constantes réelles (appelées paramètres de la boucle) ;
séquence d’instructions est le traitement à effectuer pour les valeurs d’indices variant
entre borne_inf et borne_sup avec un incrément de 1. On parle du corps de la boucle.
Interprétation :
Si borne_inf est plus petit ou égal à borne_sup, le traitement séquence d’instructions est
exécuté (borne_sup − borne_inf + 1) fois, pour les valeurs de la variable indice égales à
borne_inf, borne_inf + 1, ・・・ , borne_sup − 1, borne_sup.
Si borne_inf est strictement plus grand que borne_sup, on passe à l’instruction qui suit
immédiatement l’instruction de fin de boucle (end).
Remarque :
On peut utiliser un incrément (pas) autre que 1 (valeur par défaut). La syntaxe est alors
borne_inf : pas : borne_sup. Le pas peut être négatif.
>> for r=1.1:-0.1:0.75
disp([’r = ’, num2str(r)]);
end
r = 1.1
r=1
r = 0.9
r = 0.8
Exemples de la boucle for :
Exemple1 : Exemple 2: calcul du factoriel
>> for r=1.1:-0.1:0.75 >> n = 4;

disp([’r = ’, num2str(r)]); >> nfac = 1;
end >> for k = 1:n
r = 1.1 nfac = nfac*k;
r=1 end
r = 0.9 >> nfac
r = 0.8 nfac =
>> 24
>>
3.2 Boucle while : tant que . . . faire
Une seconde possibilité pour exécuter une séquence d’instructions de manière répétée
consiste à effectuer une boucle tant qu’une condition reste vérifiée. On arrête de boucler dès
que cette condition n’est plus satisfaite. Ce processus est mis en oeuvre par la « boucle
while ».
Syntaxe :
while expression logique
end
Où
expression logique est une expression dont le résultat peut être vrai ou faux ;
séquence d’instructions est le traitement à effectuer tant que expression logique est vraie.
3.2 Boucle while : tant que . . . faire
Interprétation :
Tant que expression logique est vraie le traitement séquence d’instructions est exécuté sous
forme d’une boucle. Lorsque expression logique devient faux, on passe à l’instruction qui suit
immédiatement l’instruction de fin de boucle (end).
Exemple >> n = 4;
>> k = 1; nfac = 1;
>> while k <= n
nfac = nfac*k;
k = k+1;
end
>> nfac
nfac =
24
3.2 L’instruction conditionnée IF
On a parfois besoin d’exécuter une séquence d’instructions seulement dans le cas où une
condition donnée est vérifiée au préalable. Différentes formes d’instruction conditionnée
existent sous matlab.
L’instruction conditionnée la plus simple a la forme suivante :
Syntaxe :
if expression logique
end
où
expression logique est une expression dont le résultat peut être vrai ou faux ;
séquence d’instructions est le traitement à effectuer si expression logique est vraie.
Interprétation :
la séquence d’instructions n’est exécutée que si le résultat de l’évaluation de l’expression
logique est vraie (c’est-à-dire vaut 1). Dans le cas contraire on exécute l’instruction qui suit
le mot clé end. Dans le cas où l’expression logique est vraie, après exécution de la séquence
d’instructions on reprend le programme à l’instruction qui suit le mot clé end.
Il est possible d’effectuer un choix en cascade :
Syntaxe :
if expression logique 1
séquence d’instructions 1
elseif expression logique 2
...
elseif expression logique N
séquence d’instructions N
else
séquence d’instructions par défaut
end
On utilise fréquemment un choix en cascade lors d’initialisation de données. Par exemple, on initialise
une matrice A en fonction de la valeur d’une variable numex (numéro d’exemple) de la manière
suivante :
Exemple :
numex=input('donner la valeur de numex')
n=3;
if numex == 1
A = ones(n);
elseif numex == 2
A = magic(n);
elseif numex == 3 | numex == 4
A = rand(n);
else
error(’numero d’’exemple non prevu ...’);
end
3.3 L’instruction swich
Une alternative à l’utilisation d’une séquence d’instructions conditionnées pour effectuer

un choix en cascade existe. Il s’agit de l’instruction switch
Syntaxe :
switch var
case cst_1 ,
case cst_2 ,
...
case cst_N ,
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 ;
cst_1, . . ., cst_N, sont des constantes numérique ou des constantes chaîne de caractères ;
séquence d’instructions i est la séquence d’instructions à exécuter si var==cst_i.
Interprétation :
Si la variable var est égale à l’une des constantes cst_1, . . ., cst_N, (par exemple cst_i) alors
la séquence d’instructions correspondante (ici séquence d’instructions i) est exécutée. Le
programme reprend ensuite à la première instruction suivant le mot-clé end. Si la variable
var n’est égale à aucune des constantes la séquence d’instructions par défaut (otherwise)
est exécutée.
Remarque :
La variable var doit bien entendu être du même type que les constantes cst_1, . . ., cst_N.
Si la séquence d’instructions à exécuter est la même pour différents cas il est possible de
les regrouper. La syntaxe est alors,
case { cst_k , cst_l , ...}

séquence d’instructions commune
Exemple : numex=input('donner la valeur de numex')

switch numex
case 1,
A = ones(6)
case 2,
A = magic(6);
case {3,4},
A = rand(6);
otherwise
disp ('pas de matrice')
end
4: Graphisme
4.1 Gestion des fenêtres graphiques
On peut ouvrir une nouvelle fenêtre graphique par la commande figure.
Chaque fenêtre se voit affecter un numéro. Ce numéro est visible dans le bandeau de la
fenêtre sous forme d’un titre.
Le résultat d’une instruction graphique est par défaut affiché dans la dernière fenêtre
graphique ouverte qui est la fenêtre graphique active.
On rend active une fenêtre graphique précédemment ouverte en exécutant la commande

figure(n), où n désigne le numéro de la figure.
La commande close permet de fermer la fenêtre graphique active. On ferme une fenêtre
graphique précédemment ouverte en exécutant la commande close(n), où n désigne le
numéro de la figure. Il est également possible de fermer toutes les fenêtres graphiques en
tapant close all.
4: Graphisme
4.2 Graphisme 2D
4.2.1 Tracer le graphe d’une fonction ; la commande fplot
La commande fplot permet de tracer le graphe d’une fonction sur un intervalle donné.
Syntaxe:
fplot(’nomf’, [xmin , xmax])
où
nomf est soit le nom d’une fonction matlab incorporée, soit une expression définissant
une fonction de la variable x, soit le nom d’une fonction utilisateur.
[xmin , xmax] est l’intervalle pour lequel est tracé le graphe de la fonction.
Illustrons par des exemples les trois façons d’utiliser la commande fplot.
4: Graphisme
4.2 Graphisme 2D
4.2.1 Tracer le graphe d’une fonction ; la commande fplot
Exemple 1
On obtient le graphe de la fonction incorporée sinus entre −2π et 2π par l’instruction:
fplot(’sin’,[-2*pi 2*pi])
4: Graphisme
4.2 Graphisme 2D
Exemple 2
Pour tracer le graphe de la fonction h(x) = x sin(x) entre −2π et 2π, on peut définir la fonction
utilisateur h dans le fichier h.m de la manière suivante
function y=h(x)
y=x.*sin(x);
On obtient alors le graphe de la fonction

h par l’instruction :
fplot(’h’, [-2*pi 2*pi])
L’autre façon de procéder est d’exécuter l’instruction: fplot(’x*sin(x)’, [-2*pi 2*pi])

4: Graphisme
4.2 Graphisme 2D
Il est possible de tracer plusieurs fonctions sur la même figure. Il faut pour cela utiliser
la commande fplot de la manière suivante :
fplot(’[nom_f1 , nom_f2 , nom_f3]’, [x_min , x_max])
où nomf_f1, nom_f2, nom_f3 est soit le nom d’une fonction matlab incorporée, soit une
expression définissant une fonction de la variable x, soit le nom d’une fonction utilisateur.
Il est également possible de gérer les bornes des valeurs en ordonnées. Pour limiter le
graphe aux ordonnées comprises entre les valeurs y_min et y_max on passera comme
second argument de la commande fplot le tableau [x_min , x_max , y_min , y_max ].
Exemple :
fplot(’[sin(x)/x , cos(x)/x]’, [-5, 5, -1, 1])
4: Graphisme
4.2.2. La commande plot
La commande plot permet de tracer un ensemble de points de coordonnées (xi, yi) , i = 1,

……,N.
La syntaxe est plot(x,y) où x est le vecteur contenant les valeurs xi en abscisse et y est le
vecteur contenant les valeurs yi en ordonnée
Voici par exemple une autre façon de tracer le graphe de la fonction h(x) = x sin(x)
entre −2π et 2π,
>> x=[-2*pi:0.01:2*pi]; y = x.*sin(x);

>> plot(x,y)
>>
4: Graphisme
On peut spécifier à matlab quelle doit être la couleur d’une courbe, quel doit être le style de
trait et/ou quel doit être le symbole à chaque point (xi, yi). Pour cela on donne un troisième
paramètre d’entrée à la commande plot qui est une chaîne de 3 caractères de la forme ’cst’
avec c désignant la couleur du trait, s le symbole du point et t le style de trait. Les
possibilités sont les suivantes :
y jaune . point - trait plein

m magenta o cercle : pointillé court
C cyan x marque x – pointillé long
r rouge + plus -. pointillé mixte
g vert * étoile
b bleu s carré
w blanc d losange
k noir v triangle (bas)
ˆ triangle (haut)
< triangle (gauche)
> triangle (droit)
p pentagone
h hexagone
4: Graphisme
Les valeurs par défaut sont c = b, s = . et t = - ce qui correspond à un trait plein bleu reliant
les points entre eux
La commande grid permet d’obtenir un quadrillage de la figure
Remarque:
Il est possible de tracer plusieurs courbes sur la même figure en spécifiant plusieurs tableaux
x1, y1, x2, y2, …. , comme paramètres de la commande plot
Exemple:
>> x = [-5:0.01:5];
>> y = x.^2.*cos(x); z =
x.*cos(x);
>> plot(x,y,'b-',x,z,'r:');
4: Graphisme
4.3 Améliorer la lisibilité d’une figure
4.3.1 Légender une figure
Il est recommandé de mettre une légende à une figure. La commande xlabel permet de
mettre un texte en légende sous l’axe des abscisses. La syntaxe est
xlabel(’ légende ’)
pour obtenir le mot légende en légende.
La commande ylabel fait de même pour l’axe des ordonnées.
La commande title permet de donner un titre à la figure. La syntaxe est

title(’ le titre ’)
pour obtenir comme titre le titre.
4: Graphisme
La syntaxe text(posx,posy,’ un texte ’) permet d’écrire un texte donné à une position précise
de coordonnées (posx, posy)
La syntaxe gtext(’ un texte ’) permet de placer le texte à une position choisie sur la figure à
l’aide de la souris
La syntaxe title([’Exemple numero ’, num2str(numex)]) permet d’afficher d’une valeur

contenue dans une variable au milieu de texte
4: Graphisme
evolution de la concentration du produit 5 au cours du temps

Exemple : 6 concentration maximale
>> P = 5;
>> t = [0:.01:2]; 5
>> c = 12*exp(-2*t) - 8*exp(-6*t);
c onc entation en gram m e par litre

>> plot(t,c); grid 4
>> xlabel(’temps en minutes’)

3
>> ylabel(’concentation en gramme par litre’)
>> title([’evolution de la concentration du
2
produit ’, num2str(P), ’ au cours du temps ’])
>> gtext(’concentration maximale’)
1
>>
0
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
temps en minutes
4: Graphisme
4.3.2 Afficher plusieurs courbes dans une même fenêtre
La commande hold on permet d’afficher plusieurs courbes dans une même fenêtre
graphique
La commande hold of permet de rétablir la situation antérieure

3
Exemple :
e = exp(1); 2.5
exp
figure 2
hold on
y=x
fplot('exp',[-1 1]) 1.5
fplot('log',[1/e e]) 1
plot([-1:0.01:e],[-1:0.01:e])
0.5
gtext('log')
log
gtext('y=x') 0
gtext('exp')
-0.5
grid
hold off -1
0.5 1 1.5 2 2.5
4: Graphisme
La commande subplot permet de décomposer une fenêtre en sous-fenêtres et d’afficher une

figure différente sur chacune de ces sous-fenêtres
La syntaxe est subplot(m,n,i)
Où:
m est le nombre de sous-fenêtres verticalement ;
n est le nombre de sous-fenêtres horizontalement ;
i sert à spécifier dans quelle sous-fenêtre doit s’effectuer l’affichage. Les fenêtres sont
numérotées de gauche à droite et de haut en bas.
4: Graphisme

Exemple:
subplot(2,3,1), fplot('cos',[0 4*pi]), title('cosinus'), grid
subplot(2,3,2), fplot('sin',[0 4*pi]), title('sinus'), grid
subplot(2,3,3), fplot('tan',[-pi/3 pi/3]), title('tangente'), grid
subplot(2,3,4), fplot('acos',[-1 1]), title('arc-cosinus'), grid
subplot(2,3,5), fplot('asin',[-1 1]), title('arc-sinus'), grid
subplot(2,3,6), fplot('atan',[-sqrt(3) sqrt(3)]), title('arc-tangente'), grid
cosinus sinus tangente
1 1 2
0.5 0.5 1
0 0 0
-0.5 -0.5 -1
-1 -1 -2
0 5 10 0 5 10 -1 0 1
arc-cosinus arc-sinus arc-tangente

4 2 2
3 1 1
2 0 0
1 -1 -1
0 -2 -2
-1 0 1 -1 0 1 -1 0 1
4: Graphisme
4.3.3 Sauvegarder une figure
La commande print permet de sauvegarder la figure d’une fenêtre graphique dans un
fichier sous divers formats d’images.
La syntaxe de la commande print est :
print -f<num> -d<format> <nomfic>
où
<num> désigne le numéro de la fenêtre graphique. Si ce paramètre n’est pas spécifié,
c’est la fenêtre active qui est prise en compte.
<nomfic> est le nom du fichier dans lequel est sauvegardée la figure.
<format> est le format de sauvegarde de la figure. Ces formats sont nombreux. On
pourra obtenir la liste complète en tapant help plot. Les principaux sont :
ps : PostScript noir et blanc

psc : PostScript couleur
eps : PostScript Encapsulé noir et blanc
epsc : PostScript Encapsulé couleur
jpeg : Format d’image JPEG
tiff : Format d’image TIFF
4: Graphisme
Exemple :
print -f2 -dtiff figure2.tiff
Nom du fichier qui

Numéro de la figure Format de contient la figure
l’image
4: Graphisme
4 Graphisme 3D
4.1 Tracer les lignes de niveau d’une fonction de 2 variables
La commande contour permet de tracer les lignes de niveau d’une fonction g(x,y) de 2
variables réelles .
Pour tracer les lignes de niveau de la fonction g(x, y) pour x [xmin, xmax] et y [ymin,
ymax] on procède de la manière suivante :
1- création d’un maillage, de maille de longueur h, du domaine [xmin, xmax]×[ymin, ymax]

grâce à la commande meshgrid,
[X,Y] = meshgrid(x_min :h :x_max, y_min :h :y_max).
2 Évaluation de la fonction aux noeuds de ce maillage, soit par appel à la fonction utilisateur
définissant la fonction, Z = g(X,Y) soit directement en définissant la fonction par une
expression matlab.
3 Affichage des lignes de niveau grâce à la commande contour, contour(X,Y,Z).

4: Graphisme
4 Graphisme 3D
Exemple : tracer les lignes de niveau de la fonction (x, y) → xe−(x2+y2) sur le domaine [−2,
2] × [−2, 2] en prenant un maillage de maille de longueur h = 0.2, :
Script N°1
>> [X,Y] = meshgrid(-2:.2:2, -
2:.2:2);
>> Z = X.*exp(-X.^2-Y.^2);
>> contour(X,Y,Z)
Script N°2
On peut également écrire une fonction
utilisateur g.m,
function x3 = g(x1,x2)
x3 = x1.*exp(-x1.^2-x2.^2);
et exécuter
>> [X,Y] = meshgrid(-2:.2:2, -2:.2:2);
>> Z = g(X,Y);
>> contour(X,Y,Z)
4: Graphisme
4 Graphisme 3D
Remarques :
Le nombre de lignes de niveau est déterminé de manière automatique à partir des valeurs
extrêmes prises par la fonction sur le domaine considéré. Pour imposer le nombre n de
lignes de niveau à afficher, il suffit d’appeler la fonction contour avec la valeur n comme
quatrième paramètre, contour(X,Y,Z,n).
La commande clabel permet d’afficher les valeurs pour toutes les lignes de niveau.
>> [C,h] = contour(X,Y,Z,n)
>> clabel(C,h)
Si l’on souhaite afficher uniquement les valeurs de quelques lignes de niveau, on utilise la
commande clabel de la manière suivante :
>> [C,h] = contour(X,Y,Z,n)

>> clabel(C,h,’manual’)
On peut alors grâce à la souris sélectionner les lignes de niveau pour lesquelles on souhaite
afficher la valeur.
4: Graphisme
4 Graphisme 3D
Exemple:
Pour tracer 30 lignes de niveau de la fonction (x, y) → (x − 1)2 + 10 (x2 − y)2 sur le domaine
[−1, 1]×[−1, 1] et pour choisir à l’aide de la souris les lignes de niveau pour lesquelles
l’isovaleur doit être affichée, on exécute :
>> [X,Y] = meshgrid(-1:.2:1, -1:.2:1);

>> Z = (X-1).^2 + 10*(X.^2-Y).^2;
>> [C,h] = contour(X,Y,Z,30);
>> clabel(C,h,’manual’)
4: Graphisme
4 Graphisme 3D
La commande colormap permet de modifier la palette des couleurs
La commande contourf permet d’afficher, en plus des lignes de niveau, un dégradé continu
de couleurs qui varie en fonction des valeurs prises par la fonction
2
Exemple
1.5
>> [X,Y] = meshgrid(-2:.2:2, -2:.2:2);
>> Z = (X-1).^2 + 10*(X.^2-Y).^2; 1
>> contourf(X,Y,Z,30);
0.5
>> colormap(cool);
0
-0.5
-1
-1.5
-2
-2 -1.5 -1 -0.5 0 0.5 1 1.5 2
4: Graphisme
4 Graphisme 3D
4.2 Représenter une surface d’équation z = g(x, y)
La commande mesh permet de tracer une surface d’équation z = g(x, y). La fonction g
peut être définie directement par une expression matlab ou être définie comme une
fonction utilisateur
Pour tracer la surface d’équation z = g(x, y) pour x [xmin, xmax] et y [ymin, ymax] on
procède de la manière suivante :
1. création d’un maillage, de maille de longueur h, du domaine [xmin, xmax]×[ymin,

ymax] grâce à la commande meshgrid,
[X,Y] = meshgrid(x_min :h :x_max, y_min :h :y_max).
2. Évaluation de la fonction aux noeuds de ce maillage, soit par appel à la fonction

utilisateur définissant la fonction, Z = g(X,Y)
soit directement en définissant la fonction par d’une expression matlab.
3. Affichage de la surface grâce à la commande mesh(X,Y,Z).

4: Graphisme
4 Graphisme 3D
4.2 Représenter une surface d’équation z = g(x, y)
>> [X,Y] = meshgrid(-2:.2:2, -2:.2:2);

>> Z = X.*exp(-X.^2-Y.^2);
>> mesh(X,Y,Z)
function x3 = g(x1,x2)
x3 = x1.*exp(-x1.^2-x2.^2);
on exécute :
>> [X,Y] = meshgrid(-2:.2:2, -
2:.2:2);
>> Z = g(X,Y);
>> mesh (X,Y,Z)
>>
Chapitre 4
Initiation au Calcul Scientifique
Plan
1- Equations non linéaires
2- Calcul approché de dérivées et intégrales

Equations non linéaires
Quelques problèmes types
Méthode de dichotomie (ou bisection) .
Méthode de Newton
Méthode de point fixe

Quelques problèmes types , dichotomie, Newton, point fixe
1- Quelques problèmes types

Calculer les zéros d’une fonction f réelle (c’est-à-dire les racines d’une équation f(x) = 0)
est un problème que l’on rencontre très souvent en Calcul Scientifique. En général, cette
tâche ne peut être effectuée en un nombre fini d’opérations.
Pour résoudre le problème, on utilise donc des méthodes itératives : partant

d’une ou plusieurs valeurs initiales, on construit une suite de valeurs ( ) qui, si
tout se passe bien, converge vers un zéro α de la fonction f considérée.
Nous débuterons ce chapitre avec quelques problèmes simples et concrets qui donnent lieu à
des équations non linéaires. Diverses méthodes numériques seront alors présentées, puis
utilisées pour résoudre ces problèmes

,
Problème 1 (Fonds d’investissement)
Le client d’une banque dépose au début de chaque année v dirhams dans un

fonds d’investissement et en retire, à la fin de la n-ème année, un capital de M dirhams.
Nous voulons calculer le taux d’intérêt annuel moyen T de cet investissement.
Comme M est relié à T par la relation:
nous déduisons que T est racine de l’équation algébrique non linéaire :


,
Problème 2 (Equation d’état d’un gaz)
Nous voulons déterminer le volume V occupé par un gaz dont la température

est T et dont la pression est p. L’équation d’état (i.e. l’équation liant p, V et T) est donnée
par
où a et b sont deux coefficients qui dépendent du gaz considéré, N est le nombre de

molécules contenues dans le volume V et k est la constante de Boltzmann. Nous devons
donc résoudre une équation non linéaire dont la racine est V
1- Méthode de Dichotomie (ou bisection)

Soit f une fonction continue sur [a, b] telle que f(a)f(b) < 0. Nécessairement f a au moins un
zéro dans ]a, b[ (ce résultat est un cas particulier du théorème des valeurs intermédiaires).
Supposons pour simplifier qu’il est unique et notons le α (dans le cas où il y a plusieurs
zéros, on peut localiser graphiquement, à l’aide de la commande fplot, un intervalle qui
n’en contient qu’un).
La méthode de dichotomie (aussi appelée méthode de bisection) consiste à diviser en deux

un intervalle donné, et à choisir le sous-intervalle où f change de signe. Plus précisément, si
on note et le sous-intervalle retenu à l’étape k, on choisit le sous-intervalle
de pour lequel f a un signe différent à ses deux extrémités. En répétant cette
procédure, on est assuré que chaque ainsi construit contiendra α. La suite { } des
milieux des intervalles convergera vers α puisque la longueur de ces intervalles tend
vers zéro quand k tend vers l’infini.
Algorithme de la méthode
La méthode est initialisée en posant:
( ) ( ) , ( ) ( ) , ( ) ( ) .
A chaque étape k ≥ 1, on choisit le sous-intervalle ( ) ( ) de

( ) ( ) comme suit:
étant donné ,
si ,
alors
et on s’arrête ;
sinon,
Si
poser , ;
Si
poser , ;
On définit alors et on incrémente k de 1.

Exemple :
En prenant ,
on obtient
=] − 0.25, 1.25[,
=]0.5, 1.25[, = 0.875,
=]0.875, 1.25[, = 1.0625,
=]0.875, 1.0625[, = 0.96875
Figure 1: Quelques itérations de la méthode de

dichotomie
Remarquer que chaque sous-intervalle contient le zéro α. De plus, la suite

converge nécessairement vers α puisqu’à chaque étape la longueur de
est divisée par deux. Comme , l’erreur à l’étape k vérifie
Pour garantir que , pour une tolérance ε donnée, il suffit d’effectuer itérations,
où est le plus petit entier tel que:

Exercice d’application:
Problème 1: fond d’investissement
Appliquons la méthode de dichotomie avec tol= , a= 0.01 et b= 0.1 pour résoudre le

problème 1 , en supposant que v est égal à 1000 dirhams et qu’après 5 ans M est égal à
6000 dirhams.
N.B
La méthode de dichotomie est simple mais elle ne garantit pas une réduction monotone de
l’erreur d’une itération à l’autre : tout ce dont on est assuré, c’est que la longueur de
l’intervalle de recherche est divisée par deux à chaque étape. Par conséquent, si le seul
critère d’arrêt est le contrôle de la longueur de ( ) , on risque de rejeter de bonnes
approximations de α.
2- Méthode de Newton
La seule information utilisée par la méthode de dichotomie est le signe de la fonction f aux
extrémités des sous-intervalles. Dans le cas où f est différentiable, on peut construire une
méthode plus efficace en exploitant les valeurs de f et de ses dérivées. En partant de
l’équation de la tangente à la courbe (x, f(x)) au point ,
et en faisant comme si vérifiait , on obtient
(2.1)
en supposant .
Cette formule permet de construire une suite , étant donné une valeur initiale
Cette méthode est connue sous le nom de méthode de Newton et revient à calculer le zéro
de f en remplaçant localement f par sa tangente (voir Figure 2).
Figure 2. Les premières itérations obtenues avec la méthode de Newton pour la fonction
en partant d’une donnée initiale
En faisant un développement de Taylor de f au voisinage d’un point arbitraire , on trouve
(2.2)
où .
En écrivant que est égal à zéro et en négligeant le terme on obtient

en fonction de comme défini en (2.1). De ce point de vue, on peut considérer
(2.1) comme une approximation de (2.2).
Exemple :comparaison entre dichotomie et Newton

Résolvons le problème 1 par la méthode de Newton, en prenant comme donnée initiale
. Test de convergence : la différence entre deux itérées successives est inférieure ou
égale à
En général, la méthode de Newton ne converge pas pour des valeurs arbitraires de , mais
seulement pour des valeurs suffisamment proches de α, c’est-à-dire appartenant à un certain
( )
voisinage de α. Au premier abord, cette condition semble inutilisable : elle signifie en
effet que pour calculer α (qui est inconnu), on devrait partir d’une valeur assez proche de α !
En pratique, on peut obtenir une valeur initiale en effectuant quelques itérations de la

méthode de dichotomie ou en examinant le graphe de f. Si est convenablement choisi et
si α est un zéro simple (c’est-à-dire tel que f’(α) ≠ 0) alors la méthode de Newton converge
Test d’arrêt pour les itérations de Newton
En théorie, une méthode de Newton convergente ne retourne le zéro α qu’après une infinité
d’itérations. En pratique, on recherche une approximation de α avec une certaine tolérance
ε. Ainsi, on peut interrompre la méthode à la première itération pour laquelle on a
l’inégalité suivante
Ceci est un test sur l’erreur. Malheureusement, comme l’erreur est elle-même inconnue, on
doit la remplacer par un estimateur d’erreur, c’est-à-dire, une quantité qui peut être
facilement calculée et grâce à laquelle on peut estimer l’erreur réelle.
La différence entre deux itérées successives fournit un estimateur d’erreur correct pour la
méthode de Newton. Cela signifie que l’on peut interrompre les itérations à l’étape
telle que
Ceci est un test sur l’incrément

Résumons-nous
1. Les méthodes pour le calcul des zéros d’une fonction f sont généralement itératives ;
2. La méthode de dichotomie permet le calcul d’un zéro d’une fonction f en construisant

une suite d’intervalles dont la longueur est divisée par deux à chaque itération.
Cette méthode est convergente dès que f est continue sur l’intervalle initial et a des
signes opposés aux extrémités de cet intervalle ;
3. La méthode de Newton permet le calcul d’un zéro α de f en faisant appel aux valeurs de
f et de sa dérivée. Une condition nécessaire de convergence est que la donnée
initiale appartienne à un certain voisinage (assez petit) de α;
3- Méthode de point fixe
En s’amusant avec une calculatrice de poche, on peut vérifier qu’en partant de la valeur 1
et en appuyant plusieurs fois de suite sur la touche “cosinus”, on obtient cette suite de
valeurs qui doit tendre vers la valeur α = 0.73908513….
En effet, on a par construction pour k = 0, 1, . . . (avec ). Si cette

suite converge, sa limite α satisfait l’équation cos(α) = α. Pour cette raison, α est appelé point
fixe de la fonction cosinus.

On peut se demander comment exploiter cette procédure pour calculer les zéros d’une
fonction donnée. Remarquons qu’on peut voir α comme un point fixe du cosinus, ou encore
comme un zéro de la fonction f(x) = x−cos(x).
La méthode proposée fournit donc un moyen de calculer les zéros de f. Cependant, toutes les
fonctions n’ont pas un point fixe. Par exemple, en répétant l’expérience précédente avec
l’exponentielle et , on dépasse les capacités de calcul (overflow) après seulement 4
itérations
Figure 3: La fonction φ(x) = cosx admet un point fixe et un seul (à gauche), tandis que
la fonction φ(x) = exp(x) n’en a aucun (à droite)
Précisons ce principe en considérant le problème suivant : étant donné une fonction

φ : [a, b] → R, trouver α [a, b] tel que α = φ(α).
Si un tel α existe, on dit que c’est un point fixe de φ et on peut essayer de le calculer à
l’aide de l’algorithme suivant
(3.1)
Où est une donnée initiale. Cet algorithme est appelé méthode de point fixe ou
itérations de point fixe et on dit que φ est la fonction d’itération. La procédure décrite en
introduction est donc un exemple d’itérations de point fixe avec φ(x) = cos(x).

La Figure 4 (à gauche) montre une représentation graphique de (3.1). Il est raisonnable de
penser que si φ est une fonction continue et si la limite de la suite { } existe, alors cette
limite est un point fixe de φ.
Figure 4. Représentation de quelques itérations de point fixe pour deux fonctions d’itération. A
gauche, la suite converge vers le point fixe α. A droite, la suite diverge

Les itérations de point fixe peuvent ne pas converger, comme le montre la Figure 4 (à
droite). On a le résultat suivant :
Proposition : Considérons la suite (3.1).
1. Supposons que φ(x) est continue sur [a, b] et telle que φ(x) [a, b] pour tout x [a, b] ;
alors il existe au moins un point fixe α [a, b].
2. De plus, si
L < 1 t.q. |φ(x1)−φ(x2)| ≤ L|x1−x2| x1, x2 [a, b],

alors φ admet un unique point fixe α [a, b] et la suite définie en (3,1) converge
vers α, pour toute donnée initiale dans [a, b].
Calcul approché de dérivées et
d'intégrales
Plan
Introduction
Calcul approché de la valeur d'une dérivée
Calcul approché d'intégrales

 Subdivision régulière d'un segment
 Méthode des trapèzes
 Méthode des rectangle
Introduction, Calcul approché de la valeur d'une dérivée, Calcul
approché d'intégrales
1- Introduction
Nous présentons dans ce chapitre des méthodes pour approcher les dérivées et les intégrales
de fonctions. Concernant l’intégration, on sait bien qu’il n’est pas toujours possible, pour une
fonction arbitraire, de trouver la forme explicite d’une primitive. Mais même quand on la
connaît, il est parfois difficile de l’utiliser. C’est par exemple le cas de la fonction
f(x) = cos(4x) cos(3 sin(x)) pour laquelle on a
On voit que le calcul de l’intégrale est transformé en un calcul, aussi difficile, de la somme
d’une série. Dans certains cas, la fonction à intégrer ou à différentier n’est connue que par
les valeurs qu’elle prend sur un ensemble fini de points (par exemple, des mesures
expérimentales).
Dans tous ces cas, il faut considérer des méthodes numériques afin d’approcher la quantité à
laquelle on s’intéresse, indépendamment de la difficulté à intégrer ou à dériver la fonction.
2.1 Calcul approché de la valeur d'une dérivée
Soit f une application réelle dérivable sur un intervalle ouvert ]a,b[ non-vide. La définition
du nombre dérivé f’( ) en ]a; b[ fournit implicitement une méthode de calcul approché
de f’( ) :
Premier algorithme :
function [y]=deriv1(x,h) % calcul approché d’un nombre dérivé
fun=inline('t^2','t')
y=(fun(x+h)-fun(x))/h;
Deuxième algorithme :
function [y]=deriv2(x,h) % calcul approché d’un nombre dérivé :
fun=inline('t^2','t')
y=(fun(x+h)-fun(x-h))/(2*h);
approché d'intégrales, Calcul exact avec syms
Utilisation
>> deriv1(1,0.01) >> deriv2(1,0.01)

fun = fun =
Inline function: Inline function:
fun(t) = t^2 fun(t) = t^2
ans = ans =
2.010000000000001 2.000000000000002
Le résultat exact est ici 2 : on constate que l'approximation est bien meilleure dans le
2eme cas...
Il ne s'agit pas d'un hasard !!!!!! Explication :

Développement de Taylor-Young a l'ordre 2 :
Soit f de classe (c.à.d.. deux fois dérivable et sa dérivée seconde continue) sur un
intervalle ouvert contenant . Alors pour tout h suffisamment proche de 0 :
Puisqu'au voisinage de 0
Tandis que :
(attention O(g) − O(g) = O(g) ≠ 0 en general !).
Lorsque h tend vers 0, converge bien plus rapidement que h vers 0. C'est pourquoi, pour
des valeurs identiques de h (proches de 0), la deuxième méthode donnera en général de
meilleurs résultats que la première : l'erreur est un O( ) plutôt qu'un O(h).
2.2 Calcul approché d'intégrales
2.2.1. Subdivision régulière d'un segment
 Calculer la valeur d'une intégrale est une opération en général difficile. Dans les
applications scientifiques ou en ingénierie il est pourtant nécessaire de calculer
rapidement des valeurs approchées d'intégrale (calcul d'aire, de volume,
physique).
 Le calcul d’une valeur approchée n'est pas très difficile. Les méthodes les plus simples
consistent à subdiviser régulièrement l'intervalle d'intégration pour approcher le
calcul intégral par un calcul d'aires de figures géométriques plus simples (par
exemple dans la méthode des trapèzes).
 C'est pourquoi il est utile de définir la notion de subdivision régulière d'un segment :
Définition :
Soit [a, b] un intervalle non vide et non réduit à un point (i.e. a < b). Soit
∗
; une subdivision régulière de [a, b] en n + 1 points est une suite finie de n + 1
réels : vérifiant :
, et la suite de terme général est stationnaire.
5.2.1. Subdivision régulière d'un segment
Autrement dit : pour tout k [0, n]:
• Sous Matlab on crée facilement une subdivision régulière en n + 1 points de

l'intervalle [a, b] a l'aide de la fonction linspace(a,b,n+1) :
>> x=linspace(1,3,10)
x=
Columns 1 through 9
1.0000 1.2222 1.4444 1.6667 1.8889 2.1111 2.3333 2.5556 2.7778
Column 10
3.0000
2.2.2. Méthode des Trapèzes
Soit une application f réelle : continue sur un intervalle [a, b]. Donné un entier n non nul (et
suffisamment grand), la méthode des trapèzes calcule une valeur approchée de l'intégrale de
f sur [a, b] en approchant le domaine délimité par la courbe représentative de f (l'axe des
abscisses et les droites x = a et x = b) par des trapèzes ayant même hauteur.
Méthode des trapèzes : Si f : [a, b] R est continue :
Soit pour k 0, n] (ainsi ). Si n est assez grand :
est l'aire du trapèze hachure (hauteur × moyenne des bases).

• Un calcul simple de somme fournit une formule plus concise :
En effectuant le changement d'indice k k + 1 dans la deuxième somme :

2.2.3. Méthode des rectangles
Soit une application f réelle : continue sur un intervalle [a, b]. Donné un entier n non nul (et
suffisamment grand), la méthode des rectangles calcule une valeur approchée de l'intégrale
de f sur [a, b] en approchant le domaine délimité par la courbe représentative de f (l'axe des
abscisses et les droites x = a et x = b) par des rectangles.
Méthode des rectangles : Si f : [a, b] R est continue :
Soit pour k 0, n] (ainsi ). Si n est assez grand :
est l'aire du rectangle hachure (hauteur × base).

 Un calcul simple de somme fournit une formule plus concise :

Cours Matlab

Transféré par

Droits d'auteur :

Formats disponibles

Cours Matlab

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Matlab

Transféré par

Droits d'auteur :

Formats disponibles

Université Cadi Ayyad ‫جامعـة القاضـي عيـاض‬

Ecole Nationale des Sciences Appliquées ‫المدرسـة الوطنيـة للعلـوم التطبيقيـة‬

Cours: Outils informatiques

Equipe de Mathématiques et Traitement de l’Information (MTI),

✓ Apprentissage de la programmation avec Matlab

 Chapitre 1: Introduction au calcul scientifique

 Chapitre 2: Présentation du Matlab

 Chapitre 3: Programmation sous Matlab

 Chapitre 4: Initiation au calcul Scientifique

Introduction au calcul scientifique

Python, Octave ……).

Ces deux types de logiciel répondent à deux besoins différents (parfois

Calcul numérique approché

Exemple introductif : On cherche à évaluer de manière numérique l’exponentielle

Solution Trouver approchant numériquement z

Calcul numérique approché

Une méthode consiste à utiliser les séries de Taylor

En considérant des ressources de calcul limitées, on en est réduit à déterminer

Pour le calcul de l’exponentielle, on commet donc une erreur

Exercice: Calcul approché de π

Erreur relatives aux données d’entrée

Erreur d’arrondi générée par la différence entre la valeur exacte x et la valeur

Erreurs résultantes d’un calcul

Erreur d’arrondi dans les étapes d’un calcul (algorithme, programme)

Exemple : on veut calculer avec une calculatrice la somme entre

x1 = 6,2317 107 x2 = 2,179 102

Soit x un résultat exact et un résultat approché. On définit alors

1-Introduction : qu’est ce que Matlab ?

✓ Logiciel de calcul scientifique

1-Introduction : qu’est ce que Matlab ?

- Current Folder : arborescence et liste de fichiers

✓ Pour une documentation plus complète : Help/documentation

2-Premiéres notions : ligne de commande, mode immédiat

>> 2*3 >> pi

✓ Instruction : ensemble structuré d’expressions ou affectation

2-Premiéres notions : ligne de commande, mode immédiat

✓ Instruction : ensemble structuré d’expressions ou affectation

>>y=input(‘texte ’ ,’s’); demande à l’utilisateur de saisir des données texte (chaîne

Dans la fenêtre de commandes :

Dans la fenêtre de commandes : Définition des variables a et b

3- Scripts et fonctions: règles de programmation

Les lignes commentées sont précédées par le caractère %

En pratique, quelques règles à respecter :

✓ Pas de déclaration de variables

✓ Suppression des variables : commande clear

✓ Variables (constantes prédéfinies) :

>> format short, pi^4 % fixe, 5 chiffres

>> format short e, pi^4 % flottante, 5 chiffres

>> format long, pi^4 % fixe, 15 chiffres

>> format long e, pi^4 % flottante, 15 chiffres

On peut définir les opérations suivantes :

1. Si A = ( ) et B = ( ) sont des matrices m×n, la somme de A et B est la matrice A+B

2. Le produit d’une matrice A par un nombre réel ou complexe λ est la matrice λA = (λ );

3. Le produit de deux matrices n’est possible que si le nombre de colonnes de la

Voici un exemple de la somme et du produit de deux matrices :

>> A=[1 2 3; 4 5 6];

>> A=[1 2 3; 4 5 6];

On peut obtenir avec la commande inv(A). L’inverse de A existe si et seulement si

Pour un produit de matrices, on a la propriété suivante :

En particulier, A est inversible si et seulement si pour tout k.

fplot(’h’, [-2pi 2pi])