F4.1
1
2
3
4
5
6
7
8
Aufruf von Externen Funktionen in MATLAB
C‐Programm im Command‐Window (DOS‐Box) übersetzen
C‐Programm mit Aufrufparametern
C‐Programm in MATLAB ausführen
Der Befehl mex und die Funktion mexfunction
Die Struktur mxArray und die mx‐Funktionen
Addiere Vektoren und Matrizen
Search Path
Aufgaben
1
F4.2
Aufruf von externen Funktionen
Ziel : Verwende in MATLAB oder Simulink Programme, die nicht in der Programmiersprache MATLAB geschrieben sind.
Konkret : Verwende C‐Programme innerhalb von MATLAB oder Simulink. Warum ?
• Bestehende Programme werden nicht neu geschrieben, weil der Aufwand für das Umschreiben, Testen, die Wartung und Weiterentwicklung zu groß ist. Das bestehende Programm wird so angepasst, dass es unter MATLAB oder Simulink ausgeführt werden kann.
• C‐Programme können Funktionalität bieten, die es so in MATLAB nicht gibt und die mit MATLAB nicht bereit gestellt werden kann.
• Gut geschriebene C–Programme sind effektiver und schneller als die entsprechenden MATLAB‐Programme.
Beachte aber : Selbstgeschriebene C‐Programme können durchaus auch langsamer oder ineffektiver sein als die entsprechenden MATLAB‐
Programme.
2
F4.3
Aufruf von externen Funktionen
In MATLAB, use functionality from other languages, such as Java, C/C++, .NET, and Python
• Call MEX‐File Functions
Call C/C++ or Fortran MEX‐file functions from MATLAB
MEX MATLAB Executable external interface function
• Call C Shared Libraries
Directly call C library functions from MATLAB
• Call Java Libraries
Access Java libraries from MATLAB
• Call .NET Libraries
Access .NET libraries from MATLAB
Siehe : Help MATLAB ‐> Advanced Software Development
‐> Calling External Functions
• Call COM Objects
Access COM components and ActiveX controls from MATLAB
• Call Python Libraries
Access Python functionality from MATLAB
• Call WSDL Web Service
Communicate with Web service from MATLAB using WSDL (Web Services Description Language)
3
F4.4
Aufruf von externen Funktionen
Vorgehensweise : Versuche zunächst ganz einfache C‐Programme in MATLAB aufzurufen
• Ein Programm, das nur einen String ausgibt, d.h. verwende eine Funktion, die keine Parameter besitzt.
• Ein Programm, das zwei Werte vom Type double addiert und das Ergebnis zurückgibt, d.h. eine Funktion mit einfachen Parametern und einem Rückgabewert.
Danach kann man versuchen Vektoren und Matrizen an Funktionen zu über‐
geben oder mehrere Ergebnisse zurückzugeben.
Konkret : Was muss man machen, damit man die beiden folgenden Funktionen in MATLAB aufrufen kann?
void myHello(void)
{
printf("myHello");
}
double myAdd(double a, double b)
{
double c;
c = a + b;
return c;
}
4
F4.5 1 C‐Programm im Command‐Window (DOS‐Box) übersetzen
C‐Programme werden normalerweise in einer IDE übersetzt. Beim Übersetzen (Build‐Prozess) ruft die IDE den Compiler im Hintergrund auf und erzeugt als Ergebnis ein ausführbares Programm. Der Buildprozess kann durch eine Vielzahl von Optionen gesteuert werden. Die Optionen werden in der IDE gesetzt. Bei den meisten Optionen können die Standardeinstellungen verwendet werden.
Ein Programm kann aber auch ohne IDE übersetzt werden. Hierzu wird der Compiler in einem Command‐Window (DOS‐Box, Shell) aufgerufen. Damit der Compiler beim Aufruf einfach gefunden wird (z.B. die Datei gcc.exe), muss das Command‐Window entsprechend konfiguriert werden.
gcc.exe –o hello.exe chello.c
•
Der Wert der PATH‐Variablen legt fest, in welchen Verzeichnissen nach ausführ‐
baren Programmen (z.B. Compiler oder Linker) gesucht wird. Der Wert der PATH‐
Variablen kann über Systemsteuerung ‐> System ‐> Erweiterte Systemein‐
stellungen ‐> Umgebungsvariablen gesetzt werden.
Mit dem Befehl
set PATH=C:\meinVz;c:\sub1\suba;%PATH%
werden die beiden Verzeichnisse C:\meinVz und c:\sub1\suba zum Suchpfad hinzugefügt. %PATH% ist der aktuelle Wert der PATH‐Variablen.
5
F4.6
1 Übersetzen mit dem Compiler des Qt‐Creator
Ein C‐Programm mit dem Compiler des Qt‐Creator übersetzen und ausführen.
C‐Programm Bsp1.c
#include<stdio.h>
Befehlsdatei Bsp1Compile1.bat
void myHello(void);
gcc Bsp1.c
int main(void)
{
printf("Bsp1\n");
myHello();
}
Der Befehl übersetzt das C‐Programm und erzeugt ein ausführbares Programm mit dem Namen a.exe (Default‐Wert)
void myHello(void)
{
printf("myHello\n");
}
gcc -o Bsp1.exe Bsp1.c
Befehlsdatei Bsp1Compile2.bat
Übersetzt das C‐Programm und erzeugt ein ausführbares Programm mit dem Namen Bsp1.exe .
Befehlsdatei zum Setzen der echo Umgebung fuer Qt setzen
PATH‐Variablen setupQt.bat
set QT55=C:\Qt\Qt5.5.1
set PATH=%QT55%\5.5\mingw492_32\bin;%QT55%\Tools\
mingw492_32\bin;%PATH%
6
F4.7
1 Übersetzen mit dem Compiler des Qt‐Creator
Das C‐Programm Bsp1.c mit dem Compiler des Qt‐Creator (Programm gcc.exe) in einer DOS‐Box übersetzen und danach ausführen.
7
F4.8
1 Übersetzen mit dem Compiler des Qt‐Creator
Funktion myHello und Datei mit der main‐Methode in zwei getrennten Dateien
C‐Programm Bsp2.c
C‐Programm Bsp2Function.c
#include<stdio.h>
#include<stdio.h>
void myHello(void) {
printf("myHello\n");
}
void myHello(void);
int main(void) {
printf("Bsp2\n");
myHello();
}
Befehlsdatei Bsp2Compile1.bat
Anzeigen aller Optionen des Compilers mit dem Befehl : gcc –-help
gcc -o Bsp2.exe Bsp2.c Bsp2Function.c
Der Befehl übersetzt die beiden C‐Programme und erzeugt ein ausführbares Programm mit dem Namen Bsp2.exe .
Befehlsdatei Bsp2Compile2.bat
gcc -c Bsp2.c Bsp2Function.c
gcc -o Bsp3.exe Bsp2.o Bsp2Function.o
Der erste Befehl erzeugt nur Object‐Dateien (Endung .o) Der zweite Befehl erstellt aus den Object‐Dateien ein ausführbares Programm. 8
F4.9
1 Übersetzen mit dem Compiler des Visual Studio
Ein C‐Programm mit dem Compiler des Visual Studio übersetzen und ausführen.
C‐Programm Bsp1.c
#include<stdio.h>
Befehlsdatei Bsp1Compile1.bat
void myHello(void);
cl Bsp1.c
int main(void)
{
printf("Bsp1\n");
myHello();
}
Der Befehl übersetzt das C‐Programm und erzeugt ein ausführbares Programm mit dem Namen Bsp1.exe .
void myHello(void)
{
printf("myHello\n");
}
Befehlsdatei setupVS.bat Setzt die Umgebungsvariablen (u.a. PATH) so, dass der Compiler des Visual Studios in einer DOS‐Box verwendet werden kann. Die Batch‐
Datei vcvarsall.bat setzt die eigentlichen Variablen für 32‐Bit oder 64‐Bit.
echo Umgebung fuer VisualStudio setzen
SET DIR_VS="C:\Program Files (x86)\Microsoft Visual Studio 12.0"
call %DIR_VS%\VC\vcvarsall.bat x86
REM call %DIR_VS%\VC\vcvarsall.bat x64
9
F4.10
1 Übersetzen mit dem Compiler des Visual Studio
Funktion myHello und Datei mit der main‐Methode in zwei getrennten Dateien
C‐Programm Bsp2.c
C‐Programm Bsp2Function.c
#include<stdio.h>
#include<stdio.h>
void myHello(void) {
printf("myHello\n");
}
void myHello(void);
int main(void) {
printf("Bsp2\n");
myHello();
}
Befehlsdatei Bsp2Compile1.bat
Anzeigen aller Optionen des Compilers mit dem Befehl : cl /?
cl /Fe:Bsp2.exe Bsp2.c Bsp2Function.c
Der Befehl übersetzt die beiden C‐Programme und erzeugt ein ausführbares Programm mit dem Namen Bsp2.exe
Befehlsdatei Bsp2Compile2.bat
cl -c Bsp2.c Bsp2Function.c
link /out:Bsp3.exe Bsp2.obj Bsp2Function.obj
10
F4.11
2 C‐Programm mit Aufrufparametern
#include<stdio.h>
#include<stdlib.h>
double myAdd(double a, double b);
int main(int argc, char *argv[])
{
double a,b,c;
printf("%s\n", argv[0]);
if ( argc != 3) {
printf("Fehler\n");
printf("Aufruf: csum a b");
return -1;
}
a = strtod(argv[1],0);
b = strtod(argv[2],0);
c = myAdd(a,b);
printf("%.2f+%.2f=%.2f",a,b,c);
return 0;
}
double myAdd(double a, double b)
{
double sum;
sum = a + b;
return sum;
}
Beim Start eines C‐Programms kön‐
nen Aufrufparameter gesetzt werden. Diese werden vom Betriebssystem an die main‐Funktion als ein Array von Strings übergeben.
Beachte :
argc : Anzahl der Parameter
argv[0] : Programmname ‐ "csum" argv[1] : ein String ‐ "2.1"
argv[2] : ein String ‐ "4.5"
strtod : "string to double"
Umwandlung eines Strings in einen Wert vom Typ double
11
F4.12
3 C‐Programm in MATLAB ausführen
MATLAB bietet eine Schnittstelle (Interface) um C‐Programme innerhalb von MATLAB/Simulink auszuführen.
• Ein C‐Programm wird mit dem MATLAB‐Befehl mex übersetzt (mex ruft beim Übersetzen einen C‐Compiler auf) und es wird eine DLL (Dynamic‐Link‐Library) erzeugt. Diese DLL (Mex‐File) kann zur Laufzeit von MATLAB geladen und aus‐
geführt werden. Damit ist das C‐Programm innerhalb von MATLAB verfügbar.
• Ein MEX‐File verhält sich wie eine MATLAB‐Funktion (m‐File). M‐Files sind plattformunabhängig (Windows, Mac, Linux, 32‐ oder 64‐Bit). Sie werden vom MATLAB‐Interpreter gelesen und ausgeführt. MEX‐Files sind hingegen platt‐
formabhängig und müssen für jedes Betriebssystem getrennt erzeugt werden. Ebenso muss man zwischen 32‐ und 64‐Bit DLLs unterscheiden.
• MEX‐Files besitzen die Fileendung mexw32 oder mexw64 . Bevor es MATLAB für 32‐Bit und 64‐Bit gab, wurde die Endung dll verwendet.
• Damit MATLAB mit der MEX‐Utility mex ein C‐Programm übersetzen kann, muss ein C‐Compiler vorhanden sein. Die 32‐Bit‐Version von MATLAB bringt bereits einen 32‐Bit‐Compiler mit, den sogenannten lcc‐Compiler (siehe Ver‐
zeichnis ..\MATLAB\R20xx\sys\lcc). Die 64‐Bit‐Version von MATLAB enthält keinen C‐Compiler. Dieser muss separat installiert und MATLAB bekannt gemacht werden.
12
F4.13
3 C‐Programm in MATLAB ausführen – Beispiel1 myHello1.c
Compiler, der zum Übersetzen von myHello1.c verwendet wird
MATLAB‐Befehl mex
C‐Programm myHello1.c übersetzen und eine MEX‐Function erzeugen
Aufruf der DLL myHello1.mexw32
Beachte :
• Der Einstiegspunkt von MATLAB bei der Ausführung eines MEX‐Files ist immer die Funktion mexFunction. Diese Funktion muss vorhanden sein und „entspricht der Funktion main“. • Die Parameter der Funktion mexFunction dienen zum Austausch von Daten zwischen 13
MATLAB und der DLL – Funktionsparameter und Rückgabewerte.
F4.14
3 C‐Programm in MATLAB ausführen – Beispiel2 myHello2.c
Beachte :
• Die eigentliche Funktionalität, die man in MATLAB verwenden möchte, ist in der Funktion myHello enthalten. • Die Funktion mexFunktion stellt ein Interface zwischen MATLAB und der Funktion myHello
bereit. Die Funktion mexFunction bekommt die Aufrufparameter, ruft die Funktion myHello auf und gibt die Ergebnisse zurück.
• Im konkreten Fall sind keine Parameter und keine Rückgabewerte notwendig. Aber mit diesem Beispiel kann man testen, ob die Umgebung (z.B. Compiler) richtig aufgesetzt ist.
• Der Dateiname des C‐Programms legt den Namen des Mex‐Files fest.
14
F4.15
3 C‐Programm in MATLAB ausführen – Beispiel3 Addiere.c
Aufruf einer Funktion, die zwei Para‐
meter vom Typ double besitzt und als Ergebnis einen Wert vom Typ double zurückliefert.
Die Funktion Addiere kann keine Vektoren oder Matrizen addieren! Hierzu müsste man die Funktion noch geeignet erweitern.
15
F4.16
3 C‐Programm in MATLAB ausführen – Beispiel3 Addiere.c
mxArray
2.0
prhs[0]
Zeiger auf eine Variable vom Typ mxArray. Diese Variable wird von MATLAB beim Aufruf von Addiere erzeugt und an die Funk‐
tion mexFunction übergeben. Diese Variable speichert Daten (Typ, Wert, Dimensionen) über den ersten Funktionsparameter.
za = mxGetPr(prhs[0])
Gibt einen Zeiger auf die Speicherzelle zurück, die den Wert des ersten Funktionsparameters speichert (den Realteil).
*za Der Wert des ersten Parameters.
mxArray
5.0
plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
Erzeugt Variable vom Typ mxArray, die einen Wert vom Typ double speichert (eine 1*1‐Matrix). Die Funktion gibt den Zeiger auf diese Variable zurück. Für jeden Rückgabewert muss eine Variable vom Typ mxArray erzeugt werden.
zc = mxGetPr(plhs[0]);
Gibt einen Zeiger auf die Speicherzelle zurück, die den Wert des ersten Rückgabewertes speichert.
*zc Der Wert des ersten Rückgabewertes.
16
F4.17
3 C‐Programm in MATLAB ausführen – Beispiel4 Addiere1.c
#include<mex.h>
double myAdd(double, double);
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
Einfache Fehlerbehandlung double c,*za,*zb;
für den Funktionsaufruf
if ( (nrhs!=2) || (nlhs>1) ) {
mexErrMsgTxt("Aufruf: c = Addiere1(a,b)");
}
Genau 2 Aufrufparameter und za = mxGetPr(prhs[0]);
höchstens ein Rückgabewert
zb = mxGetPr(prhs[1]);
c = myAdd(*za,*zb);
plhs[0] = mxCreateDoubleScalar(c);
}
double myAdd(double a, double b) {
return a + b;
}
plhs[0] = mxCreateDoubleMatrix(1,1,mxREAL);
mxCreateDoubleScalar zc = mxGetPr(plhs[0]);
*zc = c;
17
F4.18
4 Der Befehl mex und die Funktion mexfunction
> help mex
mex - Build MEX-function from C/C++ or Fortran source code
This MATLAB function compiles and links one or more C, C++,
or Fortran source files into a binary MEX-file, callable
from MATLAB.
mex filenames
mex option1 ... optionN filenames
mex -setup lang
Reference page for mex
See also C/C++ Matrix Library API, clear, computer, dbmex,
Fortran Matrix Library API, inmem, loadlibrary,
mex.getCompilerConfigurations, mexext, pcode, prefdir,
system
18
F4.19
4 Der Befehl mex und die Funktion mexfunction
> mex -setup
MEX configured to use 'Microsoft Visual C++ 2013 Professional (C)' for C language compilation.
Warning: The MATLAB C and Fortran API has changed to support MATLAB variables with more than 2^32‐1 elements. In the near future you will be required to update your code to utilize the new API. You can find more information about this at …
To choose a different C compiler, select one from the following:
lcc‐win32
mex -setup:C:\Users\Reichl\AppData\Roaming\MathWorks
\MATLAB\R2015b\mex_C_win32.xml C
Microsoft Visual C++ 2013 Professional (C) mex -setup:'C:\Program Files (x86)\MATLAB\R2015b\bin
\win32\mexopts\msvc2013.xml' C
To choose a different language, select one from the following:
mex -setup C++
mex -setup FORTRAN
19
4 Der Befehl mex und die Funktion mexfunction
F4.20
#include "mex.h"
void mexFunction(int nlhs,mxArray *plhs[],int nrhs,const mxArray *prhs[])
nlhs
plhs
nrhs
prhs
Number of expected output mxArrays ( entspricht nargout )
Array of pointers to the expected output mxArrays ( entspricht vargout )
Number of input mxArrays ( entspricht nargin )
Array of pointers to the input mxArrays. Do not modify any prhs values in your MEX‐file.
Changing the data in these read‐only mxArrays can produce undesired side effects ( vargin )
Description
mexFunction is not a routine you call. Rather, mexFunction is the name of the gateway function in C (subroutine in Fortran) which every MEX‐file requires. When you invoke a MEX‐function, MATLAB software finds and loads the corresponding MEX‐file of the same name. MATLAB then searches for a symbol named mexFunction within the MEX‐file. If it finds one, it calls the MEX‐function using the address of the mexFunction symbol. MATLAB displays an error message if it cannot find a routine named mexFunction inside the MEX‐file.
When you invoke a MEX‐file, MATLAB automatically seeds nlhs, plhs, nrhs, and prhs with the caller's information. In the syntax of the MATLAB language, functions have the general form:
[a,b,c,...] = fun(d,e,f,...)
where the ... denotes more items of the same format. The a,b,c... are left‐side output arguments, and the d,e,f... are right‐side input arguments. The arguments nlhs and nrhs contain the number of left side and right side arguments, respectively. prhs is an array of mxArray pointers whose length is nrhs. plhs is an array whose length is nlhs, where your function must set pointers for the output mxArrays.
20
F4.21
5 Die Struktur mxArray und die mx‐Funktionen
Datentyp mxArray
Eine Variable des Typs mxArray repräsentiert eine MATLAB‐Variable. Variablen des Typs mxArrays werden verwendet um MATLAB‐Variablen in ein C‐Programm zu bringen und um Ergebnisse an MATLAB‐Variablen zurückzugeben.
Für jeden Parameter beim Funktionsaufruf und jedes Ergebnis wird ein mxArray benötigt. Ein Variable des Typs mxArray kann den Wert eines Skalars, eines Vektors, einer Matrix , einer Struktur, … speichern.
Der Aufbau der Struktur mxArray ist von MATLAB nicht offen gelegt, d.h. es gibt keine offizielle Definition dieser Struktur.
Der Zugriff auf Informationen, die in einem mxArray gespeichert sind, z.B. der Wert, der Typ oder die Größe erfolgt über geeignete mx‐Funktionen. Funktionen zum Zugriff auf eine Variable vom Typ mxArray
mxIsDouble mxisComplex
mxCreateDoubleScalar
mxCreateDoubleMatrix
mxGetPr
mxGetPi
mxGetM
mxGetN
mxCreateNumericArray
mxGetDimensions
Funktionen mit Präfix mex führen Operationen in der MATLAB‐Umgebung aus
mexFunction
mexErrMsgTxt
21
F4.22
6 Addiere Vektoren und Matrizen
Beispiel :
Schreiben Sie eine mex‐Funktion VektorAdd, die zwei Spaltenvektoren gleicher Länge addiert und das Ergebnis zurückgibt. Verwenden Sie die C‐
Funktion vektorAddition.
x = [1;2]
y = [3;4]
z = VektorAdd(x,y)
void vektorAddition(double x[],double y[],double z[],int n)
{
int k;
for (k=0; k<n; k++) {
z[k] = x[k] + y[k];
}
}
void vektorAddition(double *zgx,double *zgy,double *zgz,int n)
{
int k;
for (k=0; k<n; k++) {
*(zgz+k) = *(zgx+k) + *(zgy+k);
}
zgz[k] = zgx[k] + zgy[k];
}
22
F4.23
6 Addiere Vektoren und Matrizen : Zwei Spaltenvektoren
#include<mex.h>
void vektorAddition(double *zgx,double *zgy,double *zgz,int n);
void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[])
{
int M;
double *zgx, *zgy, *zgz;
M = mxGetM(prhs[0]);
// M Anzahl der Zeilen
zgx = mxGetPr(prhs[0]); //Zeiger auf erstes Element des Vektors
zgy = mxGetPr(prhs[1]);
plhs[0] = mxCreateDoubleMatrix(M,1,mxREAL);
zgz = mxGetPr(plhs[0]);
vektorAddition(zgx,zgy,zgz,M);
}
Frage :
Was passiert beim Aufruf von z = VektorAdd(x,y) , wenn x und y Zeilen‐
vektoren sind?
Was muss man ändern, damit ein Zeilenvektor als Ergebnis zurückgegeben wird?
Was muss man ändern, damit auch Matrizen addiert werden können?
23
F4.24
6 Matrix ausgeben ‐ Spaltenweise void mexFunction(int nlhs, mxArray *plhs[],
int nrhs, const mxArray *prhs[]){
int M,N,k;
double x,*za;
M = mxGetM(prhs[0]);
N = mxGetN(prhs[0]);
printf("Zeilen M=%d\n",M);
printf("Spalten N=%d\n",N);
za = mxGetPr(prhs[0]);
for (k=0; k<M*N; k++) {
x = *za;
printf("k=%d x=%.2f\n",k,x);
za++;
}
}
Speicherung von Matrizen :
• MATLAB speichert Matrizen spaltenweise
• Die Programmiersprache C speichert Matrizen zeilenweise
• Fortran speichert Matrizen spaltenweise
24
F4.25
6 Matrix ausgeben ‐ Zeilenweise #include<mex.h>
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int m,n,N,M;
double x,*za;
M = mxGetM(prhs[0]); //Anzahl der Zeilen
N = mxGetN(prhs[0]); //Anzahl der Spalten
printf("Zeilen M=%d\n",M);
printf("Spalten N=%d\n",N);
za = mxGetPr(prhs[0]); for (m=0; m<M; m++) {
for (n=0; n<N; n++) {
x = *( za + m + n*M ) ; // x = za[ m + n*M ] ;
printf("%6.2f",x);
}
printf("\n");
}
}
Beachte : *(za+m+n*M) A(m+1,n+1)
za[m+n*M] A(m+1,n+1)
*(za+m+n*M) B(m+1,n+1)
za[m+n*M] B(m+1,n+1)
für 0 m M und 0 n N
25
F4.26
7 Search Path
> sin = 3
sin =
3
> y = sin(1)
y =
3
> z = sin(pi/2)
Subscript indices must either be real positive integers
or logicals.
> sin(2)= pi
sin =
3.0000
3.1416
> which sin
sin is a variable.
> clear sin
> which sin
built-in (C:\Program Files\MATLAB\R2014b\toolbox\matlab
\elfun\@double\sin) % double method
26
F4.27
7 Search Path
Where Does MATLAB Look for Files?
When you do not specify a path to a file, MATLAB looks for the file in the current folder or on the search path. Functions in the current folder take precedence over functions with the same file name that reside anywhere on the search path. To identify the current folder, type pwd in the Command Window.
Files and Folders You Should Add to the Search Path
The MATLAB search path should include:
• Folders containing files that you run.
• Folders containing files that are called by files you run.
• Subfolders containing files that you run. Making a folder accessible does not make its subfolders accessible.
27
F4.28
7 Search Path
Search Path Basics
The search path, or path is a subset of all the folders in the file system. MATLAB software uses the search path to efficiently locate files used with MathWorks products. MATLAB can access all files in the folders on the search path.
The order of folders on the search path is important. When files with the same name appear in multiple folders on the search path, MATLAB uses the one found in the folder nearest to the top of the search path.
By default, the search path includes
• Folders provided with MATLAB and other MathWorks products
These folders are under matlabroot/toolbox, where matlabroot is the folder displayed when you type matlabroot in the Command Window.
• The MATLAB userpath
The userpath folder is a location for storing files that MATLAB adds to the search path at startup.
• You can explicitly add folders to the search path for the files you run.
28
F4.29
7 Search Path ‐ GUI : Environment‐Tab ‐> Set Path
Enthält z.B. mexFiles
Enthält z.B. selbstgeschriebene Hilfsfunktionen
userpath‐Verzeichnis
MATLAB‐Root‐Verzeichnis : C:\Program Files\MATLAB\R2014b
Bei der Installation von MATLAB wird der Search Path initialisiert, so dass alle MATLAB‐Funktionen gefunden werden. Der Anwender kann den Search Path anschließend ändern.
29
F4.30
7 Search Path ‐ Befehle
which
which ‐ Locate functions and files
This MATLAB function displays the full path for item.
path
path ‐ View or change search path
userpath
matlabroot
addpath : addpath(folderName1,..., folderNameN)
30
F4.31
8 Aufgabe 1
Schreiben Sie eine Mex‐Funktion mexDot , die das Skalarprodukt von zwei Vektoren berechnet und zurückgibt. Aufruf in MATLAB :
z = mexDot(x,y)
Hierbei sind x und y Zeilen‐ oder Spaltenvektoren.
Das Skalarprodukt wird mit folgender C‐Funktion berechnet :
double dotProduct(double x[], double y[], int n)
{
int k;
double sp=0.0;
for (k=0; k<n ;k++) {
sp = sp + x[k] * y[k];
}
return sp;
}
Berücksichtigen Sie folgende Fehlerfälle :
• Werden keine zwei Parameter übergeben, wird eine Fehlermeldung ausgegeben.
• Sind die Vektoren x und y nicht gleich lang, erfolgt eine Fehlermeldung, die die beiden Längen der Vektoren ausgibt.
Schreiben Sie ein geeignetes Skript, um die Funktion mexDot zu testen.
31
F4.32
8 Aufgabe 2
Schreiben Sie eine Mex‐Funktion mexMatrixAdd , die zwei Matrizen gleicher Größe addiert und das Ergebnis zurückgibt. Aufruf in MATLAB :
C = mexMatrixAdd(A, B)
Hierbei sind A und B zwei Matrizen mit gleicher Dimension. Eine Fehlerbe‐
handlung muss nicht gemacht werden.
Schreiben Sie zusätzlich ein Skript, um die Funktion mexMatrixAdd zu testen.
32
F4.33
8 Aufgabe 3
Schreiben Sie eine Mex‐Funktion mexMatrixMult , die eine Matrix A mit einem Vektor x multipliziert und das Ergebnis zurückgibt. Aufruf in MATLAB :
y = mexMatrixMult(A, x)
Hierbei ist A eine m*n‐Matrix und x ein Spaltenvektor mit n Zeilen. Eine Fehlerbehandlung muss nicht gemacht werden.
Schreiben Sie zusätzlich ein Skript, um die Funktion mexMatrixMult zu testen.
33
© Copyright 2024 ExpyDoc
