Cours gratuits » Cours informatique » Cours Analyse des données » Cours MATLAB

Programmation avancée Matlab

Documents similaires

4 étoiles sur 5 a partir de 1 votes.
Votez ce document: ☆☆☆☆☆★★★★★

MATLAB à la carte

Module 3:

Programmation avancée

Eric ANTERRIEU

Observatoire Midi-Pyrénées

Laboratoire d’Astrophysique de Toulouse-Tarbes

CNRS — UMR5572

MATLAB à la carte

? Fonctions

Variables

? Optimisation du code

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 1 / 137

? Fonctions

Nom d’une fonction

La fonction mfilename retourne le nom de la fonction (sans l’extension .m du fichier) en cours d’exécution.

J C’est un moyen pratique et simple pour nommer des fichiers log:

diary([mfilename,'.log']);

MATLAB à la carte — module 3: « Programmation avancée » 2 / 137

? Fonctions

Récursivité

Les fonctions dans MATLAB peuvent être récursives (elles peuvent s’appeler elles-mêmes).

La récursivité est un outil de programmation très pratique mais qui ne conduit pas toujours aux codes les plus performants…

? Fonctions

MATLAB reconnait plusieurs types de fonctions:

? les sous-fonctions;

? les fonctions imbriquées;

? les fonctions privées;

? les pointeurs de fonctions; ? les fonctions en ligne;

? les fonctions anonymes.

MATLAB à la carte — module 3: « Programmation avancée »

5 / 137

? Fonctions

Sous-fonctions

Un fichier fun.m peut contenir la définition d’autres fonctions que la fonction principale fun.

Elles peuvent être définies function y=fun(x)fun.maprès le corps^* de la fonction end principale, ce sont alors des function y1=fun1(x1) sous-fonctions. end

function y2=fun2(x2)

endfunction y3=fun3(x3)

^*function?end (facultatif) end

MATLAB à la carte — module 3: « Programmation avancée » 6 / 137

? Fonctions

Fonctions imbriquées

Un fichier fun.m peut contenir la définition d’autres fonctions que la fonction principale fun.

Elles peuvent être définies function y=fun(x)fun.mdans le corps^* de la fonction function y1=fun1(x1) principale, ce sont alors des end fonctions imbriquées. function y2=fun2(x2)

function y3=fun3(x3) end

^*function?end (obligatoire) end

? Fonctions

Sous-fonctions

Comme MATLAB recherche toujours une sousfonction avant de rechercher une fonction principale, les sous-fonctions peuvent porter le nom de fonctions principales se trouvant dans d’autres répertoires mais ce nom doit être unique au sein d’un même fichier.

? Fonctions

Sous-fonctions

L’aide pour une sous-fonction est afficher à l’aide de la commande help en spécifiant le nom de la fonction principale suivi d’un > puis du nom de la sous-fonction.

MATLAB à la carte — module 3: « Programmation avancée » 16 / 137

? Fonctions

Fonctions privées

Les fonctions privées sont des fonctions qui résident dans des sous-répertoires avec le nom private. Les fonctions privées ne sont visibles que des fonctions du répertoire parent.

MATLAB à la carte — module 3: « Programmation avancée » 18 / 137

? Fonctions

Fonctions privées

Comme MATLAB recherche toujours une fonction privée avant de rechercher une fonction principale, les fonctions privées peuvent porter le nom de fonctions principales se trouvant dans d’autres répertoires mais ce nom doit être unique au sein d’un même répertoire.

J C’est un moyen pratique et simple pour créer une version spéciale d’une fonction tout en conservant l’originale dans un autre répertoire.

? Fonctions

Fonctions en ligne

La fonction inline permet de définir directement une fonction sans avoir à créer un fichier portant le nom de cette fonction:

>> h = inline('expression');

>> h = inline('expression','args');

K L’expression de la fonction doit être assez simple et le nombre d’arguments pas trop élevé!

MATLAB à la carte — module 3: « Programmation avancée » 20 / 137

? Fonctions

Fonctions en ligne

La fonction inline permet de définir directement une fonction sans avoir à créer un fichier portant le nom de cette fonction:

>> h = inline('expression');

>> h = inline('expression','args');

L Il n’est pas possible d’utiliser une variable locale, ni globale, dans l’expression de la fonction.

? Fonctions

Pointeurs de fonctions

Le caractère @ est un opérateur utilisé pour créer un pointeur (handle) vers une fonction contenu dans un fichier:

>> h = @fun; ou à partir d’une expression:

>> h = @(args) expression;

K L’expression de la fonction doit être assez simple et le nombre d’arguments pas trop élevé!

? Fonctions

Pointeurs de fonctions

Le caractère @ est un opérateur utilisé pour créer un pointeur (handle) vers une fonction contenu dans un fichier:

>> h = @fun; ou à partir d’une expression:

>> h = @(args) expression;

J Il est possible d’utiliser des variables (locales ou globales) dans l’expression de la fonction.

MATLAB à la carte — module 3: « Programmation avancée » 28 / 137

? Fonctions

Passer une fonction en argument Il est possible de passer une fonction en argument à une autre fonction de plusieurs manières:

? à l’aide d’une chaine de caractères; ? à l’aide d’une fonction en ligne;

? à l’aide d’un pointeur de fonction.

Variables

Nom d’une variable

Depuis une fonction, la fonction

>> inputname(argno)

retourne le nom de la variable d’appel correspondant à l’argument numéro argno.

S’il n’y a pas de variable d’appel pour cet argument (par exemple parce que l’appel correspond à un nombre ou au résultat d’une opération), alors inputname retourne la chaîne vide [].

Variables

Nom d’une variable

La fonction logique

>> isvarname('var')

retourne 1 si var est un nom de variable valide, sinon elle retourne 0.

Les mots clefs du langage MATLAB ne peuvent pas être utilisés comme nom de variable. La fonction

>> iskeyword('var')

retourne 1 si var est un mot clef de MATLAB, sinon elle retourne 0.

MATLAB à la carte — module 3: « Programmation avancée » 42 / 137

Variables

Variables locales

Les variables locales sont les variables définies dans le corps d’une fonction:

? elles sont connues uniquement à l’intérieure de la fonction;

? elles résident dans l’espace de travail de la fonction (différent de l’espace de travail global);

? l’espace mémoire qu’elles occupent est libéré au retour de la fonction (sauf si persistent).

Variables

Variables locales

On peut considérer trois familles de variables locales:

? les paramètres d’entrée:

ce sont des variables locales initialisées; ? les paramètres de sortie:

ce sont des variables locales à calculer; ? les variables locales proprement dites.

MATLAB à la carte — module 3: « Programmation avancée » 44 / 137

Variables

Variables globales

Si plusieurs fonction, et possiblement l’espace de travail global, doivent partager une même copie d’une variable sans passer par la transmission en entrée et en sortie des dites fonctions, cette variable doit être déclarée globale à l’aide de l’instruction global partout où elle doit être connue (elle sera inconnue ailleurs).

L La valeur initiale d’une variable globale est [], penser à utiliser la fonction isempty!

Variables

Variables globales

La fonction logique

>> isglobal(var)

retourne 1 si la variable var a été déclaré globale, sinon elle retourne 0.

La commande

>> clear global

efface toutes les variables globales.

MATLAB à la carte — module 3: « Programmation avancée » 46 / 137

Variables

Variables globales

Le respect des bonnes règles de programmation recommande de ne pas utiliser de variables globales…

…sauf cas extrême, après avoir épuisé toutes les alternatives possibles!

Variables

Variables persistantes

Si la valeur d’une variable locale doit persister d’un appel à l’autre de la fonction dans laquelle elle se trouve, cette variable doit être déclarée persistante à l’aide de l’instruction persistent.

L La valeur initiale d’une variable persistante est [], penser à utiliser la fonction isempty!

Variables

Variables persistantes

Si une variable a été déclarée persistent dans une fonction fun, sa valeur persiste jusqu’à la commande:

>> clear fun

qui efface fun.m de l’espace de travail global, ou

>> clear all

qui efface toutes les variables et toutes les fonctions!

MATLAB à la carte — module 3: « Programmation avancée » 56 / 137

Variables persistent

MATLAB

» clear all

» neval=banana

neval = 0 banana.m

function y = banana(x,a)

» a=1; [xmin,fmin]=fminsearch(@banana,% BANANA The ROSENBROCK banana function[-1 1],[],a)

xmin = 1.0000 1.0000 % 100(x2-x1^2)^2 + (a-x1)^2

fmin = 4.0576e-010

» neval=banana% Written by: E. ANTERRIEUneval = 187

persistent n;

» a=1; [xmin,fmin]=fminsearch(@banana,if isempty(n)[-1 1],[],a)

Variables

Variables persistantes

On peut prévenir l’effacement d’une fonction, et donc de ses variables persistantes, lors d’une commande clear en bloquant cette fonction à l’aide de la fonction mlock.

La fonction munlock permet de la débloquer de sorte que les prochains appels à clear pourront à nouveau l’effacer de l’espace de travail global.

La fonction mislocked permet de savoir si une fonction est bloquée ou non.

xmin = 1.0000 1.0000 n = 0;

fmin = 4.0576e-010 end

» neval=banana

neval = 374 if nargin == 2

y = 100*(x(2)-x(1)^2)^2+(a-x(1))^2;

» clear banana n = n+1;

end

» a=1; [xmin,fmin]=fminsearch(@banana,if nargin == 0[-1 1],[],a)

xmin = 1.0000 1.0000 y = n;

fmin = 4.0576e-010 end

» neval=banana neval = 187

MATLAB à la carte — module 3: « Programmation avancée » 58 / 137

Variables

Nombre d’arguments variable

Un des aspects particulier de MATLAB, par rapport à d’autres langages de programmation, réside dans la possibilité d’utiliser et de concevoir des fonctions à nombre d’arguments variable.

Variables

Nombre d’arguments variable

Dans le corps d’une fonction, les deux commandes nargin et nargout retournent les nombres d’arguments en entrée et en sortie utilisés lors d’une utilisation de cette fonction.

J Ces nombres peuvent varier d’une utilisation à une autre d’une même fonction.

MATLAB à la carte — module 3: « Programmation avancée » 62 / 137

Variables

Nombre d’arguments variable En dehors du corps d’une fonction, nargin et nargout indiquent les nombres d’arguments en entrée et en sortie déclarés pour une fonction:

>> narg=nargin('fun');

>> narg=nargout('fun');

narg est négatif si la fonction fun est déclarée comme ayant un nombre d’arguments variable.

MATLAB à la carte — module 3: « Programmation avancée »

63 / 137

Variables

Nombre d’arguments variable

Les instructions varargin et varargout sont utilisées, uniquement dans le corps d’une fonction, pour passer et retourner des arguments en nombres variables:

function y=fun(x,varargin)

function [y,varargout]=fun(x)

Dans la déclaration, chaque instruction doit être écrite en minuscules et doit être la dernière variable de la liste des arguments.

? Optimisation du code

Vectorisation

Dès que cela est possible, il est impératif d’éliminer, sinon de réduire autant que possible, l’utilisation des boucles: c’est la vectorisation.

J vectoriser = remplacer les boucles par des opérations vectorielles (ou matricielles) équivalentes. L Facile à dire, pas toujours facile à faire…

K Attention au JIT-Accelerator et autres effets de caches dans la mesure des temps d’exécution…

MATLAB à la carte — module 3: « Programmation avancée » 72 / 137

? Optimisation du code

Vectorisation

En présence de boucles imbriquées, vérifier que l’adressage des tableaux est fait correctement (l’indice qui varie le plus vite doit être celui de la boucle la plus interne).

? Optimisation du code for

MATLAB

» Z=rand(128,128,128);

» whos

Name Size Bytes Class

Z 128x128x128 16777216^test.mdouble

function s=test(Z)» tic; s=test(Z), toc % written by Eric Anterrieu

s = 6.9876e+005 s=0;

Elapsed time is 0.219548 seconds.for k=1:size(Z,1) for l=1:size(Z,2)» tic; s=test(Z), toc for m=1:size(Z,3)s = 6.9876e+005 s=s+Z(k,l,m)*Z(k,l,m);

Elapsed time is 0.217521 seconds.end

end

» tic; s=test(Z), toc end

s = 6.9876e+005

Elapsed time is 0.217149 seconds.

» tic; s=test(Z), toc s = 6.9876e+005

Elapsed time is 0.217740 seconds.

» tic; s=test(Z), toc s = 6.9876e+005

Elapsed time is 0.218039 seconds.

MATLAB à la carte — module 3: « Programmation avancée » 76 / 137

? Optimisation du code for

MATLAB

» Z=rand(128,128,128);

» whos

Name Size Bytes Class

Z 128x128x128 16777216^test.mdouble

function s=test(Z)» tic; s=test(Z), toc % written by Eric Anterrieu

s = 6.9847e+005 s=0;

Elapsed time is 0.041658 seconds.for m=1:size(Z,3) for l=1:size(Z,2)» tic; s=test(Z), toc for k=1:size(Z,1)s = 6.9847e+005 s=s+Z(k,l,m)*Z(k,l,m);

Elapsed time is 0.041293 seconds.end

end

» tic; s=test(Z), toc end

s = 6.9847e+005

Elapsed time is 0.041212 seconds.

» tic; s=test(Z), toc s = 6.9847e+005

Elapsed time is 0.041292 seconds.

» tic; s=test(Z), toc s = 6.9847e+005

Elapsed time is 0.041508 seconds.

? Optimisation du code

Vectorisation

Utiliser dès que possible la possibilité d’adresser les éléments des tableaux multi-dimensionnels à l’aide d’un seul indice.

MATLAB à la carte — module 3: « Programmation avancée » 78 / 137

? Optimisation du code for

MATLAB

» Z=rand(128,128,128);

» whos

Name Size Bytes Class

Z 128x128x128 16777216^test.mdouble

function s=test(Z)» tic; s=test(Z), toc% written by Eric Anterrieu

s = 6.9847e+005 s=0;

Elapsed time is 0.041658 seconds.for m=1:size(Z,3) for l=1:size(Z,2)» tic; s=test(Z), toc for k=1:size(Z,1)s = 6.9847e+005 s=s+Z(k,l,m)*Z(k,l,m);

Elapsed time is 0.041293 seconds.end

end

» tic; s=test(Z), toc end

s = 6.9847e+005

Elapsed time is 0.041212 seconds.

» tic; s=test(Z), toc s = 6.9847e+005

Elapsed time is 0.041292 seconds.

» tic; s=test(Z), toc s = 6.9847e+005

Elapsed time is 0.041508 seconds.

? Optimisation du code

Vectorisation

Vérifier qu’une fonction (vectorisée, voir built-in!) de MATLAB ne remplisse pas déjà la fonction souhaitée, ou puisse être détournée pour la remplir.

? Optimisation du code

Pré-allocation mémoire

L’allocation de mémoire pour les tableaux n’est pas nécessaire, mais vivement recommandée car elle contribue à l’optimisation du code:

? diminution du temps de calcul:

s pas d’allocations partielles;

? réduction de la fragmentation de la mémoire:

s moins de sauts de page;

s meilleure utilisation des caches mémoire.

MATLAB à la carte — module 3: « Programmation avancée » 84 / 137

? Optimisation du code

Profiling

Lorsque l’optimisation du code n’est pas aussi simple, MATLAB dispose d’un outil de profilage, profile, qui retourne de nombreuses informations utiles pour l’optimisation du code (notamment, où chercher?).

? Optimisation du code

Pré-parsing

Lors de l’exécution d’un script ou d’une fonction, le m-code contenu dans le fichier .m est converti à la volée par MATLAB en p-code (ou pré-mâché, donc) plus rapide à interpréter. Ce p-code est stocké en mémoire (voir en cache!) jusqu’à son effacement par la commande clear (ou faute de place).

J Ceci explique pourquoi la seconde exécution et les suivantes sont plus rapides que la première.

? Optimisation du code

Pré-parsing

MATLAB dispose d’une commande pcode pour

convertir avant l’exécution le m-code contenu dans un fichier .m en p-code stocké dans un fichier .p. Puisque le p-code est plus rapide à interpréter que le m-code, l’exécution d’un script ou d’une fonction contenu dans un fichier .p sera plus rapide que celle du même script ou de la même fonction contenu dans le fichier .m.

L Vrai seulement pour la première exécution!

MATLAB à la carte — module 3: « Programmation avancée » 96 / 137

? Optimisation du code

Pré-parsing

Avec les améliorations apportées régulièrement à l’environnement, MATLAB fabrique le p-code à la volée et le stocke en mémoire très rapidement, de sorte qu’il n’est pas nécessaire d’invoquer la fonction pcode pour gagner du temps!

Un seul intérêt à la fabrication de p-code dans des fichiers .p: diffusion de programmes lorsqu’on veux cacher le code source contenus dans les fichiers .m.

J Reverse- engineering plus lent sur p-code!

? Optimisation du code pcode

MATLAB

» clear all

» tic; fractal; toc

Elapsed time is 20.235623 seconds.^fractal.m

N = 75;

» clear all x = linspace(-2,2,400);

» tic; fractal; toc y = linspace(-2,2,400);

Elapsed time is 20.106776 seconds.%

for k=1:length(x)

» clear all for l=1:length(y)

» tic; fractal; toc z = x(k)+j*y(l);

Elapsed time is 20.221359 seconds.for it=1:N

z = z-(z^3-1)/(3*z^2);

» clear all end

» tic; fractal; toc Z(l,k) = angle(z);

Elapsed time is 20.138243 seconds.end end

» clear all %

» tic; fractal; toc figure(1); colormap('prism');

Elapsed time is 20.204121 seconds.imagesc(x,y,Z);

axis('xy'); axis('square');

» hold('on');

plot(cos([0 2 4]*pi/3), sin([0 2 4]*pi/3),'k+');

MATLAB à la carte — module 3: « Programmation avancée » 98 / 137

? Optimisation du code pcode

MATLAB

» pcode fractal » clear all

» tic; fractal; toc

Elapsed time is 20.131405 seconds.^fractal.p

^@P-file 3.1^@^@^@^@^@^@;^@^@^@^@^@^@T^@

» clear all ky§½wZuè|<ìAþÈù>ç¼%Ús¹Ñv?W}ÒË &ïì-BûhÙÞG» tic; fractal; toc ¤EºÓ`1Ve 3Ï‘vÿn=’Ë¸é.×¶ÕÊ#±•&/)mbÛAy~'B¥

Elapsed time is 20.117084 seconds.s ‘¶ÿý½Òãén×¸Õ£pÁæ¯uè|<ìAþÈù>ç¼%ÚcrÁ¦ïC

»(ÙÞG6säL(ø ÝÂlˆ( ²=‚•L”i•x©.ÒË&ïì-Bû7,5

» clear all ÓÃ aÆ[email protected]â›Îy~§w¥«óµÑ×?Žý·hÙÞG¤EºÓ`1Ve3lí» tic; fractal; toc B»èky§½wZuè|<ìAþÈù>ç¼%Ús¹Ñv?W}ÒË&ïì-BûhÙ

Elapsed time is 20.153935 seconds.ÞG¤EºÓ`1Ve3Ï‘vÿn=’Ë¸é.×¶ÕÊ#±•&/)mbÛAy~'B ¥s‘¶ÿý½Òãén×¸Õ£pÁæ¯líB»èÙ^ûïàäL(ø ÝÂlˆ(

» clear all ²=‚•L”i•x©7,5ÓÃ aÆ[email protected]â›Îy~§w¥«Žý·ky§½wZu

» tic; fractal; toc è|<ìAþÈù>ç¼%Ús¹Ñv?W}ÒË&ïì-BûhÙÞG¤EºÓ`1Ve

Elapsed time is 20.137558 seconds.3Ï‘vÿn=’Ë¸é.×¶ÕÊ#±•&/)mbÛAy~'B¥s‘¶ÿý½Òãé n×¸Õ£pÁæ¯líB»èÙ^ky§½wZuè|<ìAþÈù>ç¼%ÚcrÁ¦

» clear all ïC»(ÙÞG6s¹Ñv?W}ûïàäL(øÝÂlˆ(²=‚•L”i•x©.ÒË» tic; fractal; toc &ïì-Bû7,5ÓÃaÆ[email protected]â›Îy~§w¥«óµÑ×?Žý·hÙÞG¤Eº

Elapsed time is 20.168137 seconds.Ó`1Vevÿn=’Ë¸é.×¶ÕÊ#±•&/)mbÛAy~'B¥s‘¶ÿý½Ò ãé£pÁæ¯líB»èky§½wZuè|<ìAþÈù>ç¼%Ús¹Ñv?W}Ò

» Ë&ïì-BûhÙÞG¤EºÓ`1Ve3Ï‘vÿn=’Ë¸é.×¶ÕÊ#±•&/

)mbÛAy~'B¥s‘¶ÿý½Òã¥«óµÑ×?Žý·.¥«óµÑ×?Žý·k y§½wZuè|<ìAþÈù>ç¼%Ús¹Ñv?W}ÒË&ïì-BûhÙÞG¤E ºÓ`1Ve3Ï‘vÿn=’Ë¸é.×¶ÕÊ#±•&/)mbÛAy~'B¥s^G

? Optimisation du code

Vérifier les dépendances

La commande depfun retourne la liste des fichiers .m ou .p, et éventuellement des fonctions de la bibliothèque, qui sont nécessaires à l’utilisation d’une fonction:

>> [Mfiles,Builts]=depfun('mfile');

MATLAB à la carte — module 3: « Programmation avancée » 100 / 137

? Optimisation du code

Vérifier les dépendances

La commande inmem retourne la liste des M-files, et éventuellement des MEX-files, qui ont été interprétés et chargés en mémoire récemment (depuis le dernier clear all): >> clear all;

>> mfile;

>> [Mfiles, MEXfiles]=inmem;

101

Lien vers d’autres langages

MATLAB propose des interfaces qui permettent:

§ d’appeler un autre langage de programmation depuis un script ou une fonction MATLAB;

§ d’invoquer le moteur de calcul de MATLAB depuis un autre langage de programmation;

§ d’accéder aux fichiers de données de MATLAB .mat depuis un autre langage de programmation.

MATLAB à la carte — module 3: « Programmation avancée » 102 / 137

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB

Bien que l’environnement de travail de MATLAB soit autonome pour la programmation et la manipulation des données, il peut parfois s’avérer utile d’interagir avec des données et des programmes extérieur à cet environnement.

De ce point de vue, MATLAB propose une interface vers des programmes extérieurs écrits, par exemple, en C ou en FORTRAN.

103

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB

La librairie qui réalise cette interface est une collection de routines qui permettent d’appeler depuis MATLAB des fonctions écrites en C ou en FORTRAN de la même manière que cela se fait avec les fonctions internes de MATLAB.

Ces fonctions MEX (pour Matlab EXecutable) sont liées dynamiquement par MATLAB au moment de leur exécution.

Les routines de la librairie ont le préfixe mex.

MATLAB à la carte — module 3: « Programmation avancée » 104 / 137

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB

La librairie est une collection de routines qui permettent de créer/manipuler/détruire des tableaux

MATLAB de type mxArray dans des fonctions MEX écrites en C ou en FORTRAN.

Les routines de la librairie ont le préfixe mx.

105

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB

Alors que les fichiers écrit dans le langage MATLAB ont une extension .m indépendante de la plate-forme, les fonctions MEX écrites dans un autre langage ont une extension spécifique à la plate-forme qu’il est possible de connaitre à l’aide de la fonction mexext.

L’aide en ligne d’une fonction MEX sera lue depuis le fichier .m correspondant (s’il existe).

MATLAB à la carte — module 3: « Programmation avancée » 106 / 137

» list=mexext('all');

» for k=1:length(list) disp(sprintf('Arch: %s Ext: %s',list(k).arch,list(k).ext)); end

Arch: glnx86 Ext: mexglx Arch: glnxa64 Ext: mexa64 Arch: sol2 Ext: mexsol Arch: sol64 Ext: mexs64

Arch: win32 Ext: mexw32

Arch: win64 Ext: mexw64 Arch: mac Ext: mexmac

Arch: maci Ext: mexmaci

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 107 / 137

» mex -setup

Please choose your compiler for building MEX files: Would you like mex to locate installed compilers [y]/n? y

Select a compiler:

[1] Lcc-win32 C 2.4.1 in C:\PROGRA~1\MATLAB\R2007a\sys\lcc

[0] None

Compiler: 1

Please verify your choices:

Compiler: Lcc-win32 C 2.4.1

Location: C:\PROGRA~1\MATLAB\R2007a\sys\lcc

Are these correct?([y]/n): y

Trying to update options file

From template C:\PROGRA~1\MATLAB\R2007a\bin\win32\mexopts\ Done ...

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 108 / 137

@echo offrem

rem Options file for building MEX programs using LCC compiler rem

rem *** General parameters *************************************************set MATLAB=%MATLAB%

set PATH=%MATLAB%\sys\lcc\bin;%PATH%

rem *** Compiler parameters ************************************************set COMPILER=lcc

set COMPFLAGS=-c -Zp8 -I"%MATLAB%\sys\lcc\include" -DMATLAB_MEX_FILE -noregistrylookup set OPTIMFLAGS=-DNDEBUG set DEBUGFLAGS=-g4 set NAME_OBJECT=-Fo set MW_TARGET_ARCH=win32

rem *** Library creation command *******************************************set PRELINK_CMDS1=lcc %COMPFLAGS% "%MATLAB%\sys\lcc\mex\lccstub.c"rem *** Linker parameters **************************************************set LIBLOC=%MATLAB%\extern\lib\win32\lcc set LINKER=lcclnk

set LINKFLAGS= -tmpdir "%OUTDIR%." -dll "%MATLAB%\extern\lib\win32\lcc\" -

L"%MATLAB%\sys\lcc\lib" -libpath "%LIBLOC%" set set LINKOPTIMFLAGS=-s set LINKDEBUGFLAGS= set LINK_FILE= set LINK_LIB=

set NAME_OUTPUT=-o "%OUTDIR%%MEX_NAME%%MEX_EXT%" set [email protected]

rem *** Resource compiler parameters ***************************************

set RC_COMPILER=lrc -I"%MATLAB%\sys\lcc\include" -noregistrylookup -fo"" set RC_LINKER=

set POSTLINK_CMDS1=del set POSTLINK_CMDS2=del "" set POSTLINK_CMDS3=del "«

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 109 / 137

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB

Le code source d’une fonction MEX comporte deux parties distinctes:

§ une fonction de calcul qui contient le code pour effectuer les calculs;

§ une fonction passerelle qui réalise l’interface entre MATLAB et la fonction de calcul.

MATLAB à la carte — module 3: « Programmation avancée » 110 / 137

Lien vers d’autres langages

Appeler le C ou le FORTRANdepuis MATLAB Le nom de la fonction passerelle est mexFunction . Cette fonction doit apparaitre dans le code source de toutes les fonctions MEX: c’est le point d’entrée obligatoire d’une fonction MEX (ce n’est pas la fonction main en C, ni program en FORTRAN).

111

Lien vers d’autres langages

Appeler le FORTRANdepuis MATLAB

#include "fintrf.h"

subroutine mexFunction(nlhs,plhs,nrhs,prhs) integer nlhs, plhs(*), nrhs, prhs(*) ... return end

nlhs : nombre d’arguments en sortie plhs : pointeur vers les arguments de sortie nrhs : nombre d’arguments en entrée prhs : pointeur vers les arguments d’entrée

MATLAB à la carte — module 3: « Programmation avancée »

112 / 137

Lien vers d’autres langages

Appeler le C depuis MATLAB

#include "mex.h"

void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])

{ ...

}

nlhs : nombre d’arguments en sortie

plhs : tableau de pointeurs vers les arguments de sortie nrhs : nombre d’arguments en entrée prhs : tableau de pointeurs vers les arguments d’entrée

MATLAB à la carte — module 3: « Programmation avancée » 114 / 137

#include "mex.h" void mexfunct1(double *B, double alpha, double *x, double *y, double *A, int m, int n)

{

int i, j , k;

/* rank 1 operation alpha*x*y' + A as performed by BLAS level 2 routine ESGER */ for (i=0, k=0; i<n; i++)

for (j=0; j<m; j++, k++) B[k] = alpha*x[j]*y[i] + A[k];

}

voidmexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])

{

int m, n;

double alpha, *x, *y, *A, *B;

if (nrhs != 4)mexErrMsgTxt("Four inputs are required."); if (nlhs != 1)mexErrMsgTxt("One output is required.");

if (!mxIsDouble(prhs[0]) ||mxGetN(prhs[0])*mxGetM(prhs[0]) != 1)mexErrMsgTxt("First input must be a real-valued scalar.");

if (!mxIsDouble(prhs[1]) ||mxGetN(prhs[1]) != 1)mexErrMsgTxt("Second input must be a real-valued column vector.");

m=mxGetM(prhs[1]);

if (!mxIsDouble(prhs[2]) ||mxGetN(prhs[2]) != 1)mexErrMsgTxt("Third input must be a real-valued column vector.");

n=mxGetM(prhs[2]);

if (!mxIsDouble(prhs[3]) ||mxGetM(prhs[3]) != m ||mxGetN(prhs[3]) != n)mexErrMsgTxt("Fourth input must be a real-valued matrix.");

alpha =mxGetScalar(prhs[0]); x =mxGetPr(prhs[1]); y =mxGetPr(prhs[2]); A =mxGetPr(prhs[3]); plhs[0] =mxCreateDoubleMatrix(m,n,mxREAL); B =mxGetPr(plhs[0]); mexfunct1(B,alpha,x,y,A,m,n); }

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 116 / 137

» mex -f mexfunct1.c

» rand('seed',0)

» n=3; m=4; x=rand(n,1); y=rand(m,1); A=rand(n,m); alpha=2; » B=mexfunct1(alpha,x,y,A)

B =

1.1284 0.9390 0.5514 0.9142

0.0985 0.7591 0.1029 0.6378

0.9758 1.2768 0.9382 1.6357

» alpha*x*y'+A ans =

1.1284 0.9390 0.5514 0.9142

0.0985 0.7591 0.1029 0.6378

0.9758 1.2768 0.9382 1.6357

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 117 / 137

Lien vers d’autres langages

Appeler MATLAB depuis le C ou le FORTRAN

La librairie du moteur MATLAB est une collection de fonctions qui permettent d’appeler le cœur de MATLAB depuis n’importe quel programme écrit en C ou en FORTRAN, faisant ainsi de MATLAB un moteur de calcul.

Les programmes qui utilisent ainsi le moteur de calcul de MATLAB créent un processus MATLAB et communiquent avec lui, via des pipes sous UNIX, à travers une interface COM sous WINDOWS^®.

MATLAB à la carte — module 3: « Programmation avancée » 118 / 137

Lien vers d’autres langages

Appeler MATLAB depuis le C ou le FORTRAN

Les fonctions de la librairie permettent: § de démarrer/arrêter le processus du moteur de

MATLAB;

§ d’échanger des données vers/depuis le moteur de

MATLAB;

§ d’envoyer des commandes au moteur de MATLAB pour qu’il les interprète et récupérer le résultat.

Les fonctions de la librairie ont le préfixe eng.

MATLAB à la carte — module 3: « Programmation avancée » 119 / 137

Lien vers d’autres langages

Appeler MATLAB depuis le C ou le FORTRAN Que peut-on faire avec le moteur de MATLAB utilisé depuis un programme écrit en C ou en FORTRAN?

§ appeler une fonction de haut-niveau pour inverser une matrice, par exemple, ou bien utiliser la fft,… ;

§ construire un environnement d’analyse de données avec l’interface graphique (front-end) en C et l’analyse (back-end) en MATLAB. MATLAB est alors utilisée comme une librairie mathématique.

MATLAB à la carte — module 3: « Programmation avancée » 120 / 137

Lien vers d’autres langages

Appeler MATLAB depuis le C ou le FORTRAN

Le moteur de MATLAB est un processus à part qui s’exécute en arrière-plan du programme écrit en C ou en FORTRAN. Ceci procure plusieurs avantages:

§ sous UNIX, le processus du moteur MATLAB peut s’exécuter sur la même machine ou sur n’importe quelle machine du réseau local (y

compris d’architecture différente);

§ au lieu de lier le programme en C/FORTRAN avec tout MATLAB, seule un petit code de communication est inclus dans l’exécutable.

121

Lien vers d’autres langages

Appeler MATLAB depuis le C ou le FORTRAN

La librairie contient les fonctions suivantes:

engOpen démarre le processus MATLAB engClose termine le processus MATLAB engGetVariable reçoit un tableau de MATLAB engPutVariable envoie un tableau à MATLAB engEvalString exécute une commande dans MATLAB engOutputBuffer créer un buffer pour récupérer tout ce qui

normalement apparaît dans la fenêtre de commande

MATLAB à la carte — module 3: « Programmation avancée » 122 / 137

Lien vers d’autres langages

@echo offrem

rem Options file for building standalone ENG/MAT programs using LCC compiler rem

rem *** General parameters *************************************************set MATLAB=%MATLAB%

set PATH=%MATLAB%\sys\lcc\bin;%PATH% set LCCMEX=%MATLAB%\sys\lcc\mex

set PERL="%MATLAB%\sys\perl\win32\bin\" set MW_TARGET_ARCH=win32

rem *** Compiler parameters ************************************************set COMPILER=lcc set OPTIMFLAGS=-DNDEBUG set DEBUGFLAGS=-g4

set COMPFLAGS=-c -Zp8 -I"%MATLAB%\sys\lcc\include" -noregistrylookup set NAME_OBJECT=-Fo

rem *** Linker parameters **************************************************set LIBLOC=%MATLAB%\extern\lib\win32\lcc set LINKER=lcclnk

set LINKFLAGS=-tmpdir "%OUTDIR%." -L"%MATLAB%\sys\lcc\lib" -libpath "%LIBLOC%" set set LINKOPTIMFLAGS= set LINKDEBUGFLAGS= set LINK_FILE= set LINK_LIB=

set NAME_OUTPUT=-o "" set [email protected]

rem *** Resource compiler parameters ***************************************set RC_COMPILER= set RC_LINKER=

C:\PROGRA~1\MATLAB\R2007\bin\win32\mexopts\

MATLAB à la carte — module 3: « Programmation avancée » 123 / 137

#include

#include #include "engine.h"

int main()

{

Engine *eng;

mxArray *D = NULL, *T = NULL; int k; double *d, *t, data[10] = {0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; if (!(eng =engOpen("\0"))) {printf("Can't start MATLAB engine\n"); return(-1);} printf("Starting MATLAB engine...\n\n");

T =mxCreateDoubleMatrix(1,10,mxREAL); t =mxGetPr(T);

for (k=0; k<10; k++) t[k] = data[k];engPutVariable(eng,"T",T);

engEvalString(eng,"G=9.81;");engEvalString(eng,"D = -0.5*G*T.^2;");engEvalString(eng,"plot(T,D);");

engEvalString(eng,"title('Distance vs. Time for a falling object');");engEvalString(eng,"xlabel('Time (seconds)');");engEvalString(eng,"ylabel('Distance (meters)');");

D =engGetVariable(eng,"D");

if ((D != NULL) && (mxGetNumberOfElements(D) == 10))

{

d =mxGetPr(D);

for (k=0; k<10; k++) printf("%f %f\n",t[k],d[k]); } printf("Hit return to continue...\n\n"); fgetc(stdin);

engEvalString(eng,"close;");mxDestroyArray(D);mxDestroyArray(T);engClose(eng);

printf("Done\n"); return(0);

}

Lien vers d’autres langages

MATLAB à la carte — module 3: « Programmation avancée » 124 / 137

Lien vers d’autres langages

Accéder aux fichiers .mat depuis le C ou le FORTRAN La librairie est une interface avec les fichiers .mat. C’est une collection de fonctions qui permettent d’accéder aux fichiers de données au format .mat de MATLAB depuis un programme écrit en C ou en FORTRAN.

Le format (propriétaire) .mat de MATLAB peut ainsi devenir un format d’échange de données avec d’autres applications.

MATLAB à la carte — module 3: « Programmation avancée » 127 / 137

Lien vers d’autres langages

Accéder aux fichiers .mat depuis le C ou le FORTRAN Les fonctions de la librairie permettent:

§ d’ouvrir/fermer un fichier;

§ de lire/écrire des données dans un fichier;

§ de rajouter/supprimer des données dans un fichier.

Les fonctions de la librairie ont le préfixe mat.

MATLAB à la carte — module 3: « Programmation avancée » 128 / 137

Lien vers d’autres langages

Accéder aux fichiers .mat depuis le C ou le FORTRAN La librairie contient les fonctions suivantes: matOpen ouvre le fichier

matClose ferme le fichier

matGetDir liste les variables du fichier

matGetNextVariableInfo lit l’entête de la prochaine variable matGetNextVariable lit la prochaine variable matGetVariableInfo lit l’entête d’une variable du fichier matGetVariable lit une variable depuis le fichier matPutVariable écrit une variable dans le fichier matPutVariableAsGlobal écrit une variable dans le fichier matDeleteVariable supprime une variable du fichier

129

Lien vers d’autres langages

@echo offrem

rem Options file for building standalone ENG/MAT programs usin

Cours gratuits » Cours informatique » Cours Analyse des données » Cours MATLAB

Programmation avancée Matlab

Articles similaires

Documents similaires

Cours de programmation avancée

Travaux pratiques de programmation Matlab

Formation Matlab : éléments de programmation et graphisme

Apprendre Matlab pas à pas

Cours et exercices MATLAB

Cours complet de programmation avancée

Cours de Matlab

Formation avancé sur les Objets de Matlab

Programmation avancée en C

Formation d'initiation au logiciel MATLAB et Simulink

Apprendre Matlab tutoriel facile pour débutant

Cours de Matlab

Sous-fonctions

^*function?end (facultatif) end

Fonctions imbriquées

MATLAB

function y = banana(x,a)

MATLAB

end

MATLAB

end

MATLAB

end

MATLAB

N = 75;

for k=1:length(x)

axis('xy'); axis('square');

MATLAB