Pizza au chèvre et aux lardons
Pizza au thon
Pizza Margherita
Pizza à la pancetta
Pizza aux poivrons
Pizza campagnarde
Pizza au fromage gorgonzola
Découvrir Scilab/Gestion des fichiers
10. Gestion des fichiers
Nous avons vu précédemment que l'on pouvait définir une fonction ou un programme dans un fichier texte, puis appeler ce fichier texte avec l'instruction codice_1, ce qui avait le même effet que taper la fonction ou le programme (voir "Programmation").
Mais Scilab possède aussi d'autre possibilités de gestion de fichier.
Choisir un fichier de manière interactive.
La commande codice_2 permet de choisir un fichier dans une interface utilisateur.
Informations sur les fichiers.
La commande codice_3 donne des informations sur les fichiers (au sens large d'Unix, c'est-à-dire y compris les unités de stockage et les répertoires). Elle renvoie un vecteur de 13 nombres :
Si le fichier n'existe pas, tous les nombres sont des NaN "(not a number)" ; la fonction retourne donc la matrice vide.
Par exemple, pour vérifier si un fichier existe (ou si un répertoire existe, ou si un lecteur est monté), on peut utiliser
fileinfo("nom_de_fichier")~= [ ]
Manipulation des répertoires.
Scilab dispose d'un certain nombre de commandes de type Unix permettant de manipuler les chemins d'accès aux fichiers, les répertoires (dossiers) :
Par ailleurs, il existe des variables prédéfinies relatives aux répertoires :
Lecture/écriture d'une matrice en format texte.
Les fonctions codice_15 et codice_16 permettent de lire et d'écrire les valeurs d'une matrice ou d'un vecteur dans un fichier au format texte. Cela permet entre autres d'échanger les données avec d'autres logiciels, comme par exemple un tableur.
Il est possible d'appliquer un format aux données dans un format proche du Fortran.
"Syntaxe :"
 write (nom_de_fichier, a [, format])
[x] = read (nom_de_fichier, m, n [, format])
"Paramètres :"
La commande codice_23 permet de lire des fichiers au . Cela permet par exemple de lire des fichiers exportés depuis un tableur, comme Microsoft Office Excel ou bien LibreOffice Calc :
A = csvRead(nom_de_fichier);
La syntaxe complète est :
csvRead(A, nom_de_fichier, separateur_colonnes, separateur_decimal, conversion)
où
De même, la commande codice_31 permet de créer des fichiers CSV, avec par défaut une virgule "(comma)" comme séparateur de champ ; le format de la commande est
csvWrite(A, nom_de_fichier)
où A est la variable (matrice) dont le contenu va être écrit dans le fichier. La syntaxe complète est :
csvWrite(A, nom_de_fichier, separateur_colonnes_ separateur_decimal, precision, commentaire)
où
Voir aussi la commande codice_36 dans la section "Exploitation de fichiers texte" ci-dessous.
Exemples.
x=linspace(0, 2*%pi, 100)';
y=sin(x);
write("sinus.txt", [x y], "(F6.3,1X,F6.3)");
Cet exemple écrit la table de la fonction sinus dans le fichier codice_37, chaque ligne représente un point.
sinus.txt:
 0.000 0.000
 0.063 0.063
 0.127 0.127
 0.190 0.189
 0.254 0.251
Si le format est omis, Scilab décide d'un format approprié.
La commande :
write("sinus.txt", [x y]);
écrira le fichier suivant :
sinus.txt:
 0.0000000000000000 0.0000000000000000
 6.34665182543392575E-002 6.34239196565645064E-002
 0.12693303650867852 0.12659245357374926
 0.19039955476301776 0.18925124436041019
 0.25386607301735703 0.25114798718107922
 0.31733259127169627 0.31203344569848712
Inversement le fichier codice_38 contient l'heure, la temperature et l'humidité relevé.
temperature.txt:
 18 -1 86
 17 -1 84
 16 -0.7 85
Sa lecture se fera par la commande codice_15 :
a=read ("temperature.txt", -1, 3);
Il est plus simple ici de laisser scilab décider du format de lecture. Seul le nombre de colonnes est indiqué, le nombre de ligne est mis à -1 pour indiquer à scilab de lire l'intégralité du fichier.
La matrice codice_18 de type flottant contient :
 a =
 18. - 1. 86. 
 17. - 1. 84. 
 16. - 0.7 85. 
Lecture d'un fichier Microsoft Office Excel.
Scilab peut lire des fichiers Excel. La version 5.4 de Scilab peut lire les fichier de Microsoft Office Excel 2003 (format BIFF8), portant l'extension codice_47, mais pas les fichiers codice_48.
La première étape consiste à ouvrir le fichier Excel, avec la commande codice_49 ; puis, on lit les données avec la commande codice_50.
Prétraitement d'un fichier.
Dans certains cas, le fichier contient des données inutiles qu'il convient d'éliminer avant de l'ouvrir dans Scilab. Rappelons que des commandes du système d'exploitation peuvent être lancées depuis Scilab grâce à la commande codice_51.
Par exemple, avec un système unix, il est possible de nettoyer un fichier texte en exécutant des commandes de type codice_52, codice_53 et codice_54. 
Sauvegarde de variables en binaire.
Il est possible d'exporter le résultat d'un calcul dans un fichier, ce qui permet de le réutiliser pour une autre fois. Ceci se fait avec la commande codice_55 :
save (fichier, a, b, c, ...)
Cela enregistre les variables codice_18, codice_57, codice_58, ..., dans le fichier de nom codice_59.
Si aucune variable n'est spécifiée, toutes les variables de l'environnement de travail sont enregistrées.
Ce résultat peut ensuite être réimporté avec la commande codice_60 :
load (fichier, a, b, c, ...)
Cela lit les variables codice_18, codice_57, codice_58, …, présentes dans le fichier de nom codice_59. Il s'agit du nom des variables tel qu'il a été spécifié lors de la commande codice_65. De même que précédemment, si aucun variable n'est spécifiée, toutes les variables présentes dans le fichier sont chargées.
Le fichier produit est un fichier binaire. Chaque variable est représentée par :
L'instruction codice_69 permet d'avoir la liste des variable contenues dans un fichier et leur description.
Enregistrer un graphique.
Pour la création de graphiques, voir "Graphiques et sons".
Scilab permet de sauvegarder des graphiques sous plusieurs formats. Il faut au préalable donner un numéro à la fenêtre graphique, en indiquant codice_70 avant les instructions de tracé.
La syntaxe générale des fonctions d'export est la suivante :
xs2format (id, fichier)
où
Les fonctions sont :
"Exemple :"
f = gcf ();
x = linspace (0, 2*%pi, 200)';
plot (x, [sin(x), cos(x)]);
xs2gif (f, "exemple_scilab_sin_cos.gif");
L'export de graphiques sous scilab semble se faire par copie d'écran, cela signifie qu'il peut y avoir des problèmes si lors de la commande codice_81, la fenêtre contenant le graphique n'est pas clairement visible à l'écran.
Lire un fichier d'image.
Scilab ne dispose pas en natif d'instruction permettant de lire un fichier d'image. Il existe toutefois des modules externes de traitement d'image que l'on peut charger grâce au gestionnaire de modules Atoms. Citons :
Avec SIP et SIVP, on charge une image dans une variable avec l'instruction
image = imread("nom_de_ficher")
et on l'affiche avec l'instruction
imshow(image)
Avec IPD, on charge une image dans une variable avec l'instruction
image = ReadImage("nom_de_fichier")
et on l'affiche avec l'instruction
ShowImage(image)
Enregistrer et lire des fichiers de sons.
Lorsque la variable "x" est un vecteur, on peut le sauvegarder sous la forme d'un son, dans un fichier de type codice_82. Le son correspond à des variations de pression de l'air, ou des variations de la tension d'alimentation du haut-parleur, "s" de la forme
avec 
ƒ étant la fréquence d'échantillonnage. Par défaut, ƒ vaut (une valeur de "x" correspond à 1/ seconde).
La création du fichier se fait avec la fonction codice_83
savewave('nom_de_fichier', x)
Il faut bien s'assurer qu'il s'agit d'une matrice colonne.
On peut aussi définir une autre fréquence d'échantillonnage entière :
savewave('nom_de_fichier', x, f)
Un fichier codice_84 peut être mis dans une matrice avec la fonction codice_85 :
x = loadwave('nom_de_fichier')
chaque ligne de la matrice correspondant alors à un canal. On peut ensuite jouer ce son dans Scilab avec l'instruction codice_86
playsnd(x)
"Voir aussi Graphiques et sons."
Gestion avancée des fichiers.
Lecture/Ecriture « à la sauce » C.
Différentes fonctions sont directement inspirées de la syntaxe du langage C.
[fd, err] = mopen (fichier, mode)
 Ouverture du fichier de nom codice_59. Le mode d'ouverture est codice_88 pour lecture, codice_89 pour écriture et codice_90 pour ajout. La fonction retourne un scalaire « descripteur » codice_91 qui sert à identifier le fichier dans les fonctions suivantes. Le code d'erreur peut être récupéré par la variable codice_92, il vaut 0 si l'ouverture s'est déroulée correctement.
 Écriture dans le fichier d'identifiant codice_91. Le paramètre codice_22 est une chaîne de caractère décrivant le formatage des données. Cette fonction est équivalente à la fonction codice_95 du langage C (voir "Programmation C-C++/Entrée / sortie de base#La fonction printf").
y(1,1:3) = mfscanf(1, fd, "%f %f %f\n") // ou bien
y(1,1:3) = mfscanf(fd, "%f %f %f\n")
 balaie "(scan)" le fichier numéro codice_91 de manière séquentielle, et récupère les trois premières données et les met dans la première ligne d'une matrice de trois colonne appelée "y" ; le premier nombre "n"iter (ici « 1 ») indique que l'opération est faite "n"iter fois (le paramètre est optionnel et la valeur par défaut est 1) 
y(2,1:3) = mfscanf(-1, fd, "%f %f %f\n")
 continue l'opération de rapatriement et met les données dans les lignes suivantes de la matrice, jusqu'à la fin du fichier (c'est le sens de "n"iter valant -1) ;
mclose (fd)
 Ferme le fichier d'identifiant codice_91
Les fonctions codice_98 et codice_99 sont plus « rigides » que codice_23 et codice_31 par exemple, puisqu'elle nécessitent de définir strictement la structure d'une ligne de fichier alors que les codice_102 n'ont besoin que du séparateur. En revanche, elles sont plus rapides, ce qui est appréciable pour les grands volumes de données.
Exploitation de fichiers texte.
Le format texte (ASCII ou Unicode), du fait de son caractère universel, sert fréquemment de format d'échange entre logiciels. Il est donc intéressant de se focaliser sur les spécificités de ce format. Les fonctions codice_15 et codice_23 sont simples d'utilisation, mais ne sont plus applicables pour les fichiers très grands.
Lire une matrice de nombres.
La commande codice_105 permet de lire directement une matrice dans un fichier texte (ASCII ou UTF-8). Dans sa syntaxe de base
M = fscanfMat("nomfichier");
la fonction crée une matrice de nombres M à partir du fichier texte codice_106, en éliminant l'en-tête (les premières lignes qui contiennent des caractères non numériques). On peut lui demander de mettre le texte de l'en-tête dans une variable :
[M, entete] = fscanfMat("nomfichier");
Il est possible d'indiquer le format des données :
M = fscanfMat("nomfichier", "format");
ou "format" est une chaîne de caractère qui peut être de la forme codice_107, par exemple :
La chaîne peut également contenir la largeur et la précision du nombre : codice_115 par exemple. La largeur est le nombre minimum de caractères que comporte un nombre. La signification de la précision dépend du type :
Lire les lignes une par une.
La fonction codice_122 lit une ou plusieurs lignes d'un fichier texte 
txt = mgetl ('nomfichier', m)
txt = mgetl (fd, m)
Si le fichier a été ouvert (avec codice_123, il dispose d'un descripteur codice_91 qui permet d'y faire référence ; sinon, on peut utiliser le nom du fichier. Si "m" est omis ou vaut -1, la fonction lit toutes les lignes. Si "m" est un entier strictement positif, la fonction lit "m" lignes (accès séquentiel). La variable codice_125 est une matrice colonne, chaque ligne correspondant à une ligne du fichier.
La commande codice_126 enlève les espaces situés au début et à la fin des lignes.
Découper une ligne en colonnes.
Si l'on connaît les positions (index) des débuts de colonne, les nombres c1, c2, …, cn, on peut utiliser la commande codice_127 pour extraire une colonne. Par exemple, pour extraite la colonne 5 :
p = part(txt, [c5, c6 - 1])
On peut également séparer les différentes colonnes pour les mettre dans un vecteur avec
cellules = strsplit(txt, [c1, c2, …, cn])
Une ligne — une chaîne de caractères — contient souvent des délimiteurs. S'il s'agit d'une chaîne de caractères fixes, on peut utiliser la commande codice_128 :
t = tokens('a = 5', '=')
crée la matrice codice_129.
Si les séparateurs sont variables, on a intérêt à faire appel aux expressions régulières (voir "Programmation > Expressions régulières"). Par exemple, si les colonnes sont complétées par des caractères d'espacement (espaces, tabulations) en nombre indéterminé, on peut utiliser
cellules = strsplit(txt, '/\s+/)
Considérons par exemple le fichier codice_130
Clovis Ier 466-511
Clodomir 495-524
Thierry Ier 485-534
Théodebert Ier 504-548
La séparation entre le nom du roi et la date est constituée de deux espaces ou plus. On veut créer une matrice dont la première colonne contient le nom du roi, la deuxième sa date de naissance et la troisième sa date de mort. On peut par exemple écrire
// lecture du fichier
fd = mopen('roisdefrance.txt');
texte = mgetl(fd, -1); // texte(i) contient la i-ème ligne
mclose(fd);
n = size(texte, 'r');
cellules = [];
// séparation des colonnes
for i = 1:n
 cellules(i,:) = strsplit(texte(i), '/\s{2,}|-/')'
end
disp(cellules');
Voir aussi.
"Structures de données avancées" < ↑ > "Équivalences Matlab-Scilab"