Chapitre I : Présentation de Matlab

1. Introduction - Historique

2. Démarrage de MATLAB

3. Génération de graphique avec MATLAB
 

MATLAB est une abréviation de Matrix LABoratory. Écrit à l’origine, en Fortran, par C. Moler, MATLAB était destiné à faciliter l’accès au logiciel matriciel développé dans les projets LINPACK et EISPACK. La version actuelle, écrite en C par the MathWorks Inc., existe en version professionnelle et en version étudiant. Sa disponibilité est assurée sur plusieurs plates-formes : Sun, Bull, HP, IBM, compatibles PC (DOS, Unix ou Windows), Macintoch, iMac et plusieurs machines parallèles.

MATLAB est un environnement puissant, complet et facile à utiliser destiné au calcul scientifique. Il apporte aux ingénieurs, chercheurs et à tout scientifique un système interactif intégrant calcul numérique et visualisation. C'est un environnement performant, ouvert et programmable qui permet de remarquables gains de productivité et de créativité.

MATLAB est un environnement complet, ouvert et extensible pour le calcul et la visualisation. Il dispose de plusieurs centaines (voire milliers, selon les versions et les modules optionnels autour du noyeau Matlab) de fonctions mathématiques, scientifiques et techniques. L'approche matricielle de MATLAB permet de traiter les données sans aucune limitation de taille et de réaliser des calculs numériques et symboliques de façon fiable et rapide. Grâce aux fonctions graphiques de MATLAB, il devient très facile de modifier interactivement les différents paramètres des graphiques pour les adapter selon nos souhaits.

L'approche ouverte de MATLAB permet de construire un outil sur mesure. On peut inspecter le code source et les algorithmes des bibliothèques de fonctions (Toolboxes), modifier des fonctions existantes et ajouter d’autres.

MATLAB possède son propre langage, intuitif et naturel qui permet des gains de temps de CPU spectaculaires par rapport à des langages comme le C, le TurboPascal et le Fortran. Avec MATLAB, on peut faire des liaisons de façon dynamique, à des programmes C ou Fortran, échanger des données avec d'autres applications (via la DDE : MATLAB serveur ou client) ou utiliser MATLAB comme moteur d'analyse et de visualisation.

MATLAB comprend aussi un ensemble d'outils spécifiques à des domaines, appelés Toolboxes (ou Boîtes à Outils). Indispensables à la plupart des utilisateurs, les Boîtes à Outils sont des collections de fonctions qui étendent l'environnement MATLAB pour résoudre des catégories spécifiques de problèmes. Les domaines couverts sont très variés et comprennent notamment le traitement du signal, l'automatique, l'identification de systèmes, les réseaux de neurones, la logique floue, le calcul de structure, les statistiques, etc.

MATLAB fait également partie d'un ensemble d'outils intégrés dédiés au Traitement du Signal. En complément du noyau de calcul MATLAB, l'environnement comprend des modules optionnels qui sont parfaitement intégrés à l'ensemble :

    1) une vaste gamme de bibliothèques de fonctions spécialisées (Toolboxes)
    2) Simulink, un environnement puissant de modélisation basée sur les schémas-blocs et de simulation de systèmes dynamiques linéaires et non linéaires
    3) Des bibliothèques de blocs Simulink spécialisés (Blocksets)
    4) D'autres modules dont un Compilateur, un générateur de code C, un accélérateur,...
    5) Un ensemble d'outils intégrés dédiés au Traitement du Signal : le DSP Workshop.

Quelles sont les particularités de MATLAB ?

MATLAB permet le travail interactif soit en mode commande, soit en mode programmation ; tout en ayant toujours la possibilité de faire des visualisations graphiques. Considéré comme un des meilleurs langages de programmations (C ou Fortran), MATLAB possède les particularités suivantes par rapport à ces langages :

• la programmation facile,
• la continuité parmi les valeurs entières, réelles et complexes,
• la gamme étendue des nombres et leurs précisions,
• la bibliothèque mathématique très compréhensive,
• l’outil graphique qui inclus les fonctions d’interface graphique et les utilitaires,
• la possibilité de liaison avec les autres langages classiques de programmations (C ou Fortran).

La bibliothèque des fonctions mathématiques dans MATLAB donne des analyses mathématiques très simples. En effet, l’utilisateur peut exécuter dans le mode commande n’importe quelle fonction mathématique se trouvant dans la bibliothèque sans avoir à recourir à la programmation.

Pour l’interface graphique, des représentations scientifiques et même artistiques des objets peuvent être créées sur l’écran en utilisant les expressions mathématiques. Les graphiques sur MATLAB sont simples et attirent l’attention des utilisateurs, vu les possibilités importantes offertes par ce logiciel.
 

MATLAB peut-il s’en passer de la nécessité de Fortran ou du C ?

La réponse est non. En effet, le Fortran ou le C sont des langages importants pour les calculs de haute performance qui nécessitent une grande mémoire et un temps de calcul très long. Sans compilateur, les calculs sur MATLAB sont relativement lents par rapport au Fortran ou au C si les programmes comportent des boucles. Il est donc conseillé d'éviter les boucles, sutout si celles-ci est grande.

2. Démarrage de MATLAB

Pour lancer l’exécution de MATLAB :

• sous Windows, il faut cliquer sur Démarrage, ensuite Programme, ensuite MATLAB,
• sous d’autres systèmes, se référer au manuel d’installation.

La fonction "quit" permet de quitter MATLAB :

>>quit

La commande "help" permet de donner l’aide sur un problème donné.

Exemple :

>> help cos

COS Cosine.

COS(X) is the cosine of the elements of X.

Autres commandes :

• what : liste les fichiers *.m et *.mat dans le directory utilisé
• who : liste les variables utilisées dans l’espace courant
• ans : réponse retournée après exécution d’une commande

 >>x=[1:5,1]
x =
1 2 3 4 5 1

ou bien :

>>[1:5,1]
ans =
1 2 3 4 5 1

clock : affiche l’année, le mois, le jour, l’heure, les minutes et les secondes.

>>clock
ans =
1.0e+003 *
1.9980 0.0100 0.0180 0.0170 0.0020 0.0098

>>date
ans =
18-Oct-1998

Calcul en mode Commande dans MATLAB :

Soit à calculer le volume suivant :   où R=4cm

Pour calculer V, on exécute les commandes suivantes :

>>R=4
R =
4

>>V=4/3*pi*R^3
V =
268.0826

(Ici, pi=p).

Calcul arithmétique :

+      plus

-      moins

/      division

*      multiplication

Exemple :
x=2, 

>>x=2
x =
2

>>P=(4*x^2-2*x+3)/(x^3+1)
P =
1.6667

Test ‘if’  Ce test s'emploie, souvent, dans la plupart des programmes. Un test ‘if’ est toujours suivi par un ‘end’.

Exemple :

>>V=268.0826
V =
268.0826

>>if V>150, surface=pi*R^2, end
surface =
50.2655

L’opérateur ‘NON’   Il est noté (ou symbolisé) par ‘~=’

Exemple :

>>R=4
R =
4

>>if R~=2, V=4/3*pi*R^3;end

L’opérateur ‘égal’ (==) dans ‘if’  Il est noté (ou symbolisé) par ‘==’.

Exemple :

>>R=4
R =
4

>>if R==4, V=4/3*pi*R^3;end

L’opérateur ‘ou’   Il est noté (ou symbolisé) par ‘|’

Exemple :  Si R=4 ou m=1, alors 

>>if R==4 | m==1, V=4/3*pi*R^3;end

Autres opérateurs :

>      supérieur à

<     inférieur à

>=    supérieur ou égal

<=    inférieur ou égal
 

>  supérieur à	.* produit élément par élément de matrices
<  inférieur à	.^ puissance élément par élément de matrices
>=supérieur ou égal	./ division élément par élément de matrices
<=inférieur ou égal	xor OU exclusif (XOR)
Error affiche le message :  'error'	message spécifié, émet un 'bip' et interrompt l'exécution du programme

Exemples :

Si g>2 ou g<0, alors a=4

>> if g>2 |g<0, a=4, end

Si a>3 et C<0, alors b=15

>>if a>3 & c<0, b=15, end

Les opérateurs ‘&’ et ‘|’ peuvent être utilisés dans la même chaîne :

>>if ((a==2 | b==3)&(c<5),g=1,end

L’opérateur ‘if…….else…….elseif…….end’:

Exemples :

>>R=2, if R>3, b=1 ; elseif R==3, b=2, else b=0, end

l’instruction ‘elseif’ peut être répétée dans un programme autant de fois.
 

Variables et noms de variables :

Les variables et les noms de variables n’ont pas à être déclarés, car dans MATLAB, il n’y a aucune distinction entre variable ‘entière’, variable ‘réelle’ ou variable ‘complexe’.

Variables complexes :

Traditionnellement, en Fortran les variables i, j, k, l, m et n sont réservées aux variables entières. Dans MATLAB, i et j sont réservées aux unités imaginaires ( ou ). Mais, on peut également les utiliser commes d'autres variales (entières ou réelles) si on les précise.

Dans le tableau ci-dessous, on dresse les noms de variables et les nombres spéciaux utilisés par MATLAB :
 

Nom de la variable	Signification	Valeur
eps	précision relative des nombres réels (distance entre 1.0 et le nombre réel flottant le plus proche)	2.2204.10-16
pi	p	3.14159………..
i et j	unités imaginaires
inf	nombre infini (1/0=inf)
NAN	ce n’est pas un nombre : 0/0=NAN
date	date
nargin	nombre d’arguments d'appel transmis à une fonction
flops	compteur opérations en virgule flottante
nargout	nombre d’arguments de retour demandés à une fonction

Opérateurs ‘for/end’ et ‘while/end’

Exemples :

>>for R=1 :5, V=4/3*pi*R^3; disp([R,V]), end

Dans ce cas, R varie de 1 à 5, et la commande "disp([R,V])" retourne la matrice suivante :
[R=1 :5,V (V(1) :V(5)]

On peut définir également l’instruction ‘length’ qui représente la taille de la variable. En effet, dans ce cas, on a :
length(R)=5 ; (R=1 :5) et length(R)-1=4 (4 intervalles de pas 1).

>>while R<5, R=R+1 ; V=4/3*pi*R^3; disp([R,V]), end

while exécute l’instruction qui suit tant que le test logique est vrai.

Exemple de pas dans la boucle for :

>>for R=5 :-1 :1, V=4/3*pi*R^3; disp([R,V]), end

Ici, le pas utilisé est dégressif (=-1). On peut utiliser les imbrications de ‘for’ autant de fois que l’on souhaite.

Exemple :

>> for i=0 :10, for j=1 :5, V=4/3*pi*R^3;disp([R,V]);end,end
 

* format :

>>format à affiche les résultats avec 4 chiffres après la virgule.
>>format long à affiche les résultats avec 16 chiffres après la vrgule.

* break :

Interrope l’exécution d’un ‘for’ ou d’un ‘while’

* goto :

Dans MATLAB l’instruction ‘goto’ est remplacée par ‘break’.

Exemple :

while R==1
.
.
.
if x>Xlimite, break, end
.
.
.
.
end
 

* clear :

Efface toutes les variables existantes en mémoire
 

* clc :

Efface l’écran (fenêtre) de MATLAB
 

* input(' ') :

Introduire une ou des variables par l’intermédiaire du clavier.

Exemple :

>>z=input(‘Longueur L=’);

retourne :
Longueur L=
 

>>y=input(‘Introduire votre nom’,’s’);

Le second argument indique que la variable à introduire peut être un (ou des) caractère(s).
 

* fprintf(' ')

format de sortie sur écran

Exemples :

1. fprintf(‘La longueur L=%f\n’,L)

Dans cette chaîne, on a :

%    à     pour la sortie de la variable,
f      à     format de sortie
\n    à     retour à la ligne
L     à  variable.

2. fprintf(‘La longueur L= %e%f\n’,L)

le résultat affiché est avec des puissances de 10 (exemple : 2.5e04)

3. fprintf(‘Nom_fichier’,’Volume= %e%12.5f\n’,V)

écrit la valeur = variable V dans un fichier Nom_fichier.
la variable V est avec 5 chiffres après la virgule.

Pour l’ouverture et la fermeture des fichiers, on peut utiliser également ‘fopen’ et ‘fclose’. Ainsi, on peut joindre à l’ouverture de fichier par exemple, la permission d’ouvrir uniquement, de lire uniquement, de lire et écrire, etc.

Exemple :

>>fich=fopen(‘Nom_fichier’,’ ?’)

? à représente la permission :
                        ‘w’     à   écriture : créer si nécessaire,

                        ‘r’      à lecture uniquement (pas de création),

                        ‘+r’    à lecture et écriture.
 

Ecriture d’un fichier ou de variables dans un fichier :

Ouvrir tout d’abord le fichier :

>>fich=fopen(‘Nom_fichier’,’ r’) ; y=fscanf(fich,’%f’)

La variable y est maintenant égale à la (ou les) variable(s) de fich.

Produit factoriel :

La fonction ‘gamma’ donne le produit factoriel d’un nombre n.
Exemple : pour n=6, on a : 6!=6*5*4*3*2*1=720

>>factorielle=gamma(6+1)
factorielle =
720

La fonction ‘gamma’ peut calculer la factorielle des nombres entiers et même des nombres réels.
 

Utilisation de nombres ou de variables complexes :

MATLAB, peut utiliser et gérer les variables ou les nombres complexes. La plupart des fonctions implicites définies pour les réels existent pour les complexes, y compris la puissance.

Exemple :

>>z=3.5-1.25i ;

>>log(z)
ans =
1.3128 - 0.3430i

>>cos(2-i)
ans =
-0.6421 + 1.0686i

L’imaginaire pur est noté par i ou j. Ainsi, i² ou j² donne :

>>i^2
ans =
-1.0000 + 0.0000i

Soit z un nombre complexe. Son conjugué est donné par la fonction ‘conj(z)’.

>>z=3.5-1.25i
z =
3.5000 - 1.2500i

>>conj(z)
ans =
3.5000 + 1.2500i

Opérations sur les nombres complexes :

1. Addition de nombres complexes :

>>z1
z1 =
3.5000 - 1.2500i

>>z2
z2 =
1.3140 - 0.0948i

>>z1+z2
ans =
4.8140 - 1.3448i

2. Soustraction de nombres complexes :

>>z1-z2
ans =
2.186 - 1.1552i

3. Multiplication de nombres complexes :

>>z1*z2
ans =
4.4805 - 1.9743i

4. Division de nombres complexes :

>>z1/z2
ans =
2.7181 - 0.7551i

5. Opération de puissance :

>>z1^z2
ans =
4.5587 - 2.9557i

5. Module et argument d’un nombre complexe :

Dans MATLAB, les fonctions ‘abs’ et ‘angle’ permettent l’obtention directe du module et de l’argument d’un nombre complexe.

Exemple :

>>r=abs(z1)
r =
3.7165

>>theta=angle(z1)
theta =
-0.3430

L’angle theta est en radians.

Il est possible d’utiliser la notation exponentielle.

Exemple :

>>Z=exp(z1)

Z =
10.4420 -31.4261i

Comme on peut définir des tableaux ou des matrices de réels, il est aussi possible de définir des tableaux ou de matrices complexes avec MATLAB.

Exemples :

>>Z=[1+2i 0 z1;1 z2 z1+z2;z1*z2 z1-z2 z1/z2]

Z =
1.0000 + 2.0000i 0 3.5000 - 1.2500i
1.0000 1.3140 - 0.0948i 4.8140 - 1.3448i
4.4805 - 1.9744i 2.1860 - 1.1552i 2.7181 - 0.7551i

On peut également faire des opérations arithmétiques sur les matrices :

>>A=Z^(-1)
A =
0.2279 - 0.1872i -0.2475 + 0.1665i 0.1564 - 0.0282i
-0.6237 + 0.3429i 0.4146 - 0.4741i 0.0537 + 0.3314i
0.1251 - 0.0321i 0.1174 + 0.1358i -0.0282 - 0.0914i

>>A*Z
ans =
1.0000 + 0.0000i -0.0000 + 0.0000i -0.0000 + 0.0000i
0.0000 1.0000 - 0.0000i 0.0000 - 0.0000i
-0.0000 - 0.0000i 0.0000 - 0.0000i 1.0000 + 0.0000i

>>A/Z
ans =
0.1328 - 0.2826i -0.0267 + 0.2886i -0.0451 - 0.1223i
-0.1566 + 0.6725i 0.0057 - 0.5356i 0.1202 + 0.1689i
-0.1037 - 0.0857i 0.0965 + 0.0148i -0.0276 + 0.0428i

Déclarations et affectations des variables :
 

fprintf(‘caractère : %c\n’,c) ; fprintf(‘entier: %d\n’,i) ; fprintf(‘flottant: %f\n’,f) ; fprintf(‘flottant: %s\n’,s) ; Il existe également d’autres types d’affectations. Ces dernières sont analogues à celles du langage ‘C’.

c=’#’ i=1, 2, 3, … , n à des entiers par exemple (si ) s : la valur peut être la plus petite que posssible. Exemple : s=1.35e-17.

Arrangement de variables :

Une matrice d’ordre 0 est un scalaire. Une matrice d’ordre 1 est un vecteur. Ce vecteur peut être un vecteur ligne ou un vecteur colonne.

Exemples :

>>x=[0,1,2,3]  à retourne un vecteur ligne :
x =0 1 2 3

ou encore :

>>x=[0 1 2 3]  à retourne aussi un vecteur ligne.

x(2)=1 par exemple.

>>x=[0 ;1 ;2 ;3]  à retourne un vecteur colonne.
x =
0
1
2
3

>>x=[0 ;1 ;2 ;3]’  à retourne un vecteur ligne.

>>x=[0 1 2 3]’  à retourne un vecteur colonne. x(1)=0, x(2)=1, x(4)=3.

Remarque :

Dans MATLAB, les numéros de lignes ou de colonnes commencent toujours par 1 et non par zéro comme c’est le cas dans les autres langages de programmation. Exemple : x(0) n’existe pas.

Matrice d’ordre supérieur à 1 :

Une matrice d’ordre supérieur à 1 est une matrices à deux dimensions. Exemple : x(i,j).

Exemples :

>>x=[0 :2 ;4 :6]  à retourne :
x =
0 1 2
4 5 6

C’est une matrice à 2 lignes et 3 colonnes.

>>y=[0 :2 ;4 :6]’  à retourne la matrice transposée :
y =
0 4
1 5
2 6

La taille de la matrice y est donnée par la fonction ‘size(y)’ :
>>size(y)
ans =
3 2
La réponse est : 3 lignes et 2 colonnes.

La colonne j de la matrice x est donnée par : y(:,j) à pour j=2, on a :
y(:,2)=
4
5
6

La ligne i de la matrice x est donnée par : y(i,:) à pour i=2, on a :
y(2,:)=
5

Pour une matrice carrée A d’ordre n, on a sa matrice identité qui est donnée par la fonction ‘eye’.
Exemple : pour n=3, on a :

>>A
A =
1 2 3
4 5 6
6 7 8

>>eye(size(A))
ans =
1 0 0
0 1 0
0 0 1

 eye(size(A)) donne la matrice identité de même ordre que celle de A.

Aspect des nombres dans MATLAB :

Dans MATLAB, il n’existe aucune distinction entre les nombres entiers, les nombres réels ou le nombres complexes. Les nombres sont donc traités automatiquement. La précision des calculs est affectée par le nombre de variables enregistrées et traitées.
Les paramètres essentiels qui déterminent cette précision dans un langage de programmation sont :

• le plus petit nombre positif : x_min
• le plus grand nombre positif : x_max
• l’erreur de la machine (epsilon) : eps

Dans MATLAB, l’infini est représenté par ‘inf’ (=). Si on exécute la commande x=1/inf, la réponse sera ‘NAN’ c’est à dire : ‘Not A Number’.

Pour chercher x_min, x_max et eps, on peut utiliser les programmes suivants :

Cherche de x_min :
% Recherche de de x_min
x=1 ; while x>0, x=x/2, end

Cherche de x_max :
% Recherche de de x_max
x=1 ; while x<inf, x= x*2, end

Cherche de eps :
% Recherche de de eps
x=1 ; while x>0, x=x/2 ; ex=0.98*x+1,ex=ex-1, if ex>0,ex ;end,end

Fonctions Mathématiques dans MATLAB :
 

Fonctions trigonométriques	Remarques
sin(x)
cos(x)
tan(x)
asin(x)
acos(x)
atan(x)
atan2(x,y)	:
sinh(x)
cosh(x)
tanh(x)
asinh(x)
acosh(x)
atanh(x)

Autres fonctions mathématiques (élémentaires)	Remarques
abs(x)	Valeur absolue de x
angle(x)	Valeur complexe de l’angle de phase : Si x=réel à angle=0 Si à angle=p/2
sqrt(x)	Racine carrée de x
real(x)	Partie réelle de la valeur complexe de x
imag(x)	Partie imaginaire de la valeur complexe de x
conj(x)	Complexe conjugué de x
round(x)	Arrondi entier de x
fix(x)	Arrondi par défaut du réel x
floor(x)	Arrondi au voisinage de  du réel x
ceil(x)	Arrondi au voisinage de  du réel x
sign(x)	=+1 six>0 ; =-1 si x<0
rem(x,y)	Le reste de la division : = x-y*fix(x/y)
exp(x)	Exponentielle (de base e)
log(x)	Log (de base e)
log10(x)	log (de base 10)

Autres fonctions :

Soit x=[2 15 0] une matrice ligne (vecteur ligne)

sort(x) à donne une matrice ligne dont les éléments sont en ordre croissant :

>>sort(x)
ans =
0 2 15

sort(x’) à donne une matrice colonne dont les éléments sont en ordre croissant :

>>sort(x’)
ans =
0
2
15

sum(x) calcule la somme des éléments de la matrice x.

>>sum(x)
ans =
17

>>sum([4 2 1 0;8 9 3 12])
ans =
12 11 4 12

Pour trouver le maximum et le minimum du vecteur x, on utilise les fonctions max(x) et min(x) :

>>max(x)
ans =
15

>>min(x)
ans =
0

pour une matrice y quelconque, le max(y) et min(y)  donnent :

>>y
y =
4 2 1 0
8 9 3 12

>>max(y)
ans =
8 9 3 12

>>min(y)
ans =
4 2 1 0

Pour trouver la valeur moyenne d’un vecteur de la matrice x par exemple, on utilise la fonction ‘mean(x,i)’où i est le numéro de la colonne :

Exemple : si 

Alors mean(x,1) est :

>>mean(x,1)
ans =
1.5000 2.5000 3.5000

et mean(x,2) est :

>>mean(x,2)
ans =
1 4

* Nombres aléatoires :

Les nombres aléatoires peuvent être générés par la fonction ‘rand’. Son expression est ‘rand(n)’ où n est le rang de la matrice.
Si n=3 par exemple, rand(3) va générer 3 lignes et 3 colonnes de la matrice dont les coefficients sont aléatoires et compris entre 0 et 1.

Exemple :

>> rand(3)
ans =
0.4154 0.0150 0.9901
0.3050 0.7680 0.7889
0.8744 0.9708 0.4387

On peut donner à la variable z une initialisation dans un programme. Pour cela, on peut générer des valeurs aléatoires grâce à la fonction ‘seed’ (c’est à dire ensemencer) à rand(‘seed’,z)
 

* Écriture de fonctions personnelles :

Dans MATLAB, les programmes qui sont sauvegardés comme des fichiers_.m sont équivalentes à des sous-programmes et des fonctions dans d’autres langages.

Fonction retournant une seule variable :

Exemple : 

Supposons que le programme MATLAB correspondant est sauvegardé sous le nom demof_.m. ce programme est le suivant :

function y=demof_(x)
y=(2*x.^3+7*x.^2+3*x-1)/(x.^2-3*x+5*exp(-x)) ;

Pour déterminer f(x=3) par exemple, il suffit d’exécuter la commande : "y=demof_(3),et la réponse sera :

>>y=
502.1384

* Fonction retournant plusieurs variables :

Une fonction peut retourner plus qu’une variable. Considérons la fonction qui permet d’évaluer la moyenne et l’écart type de données.
Pour retourner les 2 variables, un vecteur est utilisé du côté gauche de la fonction, comme l’illustre le cas suivant :

function [mean, stdv]=mean_st(x)
n=length (x) ;
mean=sum(x)/n ;
stdv=sqrt(sum(x.^2)/n-mean.^2) ;

Exemple :

>>x=[1 5 3 4 6 5 8 9 2 4];
>>[m,s]=mean_st(x)

La réponse est : m=4.7000 et s=2.3685

* Fonction pouvant utiliser une autre :

Exemple : 

Le sous programme de la fonction f_av est donné ci-dessous :

function wa=f_av(f_nom,a,b,c)
wa=(feval(f_nom,a)+2*feval(f_nom,b)+feval(f_nom,c))/4 ;
où f_nom est le nom de la fonction f(x).

la fonction ‘feval’ est une commande de MATLAB qui évalue la fonction de nom f_nom et d’argument x . Exemple : y=feval(‘sin’,x) est équivalente à y=sin(x).

* Écriture d’un programme MATLAB :

En MATLAB, les programmes se terminent par une extension ‘.m’ dans le nom du fichier programme. Aucune compilation n’est à faire avant l’exécution du programme. Au cours de l’exécution, un message d’erreur apparaît et indique les lieux où se trouvent les erreurs.
Pour lancer l’exécution du programme, il faut se mettre toujours dans le même répertoire où se trouve ce programme.

Exemple : ce dernier se trouve dans c:\utilisateur ; il faut changer tout d’abord de répertoire après avoir lancé MATLAB en tapant :
"cd c:\utilisateur"

Les fichiers de données sont enregistrés avec une extension ‘.mat’ et les variables sont enregistrées en double précision.

3. Génération de graphique avec MATLAB

MATLAB est un outil très puissant et très convivial pour la gestion des graphiques, que ce soit en une dimension, en deux dimensions ou en trois dimensions. Pour tracer une courbe y=sin(x) par exemple, où x=0 :50 ; il suffit de faire :

>>x=0:50;y=sin(x);plot(x,y)

Ci-dessous, un petit résumé très succinct est donné pour tracer, concernant le traçage des graphiques et la manipulation des axes et des échelles :

• xlabel(‘temps’) à pour donner un titre à l’axe x,
• ylabel(‘vitesse’) à pour donner un titre à l’axe y,
• title(‘évolution de la vitesse’)à pour donner un titre au graphique,
• text(2,4,’+++Température T1’) à au point , écrire la légende de la courbe tracée avec "+++",
• loglog(x,y) à tracer la courbe en échelle logarithmique (log-log),
• semilogx(t,f(t)) à tracer la courbe seulement en échelle logarithmique suivant x,
• semilogy(t,f(t)) à tracer la courbe seulement en échelle logarithmique suivant y,
• grid on à afficher le quadrillage dans le graphique,
• grid off à masquer le quadrillage dans le graphique,
• clf à effacer le graphique,
• close figure(i) à fermer (ou quitter) la figure (i),
• close all  à fermer tous les graphiques ouverts,
• plot(x,y,x,z,x,w) à tracer y, z et w en fonction de x sur le même graphe,
• polar(x,y) à tracer la courbe y en fonction de x en coordonnées polaires,
• plot(x,y,’+g’) à tracer y en fonction de x avec des marques ‘+’ en couleur verte,
• fplot(‘f_nom’,[x-mini, x-maxi]) à tracer la fonction f_nom selon les axes données (x),
• axis(‘square’) à tracer un graphe géométriquement carré,
• axis(‘off’) à masque les axes x et y,
• axis(‘on’) à affiche les axes x et y,
• axis([x-mini, x-maxi, y-mini,y-maxi]) à affiche le graphique selon les limites

données des axes x et y,
• hold(‘on’) à traçage des courbes sur le même graphique à chaque fois qu’on exécute la fonction plot,
• hold(‘off’) à traçage de chaque courbe sur un nouveau graphique à chaque fois qu’on exécute la fonction plot,
• plot3(x,y,z) à tracer z en fonction de x et de y en 3D,
• la fonction ‘meshgrid’ est utilisée pour créer un maillage 2D (x,y) ; si on se donne xa=[… : …] et ya=[… : …], ceci est très important sont des valeurs complexesà [x,y]=meshgrid(xa,ya),

• mesh(xa,ya,z) à tracer le graphique en 3D de z,
• quiver(x,y,u,v,s) à tracer le champ vectoriel  dans le plan (x,y) où ‘s’ est la taille de base à donner aux vecteurs,
• contour(x,y,z,’niveau’) à tracer les lignes iso-valeurs de z dans le plan (x,y) où le niveau représente le nombre de lignes iso-courbes.

• text(2,0,’a-b’,’FontName’,’symbol’) à écrire sur le graphique au point 

• subpot(m,n,k) à tracer mxn graphiques séparés dans la feuille, où k est le numéro de chaque graphiques. Exemple :