Afin de réaliser de vrais longs programmes, on va rédiger des fichiers M, que l'on pourra stocker puis re-exécuter plus facilement. Cependant, 2 modes différents sont à distinguer lors de l'écriture du code.

Ce mode consiste en la simple succession de commandes Matlab. Les variables créées (pendant l'exécution de ce script) restent accessibles après la fin de l'exécution. Voilà un exemple de script :

matrice_script=rand(2,3) ;
matrice_script=1984*matrice_script ;
vecteur_script=matrice_script(:,2)

Lors de l'exécution de ce script, un vecteur sera affiché (contenu de vecteur_script) et 2 nouvelles variables seront accessibles (vecteur_script et matrice_script).

Pour lancer ce script, il suffit de taper dans la command window le nom du fichier (sans le .m) dans lequel se situe le script.

Ce mode ressemble à la façon dont fonctionne C & Java : plusieurs fonctions sont écrites et à l'exécution, une fonction spécifique est lancée. Voilà un squelette exemple :

function [arg_sortie1, arg_sortie2] = nom_fonction_main(arg_entree1, arg_entree2)
...
return
 
function arg_sortie1=fonction_aux()
...
return
 
function fonction_aux2(arg_entree1,arg_entree2,arg_entree3)
...
return

Quelques détails :

• il est très conseillé de donner au fichier dans lequel on enregistre ces fonctions le nom de la fonction principale
• la fonction principale doit toujours être placée au début
• les fonctions auxiliaires (càd toutes les fonctions sauf la principale) ne sont pas accessibles que dans le fichier dans lequel elles se situent. Dans l'exemple précédent, cela veut dire qu'un autre fichier M (en mode script ou fonction) pourra accéder à la fonction nom_fonction_main, mais pas à fonction_aux.
• toutes les variables sont localisées comme dans la plupart des autres langages : c'est-à-dire que les variables définies dans une fonction ne sont accessibles que dans cette fonction, et détruites à la fin de la fonction¹⁾.

La structure est classique :

if condition
  si_vrai() ;
else
  si_faux() ;
end

On peut également utiliser le elseif, parfois utile :

if conditionA
  si_A() ;
elseif conditionB
  si_B() ;
elseif conditionC
  si_C() ;
else
  sinon()
end

L'indentation est automatique, mais n'est pas obligatoire. On pourra également utiliser des parenthèses autour des conditions après les mots-clefs if et elseif pour plus de sécurité.

switch variable
  case a
    si_a() ;
  case {b,c,a}
    si_b() ;
  otherwise
    sinon() ;
end

Comme en C, si un test est réussi, on passe directement à end : dans l'exemple, si variable=a, seul si_a() sera exécuté. Une différence notable avec le C est qu'il n'y a pas besoin de marquer la “fin d'un case” par un break.

for compteur=vecteur_valeurs
  pouet();
end

La plupart du temps, on veut faire parcourir à compteur l'ensemble des entiers entre 1 et N (inclus) :

for compteur=1:N
  pouet();
end

On peut utiliser le mot-clef break pour terminer la boucle de façon prématurée. On peut utiliser continue pour stopper l'exécution de la boucle et reprendre la boucle à la valeur suivante du compteur.

while condition
  tant_que_condition_est_vraie();
end

Encore une fois, on peut utiliser le mot-clef break pour terminer la boucle de façon prématurée.

Il y a plusieurs tests logiques: == ²⁾, && (et), || (ou). Ils ne fonctionnent que sur des scalaires. Cependant, & et | existent et s'appliquent sur chacun des éléments de 2 tableaux (ou matrices). Ainsi,

>> m = rand(1,4) ; n = rand(1,4) ;
>> m = m>0.5 ; n = n>0.5 ; % On a ainsi que des 0 ou des 1
>> m
m =
     0     1     0     0
>> n
n =
     1     1     0     1
>> m==n
ans =
     0     1     1     0
>> m & n
ans =
     0     1     0     0
>> m | n
ans =
     1     1     0     1

Il y a également xor…

Là on commence à aborder des choses pas simples, et il vaut mieux les faire proprement: il faudra donc veiller à n'utiliser aucune boucle for dans la suite !

1. Générer une matrice aléatoire de taille 4×4, utilisant 3 valeurs (0, 1 et 2 par exemple) à répartition uniforme. On pourra générer une matrice aléatoire avec rand(4,4), puis remplacer toutes les valeurs inférieures à 0.33 par 0, celles entre 0.33 et 0.66 par 1 et celles supérieures à 0.66 par 2.
2. Calculer la somme de tous les éléments de cette matrice. La fonction sum pourra être très utile !
3. Faire un fichier .m (en mode fonction) qui prenne en argument une matrice utilisant 3 valeurs (0, 1 et 2 par exemple encore) et qui renvoie une matrice dont chaque valeur vaut la précédente ajoutée au carré de la valeur de la matrice d'entrée (on parcourt la matrice dans le sens horizontal d'abord puis dans le sens vertical). On pourra utiliser des boucles for

Vous pouvez maintenant passer à la leçon suivante Leçon 4 : débugger du code Matlab.