Programmer sous MATLAB

• Scripts et fonctions
• Op�rateurs de comparaison et op�rateurs logiques
• Instructions de contr�le
  • Boucle FOR : parcours d'un intervalle
  • L'instruction conditionn�e IF
  • Choix ventil�, l'instruction switch
  • L'interruption d'une boucle de contr�le
• Un exemple complet

Scripts et fonctions

Les fichiers de fonctions ont deux r�les. Ils permettent � l'utilisateur de d�finir des fonctions qui ne figurent pas parmi les fonctions incorpor�es de MATLAB (<< built-in functions >>) et de les utiliser de la m�me mani�re que ces derni�res (ces fonctions sont nomm�es fonctions utilisateur).   Ils sont �galement un �l�ment important dans la programmation d'applications o� les fonctions jouent le r�le des fonctions et proc�dures des langages de programmation usuels.
 

On d�finit la fonction fonc de la mani�re suivante:

o�

• vars₁, ..., vars_m sont les variables de sortie de la fonction;
• vare₁, ..., vare_n sont les variables d'entr�e de la fonction;
• s�quence d'instructions est le corps de la fonction.

Dans l'exemple qui suit, on d�finit une fonction modulo qui calcule la valeur de a modulo n en prenant pour syst�me de r�sidus {1, 2, ..., n} au lieu de {0, 1, ..., n-1} (syst�me de r�sidus consid�r� par la fonction incorpor�e mod). Les lignes qui suivent doivent �tre enregistr�es dans un fichier de nom modulo.m.

function [r,q] = modulo(a,n)

% Calcule la valeur de a modulo n en prenant pour systeme de residus
% 1, ... , n au lieu de 0, ... , n-1.
%
% appel : [r,q] = modulo(a,n)
%
% Arguments de sortie :
%  r : le residu
%  q : le quotient

q = floor(a./n);
r = a - n*q;

% si le reste de la division entiere vaut 0, le residu vaut par convention n 
if r == 0, r = n; end

>> help modulo

 Calcule la valeur de a modulo n en prenant pour systeme de residus
 1, ... , n au lieu de 0, ... , n-1.

 appel : [r,q] = modulo(a,n)

 Arguments de sortie :
  r : le residu
  q : le quotient

>>

>> b = 10 ; m = 4;
>> [r,q] = modulo(b,m)
r =
     2
q =
     2  
>> modulo(10,5)
ans =
     5
>>

Remarques:

1. Il n'y a pas de mot-cl� (par exemple end) pour indiquer la fin de la fonction. La fonction est suppos�e se terminer � la fin du fichier. Il est toutefois possible de provoquer un retour au programme appelant dans le corps de la fonction gr�ce � la commande return.
2. On ne peut �crire qu'une seule fonction par fichier (qui doit porter le nom de cette fonction). Toutefois dans la version 5 de MATLAB existe la notion de << sous-fonction >>. Une sous-fonction est une fonction �crite dans le m�me fichier qu'une autre fonction (dite principale) et qui ne sera utilisable que par cette fonction principale (une sous-fonction ne peut pas �tre appel�e par un autre sous-programme que la fonction principale).
3. Si le fichier ne commence pas par le mot-cl� function on a tout simplement �crit un script!

La gestion des variables d'entr�e et de sortie est tr�s souple sous MATLAB. Si l'on n'est int�ress� que par le r�sidu et pas par le quotient, on peut se contenter de ne mettre qu'une seule variable de sortie, v = modulo(10,4). Dans cet appel la variable v contiendra le r�sidu (la premi�re variable de sortie). Par contre, m�me si l'on ne souhaite recueillir que le quotient, on est oblig� d'effectuer un appel de la forme [r,q] = modulo(10,4) et donc de d�finir une variable inutile. Aussi, d'une mani�re g�n�rale, il est bon de ranger les variables de sortie par ordre << d'importance >>. Il est �galement possible d'appeler une fonction donn�e avec moins de variables d'entr�e que le nombre indiqu� pour la d�finition de la fonction (il faut bien entendu que le corps de la fonction soit programm� de sorte de pr�voir cette �ventualit�). Il existe deux fonctions MATLAB utiles pour g�rer cette situation: nargin qui retourne le nombre de variables d'entr�e utilis�s lors de l'appel et nargout qui retourne le nombre de variables de sortie pr�vues lors de l'appel. Voici un petit exemple venant illustrer ces possibilit�s.

function [A,rang] = matale(T,m,n)

% Construit une matrice A de m lignes et n colonnes ayant des elements
% entiers generes de maniere aleatoire entre 0 et T.
% Calcule le rang de la matrice si l'appel est effectue avec 2 arguments
% de sortie.
% Si la matrice est carree, le parametre n peut etre omis.
%
% Appels:
%       [A,r] = Matale(T,m,n)
%       [A,r] = Matale(T,m)
%           A = Matale(T,m,n)
%           A = Matale(T,m)

if nargin == 2
  A = fix(T*rand(m));
else
  A = fix(T*rand(m,n));
end

if nargout == 2
 rang = rank(A);
end

>> [A,r] = matale(20,3,4)
A =
    16    13    13    10
    10    16     7    14
     4     0    16     8
r =
     3   
>> [A,r] = matale(20,3)
A =
    12     0    18
     5    14     9
     3     8     8
r =
     3 
>> A = matale(20,3)
A =
     8     7     2
    17    16     4
     1     0     3    
>>

Un point important concerne la gestion des variables entre le programme principal (ou le workspace) et les fonctions de l'utilisateur. Toutes les variables d�finies � l'int�rieur d'une fonction sont des variables locales � cette fonction. La communication avec des variables du programme principal (ou du workspace) ou avec des variables d'autres fonctions se fait uniquement par les variables d'entr�e et sortie de la fonction. Une alternative existe toutefois: il est possible de d�clarer certaines variables comme des variables globales . Une variable globale peut �tre partag�e entre un programme principal et plusieurs fonctions sans qu'il soit besoin de la sp�cifier parmi les variables d'entr�e-sortie des diff�rentes fonctions. On d�clare une variable globale gr�ce au mot cl� global. Par exemple pour d�clarer la variable numex globale on �crit global numex. Attention, la d�claration global numex doit �tre reprise dans chaque fonction utilisant numex comme variable.

Op�rateurs de comparaison et op�rateurs logiques

Les op�rateurs logiques sont:
 
 

&	:	et (x & y)
|	:	ou (x | y)
~	:	non (~ x)

Les op�rateurs de comparaison et les op�rateurs logiques sont utilis�s essentiellement dans les instructions de contr�le, voir le paragraphe 5.3.

  
Instructions de contr�le

  
Boucle FOR : parcours d'un intervalle

Syntaxe :

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 fois, pour les valeurs de la variable indice �gales � borne_inf, borne_inf+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 :
L'indice de boucle ne prend pas n�cessairement des valeurs enti�res. D'autre part il n'est pas n�cessaire que l'indice de la boucle apparaisse dans le corps de la boucle; par contre il est interdit de modifier sa valeur s'il appara�t. Il est possible d'imbriquer des boucles mais elles ne doivent pas se recouvrir. 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. Attention � bien g�rer la borne sup�rieure! Voici un exemple (idiot) venant illustrer les possibilit�s de variations de l'indice de la boucle

>> for r=1.1:-0.1:0.75
     disp(['r = ', num2str(r)]);
   end
r = 1.1
r = 1
r = 0.9
r = 0.8  
>>

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

  
Boucle WHILE : tant que . . . faire

Syntaxe :

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.

Interpr�tation :
Tant que expression logique est vraie le traitement s�quence d'instructionsest 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).
 

Remarque :
expression logique est en g�n�ral le r�sultat d'un test (par exemple i < Imax) ou le r�sultat d'une fonction logique (par exemple all(x)). Il est imp�ratif que le traitement de la s�quence d'instructions agisse sur le r�sultat de expression logique sans quoi on boucle ind�finiment (-:.
 

Voici comment calculer n! avec une boucle while:

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

  
L'instruction conditionn�e IF

L'instruction conditionn�e la plus simple a la forme suivante:

Syntaxe :

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.
 

Remarque :
Contrairement � certains langages de programmation, il n'y a pas de mot cl� << then >> dans cette instruction conditionn�e. Notez �galement que la marque de fin de bloc conditionn� est le mot cl� end et non pas<< endif >>.
 

Il existe une s�quence conditionn�e sous forme d'alternatives:

Syntaxe :

o�

• expression logique est une expression dont le r�sultat peut �tre vrai ou faux;
• s�quence d'instructions 1 est la s�quence d'instructions � ex�cuter dans le cas o� expression logique est vraie et s�quence d'instructions 2 est la s�quence d'instructions � ex�cuter dans le cas o� expression logique est faux.

Interpr�tation :
Si expression logique est vraie la s�quence d'instructions 1 est ex�cut�e, sinon c'est la s�quence d'instructions 2 qui est ex�cut�e. Le d�roulement du programme reprend ensuite � la premi�re instruction suivant le mot cl� end.
 

Il est bien entendu possible d'imbriquer des s�quences d'instructions conditionn�es (au sens o� la s�quence d'instruction conditionn�e contient des s�quences d'instructions conditionn�e). Pour une meilleure lisibilit�, il est recommand� d'utiliser des indentations afin de mettre en �vidence l'imbrication des s�quences d'instructions conditionn�es.
 

Il est possible d'effectuer un choix en cascade:

Syntaxe :

Interpr�tation :
Si expression logique 1 est vraie la s�quence d'instructions 1 est ex�cut�e et le programme reprend ensuite � la premi�re instruction suivant le mot cl� end, sinon si expression logique 2 est vraie la s�quence d'instructions 2 est ex�cut�e et le programme reprend ensuite � la premi�re instruction suivant le mot cl� end, etc. Si aucune des expressions logiques 1 � N n'est vraie alors s�quence d'instructions par d�faut est ex�cut�e.
 

Remarque :
Attention � ne pas laisser d'espace entre else et if; le mot cl� est elseif.
 

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:

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

  
Choix ventil�, l'instruction switch

Syntaxe :

o�

• var est une variable num�rique ou une variable cha�ne de caract�res;
• cst₁, ..., 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 le contenu de la variable var est �gal � la constante cst_i (var==cst_i).

Interpr�tation :
Si la variable var est �gale � l'une des constantes cst₁, ..., 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 est ex�cut�e.
 

Remarque :
La variable var doit bien entendu �tre du m�me type que les constantes cst₁, ..., cst_N.
Il n'est pas n�cessaire de pr�voir un cas par d�faut (bien que cela soit pr�f�rable). S'il n'y a pas de cas par d�faut et si la variable var n'est �gale � aucune des constantes, alors le programme continue � la premi�re instruction suivant le mot-cl� end.
Il est possible de regrouper plusieurs << cas >> si la s�quence d'instructions � ex�cuter est la m�me pour ces diff�rents cas. La syntaxe est alors,

Reprenons l'exemple o� l'on souhaite initialiser une matrice A en fonction de la valeur prise par une variable num�rique numex (num�ro d'exemple). En utilisant un choix ventil� on obtient:

function  A = initA(n,numex)

switch numex
  case 1,
    A = ones(n)
  case 2,
    A = magic(n);
  case {3,4},
    A = rand(n);
  otherwise
    error('numero d''exemple non prevu ...');
end

rep = input('Votre reponse (oui, non, chepas) :');

switch rep
  case {'oui','o'},
    disp('bravo ...');
  case {'non','n'}
    disp('perdu ...');
  case 'chepas'
    disp('c''est pourtant facile ...');
end

Interruption d'une boucle de contr�le

L'instruction errorpermet d'arr�ter un programme et d'afficher un message d'erreur. La syntaxe est error(' message d''erreur '). L'instruction warning permet d'afficher un message de mise en garde sans suspendre l'ex�cution du programme. La syntaxe est warning(' message de mise en garde '). Il est possible d'indiquer � MATLAB de ne pas afficher les messages de mise en garde d'un programme en tapant warning off dans la fen�tre de commandes. On r�tablit l'affichage en tapant warning on.
 

On peut ainsi am�liorer la fonction matale de la mani�re suivante:

function [A,rang] = matale(T,m,n)
% Construit une matrice A de m lignes et n colonnes ayant des elements
% entiers generes de maniere aleatoire entre 0 et T.
% Calcule le rang de la matrice si l'appel est effectue avec 2 arguments
% de sortie.
% Si la matrice est carree, le parametre n peut etre omis.
%
% Appels:
%       [A,r] = Matale(T,m,n)
%       [A,r] = Matale(T,m)
%           A = Matale(T,m,n)
%           A = Matale(T,m)

% si la fonction est appelee avec un nombre d'arguments d'entree
% different de 2 ou 3, on arrete tout ...
if nargin ~= 2 &  nargin ~= 3,
   error(' La fonction matale doit avoir 2 ou 3 arguments d''entree ');
end

if nargin == 2
  A = fix(T*rand(m));
else
  A = fix(T*rand(m,n));
end

if nargout == 2
  rang = rank(A);
  if nargin == 2,
    rangx = m;
  else
    rangx = min([m,n]);
  end
  if rang ~= rangx, warning(' Le rang n''est pas maximum '); end;
end

>> A = matale(3);
??? Error using ==> matale
 La fonction matale doit avoir 2 ou 3 arguments d'entree
 
>> A = matale(20,3)
A =
     8    18     8
    12    14    18
    15     3    18 
>> [A,r] = matale(20,3)

Warning:  Le rang n'est pas maximum
> In /home0/maths/balac/DOCMATLAB/matale.m at line 34
A =
     1     4     3
    10    15    11
     3    12     9
r =
     2  
>>

Un exemple complet

Notons l(x) le num�ro de la ligne et c(x) le num�ro de la colonne du carr� sur lequel se trouve l'entier x. Partant d'un carr� d'ordre impair n=2k+1, la technique de Moschopoulos peut se formuler comme suit:

• Initialisation de l'algorithme en pla�ant l'unit� dans la case imm�diatement au dessous de la case centrale, autrement dit � l'intersection de la (k+1) �me colonne et de la (k+2) �me ligne:

• Connaissant la position (l(x), c(x)) de l'entier x, on place l'entier x+1 suivant les r�gles suivantes:

si x n'est pas un multiple de n, alors

l(x+1) = 1 + l(x) modulo(n)
c(x+1) = 1 + c(x) modulo(n)

si x est un multiple de n, alors

l(x+1) = 2 + l(x) modulo(n)
c(x+1) = c(x) modulo(n)

Dans ces r�gles pour la prise du modulo, le syst�me de r�sidus que l'on consid�re est 1, 2, ..., n et non pas 0, 1, ..., n-1.
 

La fonction magik met en oeuvre la m�thode de Moschopoulos.

function M = magik(n)
%
% Calcule le carre magique d'ordre n selon la methode
% de Moschopoulous. 
%
% Entree: 
%  n : ordre du carre (entier impair)
% Sortie:
%  M : le carre magique
%

if rem(n,2) == 0,
  msg = ['la methode de Moschopoulous ne construit que des carres' ...
       ,' d''ordre impair'];
  error(msg)
end

k = (n-1)/2;
l(1) = k+2;
c(1) = k+1;
M(l(1),c(1)) = 1;

for x = 2:n.^2
  [l(x),c(x)] = pos(x-1,l(x-1),c(x-1),n);
  M(l(x),c(x)) = x;               
% ou plus simplement M(pos(x,l(x-1),c(x-1))) = x;
end

function [ly,cy] = pos(x,lx,cx,n)
%
% Retourne la position (indice de ligne ly et indice de colonne cy)
% dans le carre magique d'ordre n de l'entier y = x+1 selon la 
% regle de Moschopoulous. 
%
% Entree: 
%  n : ordre du carre (entier impair)
%  x : l'entier considere
% lx : indice de ligne de l'entier x dans le carre magique
% cx : indice de colonne de l'entier x dans le carre magique
%
% Sortie:
%  ly : indice de ligne de l'entier y=x+1 dans le carre magique
%  cy : indice de colonne de l'entier y=x+1 dans le carre magique
%

if rem(x,n) == 0
  ly = modulo(2+lx,n);
  cy = modulo(cx,n);
else
  ly = modulo(1+lx,n);
  cy = modulo(1+cx,n);
end

Voici quelques exemples d'utilisation de la fonction magik. On v�rifie que la somme des �l�ments des diff�rentes lignes ainsi que la somme des �l�ments des diff�rentes colonnes sont bien constantes. Pour calculer la somme des �l�ments diagonaux c'est un peu plus compliqu�. On remarque que le carr� magique construit diff�re du carr� magique retourn� par la fonction MATLAB incorpor�e magic.

>> magik(4)
??? Error using ==> magik
la methode de Moschopoulous ne construit que des carres d'ordre impair
>> magik(5)
ans =
    11    24     7    20     3
     4    12    25     8    16
    17     5    13    21     9
    10    18     1    14    22
    23     6    19     2    15
>> sum(magik(5),1)
ans =
    65    65    65    65    65
>>  sum(magik(5),2)
ans =
    65
    65
    65
    65
    65  
>> magic(5)
ans =
    17    24     1     8    15
    23     5     7    14    16
     4     6    13    20    22
    10    12    19    21     3
    11    18    25     2     9