 |
Vidéos d'introduction à MATLAB/Octave |
 |
|
Vidéos d'introduction à MATLAB/Octave |
|
 35:30 min |
Dans cette vidéo : • nous présentons les caractéristiques fondamentales de MATLAB et de GNU Octave • nous voyons comment notre support de cours web est organisé • nous indiquons comment installer Octave ou MATLAB sur votre propre machine • nous décrivons les différentes fenêtres des environnements de développement MATLAB/Octave • nous voyons comment paramétrer MATLAB/Octave au mieux pour un maximum d'efficacité |
|
39:03 min |
Dans cette vidéo : • nous présentons les règles relatives au nommage de variables sous MATLAB/Octave et la manipulation des variables • nous indiquons comment naviguer d'un répertoire dans un autre • nous présentons la notion de "workspace", et comment le sauvegarder/recharger • nous voyons à quoi ressemblent les tableaux de nombres et comment les manipuler • nous présentons les différents types possibles pour stocker des nombres (réels virgule flottante simple ou double précision, entiers et nombres complexes) |
|
27:26 min |
Cette vidéo présente les notions de base suivantes : • séries linéaires et logarithmiques • opérateurs de base (arithmétiques, logiques, etc...) • fonctions les plus courantes (mathématiques, statistiques, calcul matriciel, etc...) Nous montrons que ces opérateurs et fonctions sont "vectorisés", c'est-à-dire permettant d'agir sur des vecteurs et tableaux de n'importe quelle tailles et dimension, sans avoir besoin d'implémenter des boucles comme dans la plupart des langages classiques. Cette caractéristique fait notamment la réputation de MATLAB et Octave, rendant ces logiciels particulièrement efficaces en terme de rapidité d'exécution et de simplicité de programmation, par rapport aux langages usuels. |
|
16:51 min |
Cette vidéo présente l'usage des chaînes de caractères basées sur le type char. Nous voyons notamment comment : • définir des chaînes de caractères • les concaténer • comparer des chaînes • faire des recherches et substitutions dans les chaînes Il faut noter qu'il existe encore 2 autres types d'objets que l'on peut utiliser pour manipuler des chaînes : • le type tableau cellulaires, très flexible, que l'on présente dans une autre vidéo • le type string (qui fait son apparition sous MATLAB 2017 mais reste à ce jour très peu utilisé) |
|
19:16 min |
Les "scripts" sont la dénomination des programmes sous MATLAB/Octave. Dans cette vidéo nous voyons : • ce qui caractérise un script • comment un script peut interagir avec l'extérieur, que ce soit à travers le workspace, ou interactivement avec l'utilisateur • comment on peut documenter un script ainsi qu'élaborer une aide en-ligne facilitant son utilisation • comment utiliser efficacement l'éditeur intégré des environnements de développement Octave et MATLAB • ce qu'est le "prologue utilisateur" sous MATLAB/Octave |
|
19:17 min |
Les structures de contrôle sont un aspect fondamental de tous les langages de programmation. Il s'agit de constructions permettant d'exécuter des blocs d'instructions de façon itérative (boucle) ou sous condition (test). Nous présentons dans cette vidéo : • les boucles for, while et do/until, et l'effet dans celles-ci des instructions break et continue • le test if/elsif/else • la construction switch/case • le traitement d'erreurs avec try/catch, et les fonctions warning et error Mais avant de programmer des boucles (coûteuses en temps d'exécution), on réfléchira cependant toujours à deux fois, sous MATLAB/Octave (langages permettant le traitement natif de tableaux de N-dimension sans implémenter de boucles) s'il n'est pas possible de s'en passer, en programmant plutôt des expressions tirant parti des possibilités vectorisées de MATLAB/Octave (y.c. l'indexation logique qu'on présentera dans une prochaine vidéo), ce qui permet des gains de temps considérables lorsqu'on manipule de gros tableaux (millions d'éléments). |
|
17:15 min |
Les fonctions utilisateur sont fondamentales en programmation, permettant notamment de rendre un code plus modulaire, plus lisible et moins redondant. Nous montrons dans cette vidéo : • ce qui distingue fondamentalement les fionctions des scripts (présentés dans une vidéo précédente), au niveau de leur implémentation et de leur utilisation, notamment la question du passage d'arguments en entrée et la récupération de données en sortie • la portée et la durée de vie des variables au sein des fonctions, et comment modifier cela (avec les instructions global et persistent) • ce qu'il est possible de faire, s'agissant de la combinaison, dans un même M-file, de plusieurs fonctions |
|
06:43 min |
L'indexation logique est un mécanisme particulièrement efficace, car vectorisé, permettant de remplacer très avantageusement les boucles dans certaines situation, et par conséquent de gagner du temps d'exécution.
Cette technique, qui s'applique à des tableaux de dimension quelconque (i.e. vecteurs, tableaux 2D, tableaux à N-dimension), consiste à indexer des tableaux non pas par des indices (numéro de ligne, de colonne...), mais par des "tableaux logiques", c'est-à-dire des tableaux contenant des valeurs logiques (vrai ou faux). Elle permet de modifier des tableaux ou de récupérer certaines valeurs d'un tableau. Elle s'applique non seulement aux tableaux de nombre (virgule flottante, integer) mais aussi aux chaînes, tableaux cellulaires, etc... |
|
09:17 min |
Cette vidéo présente le type de données le plus polyvalent sous MATLAB/Octave, c'est-à-dire le tableau cellulaire (cells array). Tout comme les tableaux de nombres, les tableaux cellulaires peuvent avoir n'importe quelle dimension (c-à-d. vecteur, tableau à 2, 3 ou N dimension), mais leur originalité réside dans le fait que les cellules de ceux-ci peuvent contenir des données de n'importe quel type, voire même des tableaux imbriqués. Plusieurs fonctions MATLAB/Octave retournent automatiquement des tableaux cellulaires, notamment certaines fonctions de manipulation de texte, et c'est donc important de maîtriser ce type. Nous voyons ici comment utiliser ce type de données, c'est-à-dire créer et manipuler des tableaux cellulaires. |
|
08:10 min |
Les entrées/sorties sont un chapitre très important en programmation. Elles concernent la lecture de données à partir de fichiers, ou l'écriture (donc la production) de données sur des fichiers.
Lorsque ces fichiers sont de type texte, c'est-à-dire "lisibles" par un être humain (par opposition aux fichiers binaires), on doit faire usage de "formats", c'est-à-dire d'un mécanisme permettant de spécifier de quelle façon représenter les données (qui, en mémoire interne, sont binaires). Par exemple : • pour un nombre réel : combien de chiffres après la virgule faut-il afficher, s'il faut afficher un exposant de 10... • ou pour une chaîne de caractères : dans quelle largeur de champ faut-il l'afficher, doit-elle être justifiée à gauche au à droite de ce champ L'implémentation des entrées/sorties et des formats sous MATLAB/Octave est très semblable au langage C. Dans cette vidéo nous présentons les formats pour écrire/décoder des chaînes, et dans une vidéo ultérieure on utilisera ces formats pour lire et écrire des fichiers. |
|
14:56 min |
Quel que soit le langage utilisé (MATLAB/Octave, Python, C, Java...), la grande majorité des programmes que l'on développe sont appelés à manipuler des données qui doivent être persistantes, c'est-à-dire stockées sous forme de fichiers sur disque. Bien souvent aussi ces programmes ne travaillent pas seuls, c'est-à-dire qu'ils utilisent des données produites par d'autres logiciels, ou fournissent des données à d'autres programmes.
Il existe fondamentalement 2 types de fichiers : les fichiers binaires et les fichiers texte : • les fichiers binaires ne sont pas lisibles par un oeil humain, et leur contenu n'est souvent pas documenté, donc seul le programme qui les a créé peut les utiliser (exemple: les fichiers au format natifs manipulés par un tableur tel que LibreOffice Calc ou Microsoft Excel...) • les fichiers-texte, quant à eux, sont directement lisibles par l'être humain et modifiables dans un éditeur ; et c'est ce type de fichier qui est le plus utilisé lorsqu'on échange des données entre différents programmes (exemple: le format CSV...) Nous présentons dans cette vidéo la lecture et l'écriture de fichiers texte sous MATLAB/Octave, et utilisons pour cela les "formats", concept présenté dans la vidéo précédente. |
|
15:35 min |
Dans les précédentes vidéo, nous avons présenté la manière d'interagir entre un programme MATLAB/Octave et l'utilisateur via la fenêtre de commande, avec notamment les fonctions disp et input.
Il est cependant possible d'implémenter une interaction MATLAB/Octave de plus haut niveau et plus conviviale, basée "interface-utilisateur graphique" (en anglais "Graphical User Interface", abrégé GUI) : • cela peut se faire par une véritable programmation événementielle, avec des "contrôles graphiques" (tels que des menus, boutons, champs de saisie etc.) et des fonctions de "callback"... mais cette technique fera l'objet d'une autre vidéo • cela peut aussi se faire plus simplement en utilisant des "widgets" (contraction de window gadgets), c'est-à-dire des fenêtres de dialogue simples (bouton oui/non/annuler, choix dans une liste, sélection d'un fichier, etc...) ; ce sont les fonctions de base, permettant d'implémenter ces fenêtres de dialogue, que nous présenterons dans la présente vidéo. |
|
10:23 min |
La gestion du temps est un chapitre important en programmation. Beaucoup de données se réfèrent au temps (dates et/ou heures), celui-ci constituant souvent la 4e dimension (après l'espace 3D), par exemple pour des séries temporelles (hydro-météorologiques, bio-chimiques...).
Cette vidéo présente la forme sous laquelle on stocke des dates et des heures, et comment on les affiche de façon lisible. La solution sous MATLAB/Octave est analogue à d'autres logiciels (tels que les tableurs...), les dates et heures n'étant rien d'autre que des nombres réels formatés de manière particulière. Nous complétons cette vidéo par la présentation de quelques fonctions utiles de "timing", c-à-d. permettant de déterminer le temps d'exécution d'un programme ou d'un morceau de code. |
|
09:13 min |
Lorsqu'il s'agit de stocker des données structurées, c'est-à-dire des objets composés de différents champs (par exemple des personnes, avec des champs tels que leur nom, prénom, année de naissance, adresse...), le type de donnée "structure" (parfois dénommé record ou enregistrement), que nous présentons dans cette vidéo, est particulièrement approprié.
Il apporte en effet une grande lisibilité au programme, facilitant son écriture ainsi que sa maintenance. Très polyvalent, ce type de donnée permet aussi de réaliser des tableaux de structure, et les champs d'une structure peuvent être de n'importe quel type (chaîne, nombre, tableau cellulaire...) voire même être constitués d'une arborescence de sous-champs, sous-sous-champs, etc... Bien entendu des méthodes vectorisées peuvent aussi être appliquées aux structures, par exemple l'indexation logique. |
|
08:18 min |
Cette vidéo termine le passage en revue des principaux types de données offerts par MATLAB/Octave, avec la présentation du type "maps". On retrouve ce type assez classique sous d'autres dénominations dans différents langages : • les dictionnaires sous Python • les tableaux associatifs sous PHP • les hash (tables de hachage) sous Perl Il permet de créer des tableaux qui sont indexés non pas par des indices de type nombres entiers (comme les tableaux de nombre ou les tableaux cellulaires vus jusqu'ici), mais par des "clés" qui peuvent être textuelles ou numériques. |
|
17:40 min |
Cette vidéo aborde, avec les 3 autres vidéos qui suivent, les possibilités très étendues offertes par MATLAB/Octave en matière de visualisation de données : graphiques 2D variés (lignes, semis de point, aires, barres... dans des système d'axe X/Y ou polaire), 2D½ et 3D.
Mais c'est surtout la possibilité d'automatiser la production de graphiques et de les personnaliser à l'infini, grâce à la programmation, qui rend MATLAB/Octave nettement plus efficace que les tableurs/grapheurs classiques, permettant même de réaliser des animations. Cette vidéo aborde les principes de base relatifs à l'élaboration de graphiques MATLAB/Octave. Les usagers Python constateront de grandes similitudes avec la librairie MatPlotLib, cette dernière s'étant très largement inspiré de MATLAB. |
|
17:22 min |
Dans cette vidéo nous passons en revue les principaux types de graphiques 2D offerts par MATLAB/Octave (lignes, semis de points et symboles, aires, barres, histogrammes, camemberts, etc... dans des système d'axe X/Y ou polaire).
Nous montrons aussi qu'à l'aide des primitives de dessin de lignes (plot et line) et de surfaces (fill et patch) le programmeur est en mesure d'implémenter ses propres fonctions graphiques. |
|
20:28 min |
La première vidéo de présentation des graphiques a montré comment habiller des graphiques et jouer avec les couleurs de base et les différents types de ligne. Dans la présente vidéo on montre qu'au moyen des "graphics handles", on peut agir de façon beaucoup plus fine sur tous les aspects d'un graphique (types de traite et de points, axes, quadrillage, couleurs, légendes...).
En modifiant certains paramètres via un programme, il est même possible d'animer les graphiques et donc réaliser de véritables vidéos. Une animation peut être encore plus parlante qu'un graphique statique, montrant par exemple l'évolution d'un modèle en faisant varier certaines données ou paramètres. |
|
31:36 min |
Dans cette vidéo, on aborde respectivement les graphiques 2D½ et 3D, c'est-à-dire les techniques de représentation de surfaces 3D sur un plan XY, respectivement en perspective XYZ. On évoque également brièvement la visualisation de données volumétriques 4D.
On présente également la notion de "tables de couleurs" (colormaps), concept particulièrement important pour les graphiques 3D. On voit aussi comment agir sur les paramètres de visualisation d'une scène 3D, que ce soit l'angle vue, l'éclairage, l'interpolation/rendu des couleurs, etc... Accessoirement, on présente les techniques d'interpolation de semis de point XYZ en grille régulière, et vice-versa. |
