====== Leçon 3 : fichiers M et structures de contrôle ======

===== Utilisation de fichiers M =====

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.

==== Mode script ====

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 :
<code matlab>matrice_script=rand(2,3) ;
matrice_script=1984*matrice_script ;
vecteur_script=matrice_script(:,2)</code>
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.


==== Mode "fonction" ====

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 :
<code matlab>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</code>
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((Cependant, il est possible de rendre une variable //globale//, cf quelques cours plus tard)).

===== Structures de contrôle, boucles =====


==== Condition ====

La structure est classique :
<code matlab>if condition
  si_vrai() ;
else
  si_faux() ;
end</code>

On peut également utiliser le ''elseif'', parfois utile :
<code matlab>if conditionA
  si_A() ;
elseif conditionB
  si_B() ;
elseif conditionC
  si_C() ;
else
  sinon()
end</code>

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é.

==== Appariement (matching) ====

<code matlab>switch variable
  case a
    si_a() ;
  case {b,c,a}
    si_b() ;
  otherwise
    sinon() ;
end</code>
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''.


==== Boucle incrémentielle ====

<code matlab>for compteur=vecteur_valeurs
  pouet();
end</code>
La plupart du temps, on veut faire parcourir à ''compteur'' l'ensemble des entiers entre 1 et N (inclus) :
<code matlab>for compteur=1:N
  pouet();
end</code>
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''.

==== Boucle conditionnelle ====

<code matlab>while condition
  tant_que_condition_est_vraie();
end</code>
Encore une fois, on peut utiliser le mot-clef ''break'' pour terminer la boucle de façon prématurée.



==== Opérateurs logiques ====

Il y a plusieurs tests logiques: ''==''
((A ne pas confondre avec '=' qui définit un élément)), ''&&'' (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,
<code matlab>
>> 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
</code>
Il y a également ''xor''...



===== Exercice =====

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 !

  - Générer une matrice aléatoire de taille 4x4, 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.//
  - Calculer la somme de tous les éléments de cette matrice. //La fonction ''sum'' pourra être très utile !//
  - 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 [[04debug]].