2. Workspace, environnement, commandes générales

2.1 Workspace MATLAB/Octave

2.1.1 Sauvegarde et restauration du workspace et de variables

Les variables créées au cours d'une session MATLAB/Octave (interactivement depuis la fenêtre de commande MATLAB/Octave ou en exécutant des M-files...) résident en mémoire dans ce que l'on appelle le "workspace" (espace de travail). A moins d'être sauvegardées sur disque dans un "MAT-file", les variables sont perdues lorsque l'on termine la session.

Les MAT-files sont des fichiers binaires de variables qui sont identifiables sous MATLAB par leur extension *.mat (à ne pas confondre avec les "M-files" qui sont des fichiers-texte de scripts ou de fonctions et qui ont l'extension *.m), alors qu'avec Octave ils n'ont par défaut pas d'extension.

Sous Octave, le format et version des MAT-files dépend de la valeur affectée à la fonction built-in Octave save_default_options :


save {format et option(s)} MAT-file {variable(s)}, ou Save Workspace ou File > Save Workspace As
Sauvegarde, dans le MAT-file spécifié, toutes les variables définies et présentes en mémoire, ou seulement de la(les) variable(s) spécifiées.

load MAT-file {variable(s)}, ou Import Data ou File > Load Workspace
Charge en mémoire, à partir du MAT-file spécifié, toutes les variables présentes dans ce fichier, ou seulement celles spécifiées.

who{s} {variable(s)} -file MAT-file
Permet, sous MATLAB, de lister les variables du MAT-file spécifié plutôt que celles du workspace courant
Sous Octave, on ne peut pas spécifier de variables

Au cours d'une longue session MATLAB (particulièrement lorsque l'on créée/détruit de gros vecteurs/matrices), l'espace mémoire (workspace) peut devenir très fragmenté et empêcher la définition de nouvelles variables. Utiliser dans ce cas la commande ci-dessous.

pack
Défragmente/consolide l'espace mémoire du workspace (garbage collector manuel). MATLAB réalise cela en sauvegardant toutes les variables sur disque, en effaçant la mémoire, puis rechargeant les variables en mémoire. Cette fonction existe aussi sous Octave pour des raisons de compatibilité avec MATLAB mais ne fait rien de particulier.

2.1.2 Sauvegarde et chargement de données numériques via des fichiers-texte

Lorsqu'il s'agit d'échanger des données numériques entre MATLAB/Octave et d'autres logiciels (tableur/grapheur, logiciel de statistique, SGBD...), les MAT-files standards ne conviennent pas, car sont des fichiers binaires. Outre les fonctions que l'on verra au chapitre "Entrées-sorties formatées", une solution consiste à utiliser la commande save avec l'option -ascii qui permet de sauvegarder des variables numériques MATLAB/Octave sur des fichiers-texte (ASCII). Notez que cette technique ne convient donc pas pour manipuler des chaînes, tableaux > 2D, tableaux cellulaires, structures.

save -ascii {-double} fichier_texte variable(s)
Sauvegarde, sur le fichier_texte spécifié (qui sera écrasé s'il existe déjà), la (les) variable(s) spécifiée(s).
Les nombres sont écrits en notation scientifique avec 8 chiffres significatifs, à moins d'utiliser l'option -double qui écrit alors en double précision (16 chiffres significatifs). Les vecteurs-ligne occupent 1 ligne dans le fichier, les vecteurs colonnes et les matrices plusieurs lignes. Lorsqu'une ligne comporte plusieurs nombres, ceux-ci sont délimités par des espace, à moins d'utiliser l'option -tabs qui insère alors des caractères tab. Les chaînes de caractères sont écrites sous forme de nombres (succession de codes ASCII pour chaque caractère).
Il est fortement déconseillé de sauvegarder simultanément plusieurs variables, car ce format de stockage ASCII ne permet pas de les différencier facilement les unes des autres (l'exemple ci-dessous est parlant !).

Ex: Définissons les variables suivantes :
      nb=123.45678901234 ; vec=[1 2 3] ; mat=[4 5 6;7 8 9] ; str='Hi !' ;
La commande save -ascii fichier.txt génèrera alors grosso modo (différences, entre MATLAB et Octave, dans l'ordre des variables !) le fichier ci-dessous. N'ayant ici pas spécifié de noms de variable dans la commande, toutes les variables du workspace sont écrites (mat, nb, str, vec) :

  4.0000000e+000  5.0000000e+000  6.0000000e+000
  7.0000000e+000  8.0000000e+000  9.0000000e+000
  1.2345679e+002
  7.2000000e+001  1.0500000e+002  3.2000000e+001  3.3000000e+001
  1.0000000e+000  2.0000000e+000  3.0000000e+000
a) load {-ascii} fichier_texte
b) variable = load('fichier_texte') ;
Charge sur un vecteur ou un tableau 2D les données provenant du fichier_texte spécifié. Celles-ci ne peuvent être que numériques (pas de chaînes) et délimitées par un ou plusieurs espace ou tab. Chaque ligne de données du fichier donnera naissance à une ligne du tableau. Il doit donc y avoir exactement le même nombre de données dans toutes les lignes du fichier !
a) Le chargement s'effectue sur une variable de nom identique au nom du fichier (mais sans son extension). L'option -ascii est facultative (le mode de lecture ASCII étant automatiquement activé si le fichier spécifié est de type texte).
b) Les données sont chargées sur la variable de nom spécifié.

Important : notez bien que si save -ascii permet de sauvegarder plusieurs variables d'un coup, la fonction load quant à elle ne permet de charger ces données que sur une seule variable.


Voici une technique alternative offrant un petit peu plus de finesses (délimiteur...) :
dlmwrite(fichier_texte, variable, {délimiteur {, nb_row {, nb_col } } } )
Sauvegarde, sur le fichier_texte spécifié (qui est écrasé s'il existe déjà), la variable spécifiée (en général une matrice). Utilise par défaut, entre chaque colonne, le séparateur , (virgule), à moins que l'on spécifie un autre délimiteur (p.ex. ';', ou '\t' pour le caractère tab). Ajoute éventuellement (si spécifié dans la commande) nb_col caractères de séparation au début de chaque ligne, et nb_row lignes vides au début du fichier.
Voir aussi la fonction analogue csvwrite (sous Octave dans le package "io").
variable = dlmread(fichier_texte, {délimiteur {, nb_row {, nb_col } } } )
Charge, sur la variable spécifiée, les données numériques provenant du fichier_texte indiqué. S'attend à trouver dans le fichier, entre chaque colonne, le séparateur , (virgule), à moins que l'on spécifie un autre délimiteur (p.ex. ';', ou '\t' pour le caractère tab). Avec les paramètres nb_row et nb_col, on peut définir le cas échéant à partir de quelle ligne et colonne (numérotés dans ce cas à partir de zéro et non pas 1 !) il faut récupérer les données.
Voir aussi la fonction analogue csvread (sous Octave dans le package "io").

Un dernier truc simple pour récupérer des données numériques (depuis un fichier texte) sur des variables MATLAB/Octave consiste à enrober 'manuellement' ces données dans un M-file (script) et l'exécuter.

Ex: A) Soit le fichier de données fich_data.txt ci-dessous contenant les données d'une matrice, que l'on veut charger sur M, et d'un vecteur, que l'on veut charger sur V :
       1   2   3
       4   5   6
       9   8   7

       22  33  44 
B) Il suffit de renommer ce fichier en un nom de script fich_data.m, y intercaler les lignes (en gras ci-dessous) de définition de début et de fin d'affectation :
 M = [ ...
       1   2   3
       4   5   6
       9   8   7
 ] ;

 V = [ ...
       22  33  44
 ] ;  
C) Puis exécuter ce script sous MATLAB/Octave en frappant la commande fich_data
  On voit donc, par cet exemple, que le caractère newline a le même effet que le caractère ; pour délimiter les lignes d'une matrice.


Pour manipuler directement des feuilles de calcul binaires (classeurs) OpenOffice.org Calc (ODS) ou MS Office Excel (XLS), mentionnons encore les fonctions suivantes :

Finalement, pour réaliser des opérations plus sophistiquées de lecture/écriture de données externes, on renvoie le lecteur au chapitre "Entrées-sorties formatées" présentant d'autres fonctions MATLAB/Octave plus pointues (telles que textread, fscanf, fprintf...)

2.1.3 Journal de session MATLAB/Octave

Les commandes présentées plus haut ne permettent de sauvegarder/recharger que des variables. Si l'on veut sauvegarder les commandes passées au cours d'une session MATLAB/Octave ainsi que l'output produit par ces commandes, on peut utiliser la commande diary qui crée un "journal" de session dans un fichier de type texte. Ce serait une façon simple pour créer un petit script MATLAB/Octave ("M-file"), c'est-à-dire un fichier de commandes MATLAB que l'on pourra exécuter lors de sessions ultérieures (voir chapitre "Generalités" sur les M-files). Dans cette éventualité, lui donner directement un nom se terminant par l'extension "*.m", et n'enregistrer alors dans ce fichier que les commandes (et pas leurs résultats) en les terminant par le caractère ;

diary {fichier_texte} {on}
MATLAB/Octave enregistre, dès cet instant, toutes les commandes subséquentes et leurs résultats dans le fichier_texte spécifié. Si ce fichier existe déjà, il n'est pas écrasé mais complété (mode append). Si l'on ne spécifie pas de fichier, c'est un fichier de nom "diary" dans le répertoire courant (qui est par défaut "Z:\" en ce qui concerne les salles d'enseignement ENAC-SSIE) qui est utilisé. Si l'on ne spécifie pas on, la commande agit comme une bascule (activation-désactivation-activation...)
diary off
Désactive l'enregistrement des commandes subséquentes dans le fichier_texte précédement spécifié (ou dans le fichier "diary" si aucun nom de fichier n'avait été spécifié) et ferme ce fichier. Il faut ainsi le fermer pour pouvoir l'utiliser (le visualiser, éditer...)
diary
Passée sans paramètres, cette commande passe de l'état on à off ou vice-versa ("bascule") et permet donc d'activer/désactiver à volonté l'enregistrement dans le journal.

2.1.4 Historique Octave

Indépendemment du mécanisme standard de "journal", Octave gère en outre un historique en enregistrant automatiquement, dans le répertoire profile (Windows) ou home (Unix) de l'utilisateur, un fichier .octave_hist contenant toutes les commandes (sans leur output) qui ont été passées au cours de la session et des sessions précédentes. Cela permet, à l'aide des commandes habituelles de rappel et édition de commandes (curseur-haut, etc...), de retrouver des commandes passées lors de sessions précédentes. En relation avec cet "historique", on peut utiliser les commandes suivantes :

history {-q} {n}
Affiche la liste des commandes de l'historique Octave. Avec l'option -q, les commandes ne sont pas numérotées. En spécifiant un nombre n, seules les n dernières commandes de l'historique sont listées.
run_history n1 {n2}
Exécute la n1-ème commande de l'historique, ou les commandes n1 à n2
ctrl-R
Permet de faire une recherche dans l'historique
history_size(0)
Effacera tout l'historique lorsqu'on quittera Octave
Clear Commands > Command History
Edit > Clear Command History
Efface instantanément l'historique de commandes

Différentes fonctions built-in Octave permettent de paramétrer le mécanisme de l'historique (voir l'aide) :

2.2 Environnement MATLAB/Octave

2.2.1 Généralités

MATLAB et Octave procèdent de la façon suivante lorsqu'ils évaluent les instructions d'un M-File ou ce que saisit l'utilisateur. Si l'utilisateur fait par exemple référence au nom "xxx" :

  1. MATLAB/Octave regarde si "xxx" correspond à une variable du workspace
  2. s'il n'a pas trouvé, il recherche un M-file nommé "xxx.m" (script ou fonction) dans le répertoire courant de l'utilisateur
  3. s'il n'a pas trouvé, il parcourt, dans l'ordre, les différents répertoires définis dans le "path de recherche" MATLAB/Octave (path) à la recherche d'un M-file nommé "xxx.m", donc en passant revue les toolboxes/packages
  4. s'il n'a pas trouvé, il regarde s'il y a une fonctions built-in ainsi nommée
  5. finalement si rien n'est trouvé, MATLAB/Octave affiche une erreur

Cet ordre de recherche entraîne que les définitions réalisées par l'utilisateur priment sur les définitions de base de MATLAB/Octave !

Ex: si l'utilisateur définit une variable sqrt=444, il ne peut plus faire appel à la fonction MATLAB/Octave sqrt (racine carrée) ; pour sqrt(2), MATLAB rechercherait alors le 2e élément du vecteur sqrt qui n'existe pas, ce qui provoquerait une erreur ; pour restaurer la fonction sqrt, il faut effacer la variable avec clear sqrt.

Il ne faut, par conséquent, jamais créer de variables ayant le même nom que des fonctions MATLAB/Octave prédéfinies. Comme MATLAB/Octave est case-sensitive et que pratiquement toutes les fonctions sont définies en minuscules, on évite ce problème en mettant par exemple en majuscule le 1er caractère du nom pour des variables qui pourraient occasionner ce genre de conflit.

2.2.2 Path de recherche

Le "path de recherche" MATLAB/Octave définit le "chemin d'accès" aux différents répertoires où sont recherchés les scripts et fonctions invoqués, qu'il s'agisse de M-files de l'utilisateur ou de fonctions MATLAB/Octave built-in ou de toolboxes/packages. Les commandes ci-dessous permettent de visualiser/modifier le path, ce qui est utile pour pouvoir accéder à vos propres fonctions implémentées dans des M-files situés dans un autre répertoire que le répertoire courant.

Pour que vos adaptations du path de recherche MATLAB/Octave soient prises en compte dans les sessions ultérieures, il est nécessaire de placer ces commandes de changement dans votre prologue MATLAB/Octave (voir chapitre "Démarrer et quitter MATLAB ou Octave"). Elles seront ainsi automatiquement appliquées au début de chaque session MATLAB/Octave.

Rappelons encore que le path est automatiquement modifié, sous Octave, lors du chargement/déchargement de packages (voir chapitre "Packages").

{variable =} path
Retourne le "path de recherche" courant.
Voir aussi la fonction pathdef qui retourne le path sous forme d'une seule chaîne (concaténation de tous les paths)
addpath('chemin(s)' {,-end})
Cette commande ajoute, en tête du path de recherche courant (ou en queue du path si l'on utilise l'option -end), le(s) chemin(s) spécifié(s), pour autant qu'ils correspondent à des répertoires existants.
Ex (ici sous Windows): addpath('Z:/fcts','Z:/fcts bis')
rmpath('chemin1'{,'chemin2'...})
Supprime du path de recherche MATLAB/Octave le(s) chemin(s) spécifié(s).
Ex (ici sous Windows): rmpath('Z:/mes fcts')
genpath('chemin')
Retourne le path formé du chemin spécifié et de tous ses sous-répertoires (récursivement).
Ex (ici sous Unix): addpath(genpath('/home/dupond/mes_fcts')) ajoute au path de recherche courant le dossier /home/dupond/mes_fcts et tous ses sous-dossiers !
pathtool ou Set Path
Affichage de la fenêtre MATLAB "Set Path" (voir illustration ci-dessous) qui permet de voir et de modifier avec une interface utilisateur graphique le path de recherche.


Path Browser MATLAB 7

path('chemin1'{,'chemin2'})
Commande dangereuse (utiliser plutôt addpath) qui redéfinirait (écraserait) entièrement le path de recherche en concaténant les paths chemin1 et chemin2. Retourne une erreur si chemin1 et/ou chemin2 ne correspondent pas à des répertoires existants.
Ex (ici sous Unix): path(path,'/home/dupond/mes_fcts') : dans ce cas ajoute, en queue du path de recherche courant, le chemin /home/dupond/mes_fcts. Si le chemin spécifié était déjà défini dans le path courant, la commande path ne l'ajoute pas une nouvelle fois.
a) which M-file|fonction   ou   which('M-file|fonction')
b) which fichier
a) Affiche le chemin et nom du M-file spécifié ou dans lequel est définie la fonction spécifiée.
b) Affiche le chemin du fichier spécifié.
type fonction ou type fichier
Affiche le contenu de la fonction fonction.m ou du fichier spécifié

2.2.3 Répertoire courant

Lorsque l'on manipule sous MATLAB/Octave des fichiers sans préciser leur chemin d'accès, ils sont bien entendu recherchés dans le "répertoire courant" ou "répertoire de travail". Lorsque l'on invoque un script ou fonction, MATLAB/Octave commence également par chercher le M-file éponyme dans le répertoire courant, et ceci parce que le 1er chemin figurant dans le path de recherche est toujours "." (désignant le répertoire courant) ; en cas d'échec il parcourt les autres répertoires indiqués dans le path de recherche.

Les commandes en relation avec la gestion du répertoire courant sont les suivantes :

{variable =} pwd
Retourne le chemin d'accès du répertoire courant
cd {chemin}
Change de répertoire courant en suivant le chemin (absolu ou relatif) spécifié. Si ce chemin contient des espaces, ne pas oublier de l'entourer d'apostrophes. Notez que, passée sans spécifier de chemin, cette commande affiche sous MATLAB le chemin du répertoire courant, alors que sous Octave elle renvoie l'utilisateur dans son répertoire home.

Ex:
cd mes_fonctions : descend d'un niveau dans le sous-répertoire "mes_fonctions" (chemin relatif)
cd .. : remonte d'un niveau (chemin relatif)
• sous Windows: cd 'Z:/fcts matlab' : passe dans le répertoire spécifié (chemin absolu)
• sous Unix: cd /home/dupond : passe dans le répertoire spécifié (chemin absolu)

2.3 Commandes MATLAB/Octave en relation avec le système d'exploitation

Lorsque l'on spécifie un fichier, on doit faire précéder le nom de celui-ci par un chemin si le fichier n'est pas dans le répertoire courant. Le séparateur de répertoires est \ sous Windows, et / sous Linux ou macOS.
Le / étant cependant accepté par MATLAB/Octave sous Windows, nous vous conseillons de toujours utiliser ce séparateur / quel que soit votre environnement de travail. Ainsi vos scripts/fonctions seront portables, c'est-à-dire fonctionneront dans les 3 mondes Windows, macOS et GNU/Linux !

dir {chemin/}{fichier(s)}
ls {chemin/}{fichier(s)}
Affiche la liste des fichiers du répertoire courant, respectivement la liste du(des) fichier(s) spécifiés du répertoire courant ou du répertoire défini par le chemin spécifié.
• On peut aussi obtenir des informations plus détaillées sur chaque fichiers en passant par une structure avec l'affectation structure = dir
• Sous Octave, la présentation est différente selon que l'on utilise dir ou ls. En outre avec Octave sous Linux, on peut faire ls -l pour un affichage détaillé à la façon Unix (permissions, propriétaire, date, taille...)
readdir('chemin')
glob('{chemin/}pattern')
Retourne, sous forme de vecteur-colonne cellulaire de chaînes, la liste de tous les fichiers/dossiers du répertoire courant (ou du répertoire spécifié par chemin). Avec glob, on peut filtrer sur les fichiers dont le nom correspond à la pattern indiquée (dans laquelle on peut utiliser le caractère de substitution *)
[status, msg_struct, msg_id] = fileattrib('fichier')
attr_struct = stat('fichier')
Retourne, sous forme de structure msg_struct ou attr_sctuct, les informations détaillées relatives au fichier spécifié (permissions, propriétaire, taille, date...)
what {chemin}
Affiche la liste des fichiers MATLAB/Octave (M-files, MAT-files et P-files) du répertoire courant (ou du répertoire défini par le chemin spécifié)
type {chemin/}fichier
Affiche le contenu du fichier-texte spécifié.
copyfile('fich_source', 'fich_destin')
Effectue une copie du fich_source spécifié sous le nom fich_destin
a) movefile('fichier', 'nouv_nom_fichier') ou rename('fichier','nouv_nom_fichier')
b) movefile('fichier', 'chemin')
a) Renomme le fichier spécifié en nouv_nom_fichier
b) Déplace le fichier dans le répertoire spécifié par chemin
delete fichier(s)
unlink('fichier')
Détruit le(s) fichier(s) spécifié(s)
mkdir('sous-répertoire') ou mkdir sous-répertoire
Crée le sous-répertoire spécifié
rmdir('sous-répertoire') ou rmdir sous-répertoire
Détruit le sous-répertoire spécifié pour autant qu'il soit vide
a) open fichier.m   ou   open('fichier.m')
b) structure = open('fichier.mat')
c) open fichier.ext   ou   open('fichier.ext')
Ouvre le fichier spécifié avec l'application appropriée :
a) Dans le cas d'un M-file, celui-ci est ouvert dans l'éditeur MATLAB/Octave
b) Dans le cas d'un fichier de workspace .mat, ses variables sont chargées sur les différents champs de la structure spécifiée
c) Si l'extension .ext est autre, c'est l'application externe propre au fichier qui est invoquée. Par exemple pour un fichier .html, celui-ci est ouvert dans la navigateur web par défaut. Sous Windows, s'il s'agit d'un fichier .exe, il est exécuté en tant qu'application.
[status, output] = system('commande du système d'exploitation')
! commande du système d'exploitation {&}
La commande spécifiée est passée à l'interpréteur de commandes du système d'exploitation, et l'output de celle-ci est affiché dans la fenêtre de commande MATLAB (ou, en ce qui concerne MATLAB, dans une fenêtre de commande Windows si l'on termine la commande par le caractère &) ou sur la variable output
Ex (ici pour Windows) : ! rmdir répertoire: détruit le sous-répertoire spécifié
[status, output] = dos('commande {&}' {,'-echo'})
Sous Windows, exécute la commande spécifiée du système d'exploitation (ou un programme quelconque) et affecte sa sortie standard à la variable output spécifiée. Sans l'option -echo, la sortie standard de la commande n'est pas affichée dans la fenêtre de commande MATLAB
Ex :
dos('copy fich_source fich_destin') : copie fich_source sous le nom fich_destin
[status, output]=dos('script.bat'); affecte à la variable "output" la sortie de "script.bat"
[status, output] = unix(...)
Sous Unix, commande analogue à la commande dos...
[output, status] = perl(script {, param1, param2 ...})
[output, status] = python(script {, param1, param2 ...})
Exécute le script Perl ou Python spécifié en lui passant les arguments param1, param2...
computer
Retourne sur une chaîne le type de machine sur laquelle on exécute MATLAB/Octave. On y voit notamment apparaître le système d'exploitation.
version
Retourne sur une chaîne le numéro de version de MATLAB/Octave que l'on exécute
ver
Retourne plusieurs lignes d'information : version de MATLAB/Octave, système d'exploitation, liste des toolboxes MATLAB installées, respectivement des packages Octave installés
get_home_directory
Retourne le chemin du répertoire de base de l'utilisateur
matlabroot
OCTAVE_HOME
Retourne le chemin de la racine du dossier où est installé MATLAB ou Octave
variable = getenv('variable_environnement')
Retourne la valeur de la variable d'environnement indiquée. Les noms de ces variables, propres au système d'exploitation, sont généralement en majuscule.
Il ne faut pas confondre ces variables d'environnement système avec les variables spécifiques Octave produites (depuis Octave 2.9) par des fonctions built-ins, p.ex: OCTAVE_VERSION, EDITOR ...

Ex: getenv('USERNAME') affiche le nom de l'utilisateur (variable d'environnement système)

setenv('variable_environnement', 'valeur')
putenv('variable_environnement', 'valeur')
Définition ou modification d'une variable d'environnement.

Ex: sur macOS avec Octave setenv('GNUTERM','x11') change l'environnement graphique de Gnuplot de "aqua" à "x11" (X-Window)

status = unsetenv('variable_environnement')
Détruit la variable d'environnement. Le status de retour sera 0 si cela s'est bien passé.



Documentation CC BY-SA 4.0 / J.-D. BONJOUR () / EPFL-ENAC-IT / Rév. 26-09-2016       ↵ Table des matières