MATLAB LanguageErste Schritte mit MATLAB Language

Versionen

Ausführung Veröffentlichung Veröffentlichungsdatum
1,0 1984-01-01
2 1986-01-01
3 1987-01-01
3,5 1990-01-01
4 1992-01-01
4.2c 1994-01-01
5,0 Band 8 1996-12-01
5.1 Band 9 1997-05-01
5.1.1 R9.1 1997-05-02
5.2 R10 1998-03-01
5.2.1 R10.1 1998-03-02
5.3 R11 1999-01-01
5.3.1 R11.1 1999-11-01
6,0 R12 2000-11-01
6.1 R12.1 2001-06-01
6,5 R13 2002-06-01
6.5.1 R13SP2 2003-01-01
6.5.2 R13SP2 2003-01-02
7 R14 2006-06-01
7.0.4 R14SP1 2004-10-01
7.1 R14SP3 2005-08-01
7.2 R2006a 2006-03-01
7.3 R2006b 2006-09-01
7.4 R2007a 2007-03-01
7,5 R2007b 2007-09-01
7.6 R2008a 2008-03-01
7.7 R2008b 2008-09-01
7.8 R2009a 2009-03-01
7,9 R2009b 2009-09-01
7.10 R2010a 2010-03-01
7.11 R2010b 2010-09-01
7.12 R2011a 2011-03-01
7.13 R2011b 2011-09-01
7.14 R2012a 2012-03-01
8,0 R2012b 2012-09-01
8.1 R2013a 2013-03-01
8.2 R2013b 2013-09-01
8.3 R2014a 2014-03-01
8.4 R2014b 2014-09-01
8,5 R2015a 2015-03-01
8,6 R2015b 2015-09-01
9,0 R2016a 2016-03-01
9.1 R2016b 2016-09-14
9.2 R2017a 2017-03-08

Siehe auch: MATLAB-Veröffentlichungsgeschichte auf Wikipedia .

Hallo Welt

Öffnen Sie ein neues leeres Dokument im MATLAB-Editor (wählen Sie dazu in den letzten Versionen von MATLAB die Registerkarte Start des Werkzeugstreifens aus und klicken Sie auf Neues Skript). Die Standardtastenkombination zum Erstellen eines neuen Skripts lautet Ctrl-n .

Alternativ können Sie durch Eingabe von edit myscriptname.m die Datei myscriptname.m zur Bearbeitung öffnen oder anbieten, die Datei zu erstellen, falls sie nicht im MATLAB-Pfad vorhanden ist.

Geben Sie im Editor Folgendes ein:

disp('Hello, World!');

Wählen Sie die Registerkarte Editor des Werkzeugstreifens und klicken Sie auf Speichern unter. Speichern Sie das Dokument in einer Datei im aktuellen Verzeichnis namens helloworld.m . Wenn Sie eine unbenannte Datei speichern, wird ein Dialogfeld zum Benennen der Datei angezeigt.

Geben Sie im MATLAB-Befehlsfenster Folgendes ein:

>> helloworld

Sie sollten die folgende Antwort im MATLAB-Befehlsfenster sehen:

Hello, World!

Wir sehen, dass wir im Befehlsfenster die Namen von Funktionen oder Skriptdateien eingeben können, die wir geschrieben haben oder die mit MATLAB ausgeliefert wurden, um sie auszuführen.

Hier haben wir das Skript 'helloworld' ausgeführt. Beachten Sie, dass die Eingabe der Erweiterung ( .m ) nicht .m ist. Die Anweisungen in der Skriptdatei werden von MATLAB ausgeführt. Hier wird "Hallo, Welt!" Gedruckt. mit der disp Funktion.

Skriptdateien können auf diese Weise geschrieben werden, um eine Reihe von Befehlen zur späteren (erneuten) Verwendung zu speichern.

Matrizen und Arrays

In MATLAB ist der grundlegendste Datentyp das numerische Array. Dies kann ein Skalar, ein 1-D-Vektor, eine 2-D-Matrix oder ein mehrdimensionales ND-Array sein.

% a 1-by-1 scalar value
x = 1;

Um einen Zeilenvektor zu erstellen, geben Sie die Elemente in Klammern ein, getrennt durch Leerzeichen oder Kommas:

% a 1-by-4 row vector
v = [1, 2, 3, 4];
v = [1 2 3 4];

Um einen Spaltenvektor zu erstellen, trennen Sie die Elemente durch Semikolons:

% a 4-by-1 column vector
v = [1; 2; 3; 4];

Um eine Matrix zu erstellen, geben wir die Zeilen wie zuvor getrennt durch Semikolons ein:

% a 2 row-by-4 column matrix
M = [1 2 3 4; 5 6 7 8];

% a 4 row-by-2 column matrix
M = [1 2; ...
     4 5; ...
     6 7; ...
     8 9];

Beachten Sie, dass Sie keine Matrix mit ungleicher Zeilen- / Spaltengröße erstellen können. Alle Zeilen müssen dieselbe Länge haben und alle Spalten müssen dieselbe Länge haben:

% an unequal row / column matrix
M = [1 2 3 ; 4 5 6 7]; % This is not valid and will return an error

% another unequal row / column matrix
M = [1 2 3; ...
     4   5; ...
     6 7 8; ...
     9   10];     % This is not valid and will return an error

Um einen Vektor oder eine Matrix zu transponieren, verwenden wir das .' -operator oder der ' Operator ' , um sein hermitianisches Konjugat zu nehmen, das das komplexe Konjugat seiner Transponierten ist. Für echte Matrizen sind diese beiden gleich:

% create a row vector and transpose it into a column vector
v = [1 2 3 4].';              % v is equal to [1; 2; 3; 4];

% create a 2-by-4 matrix and transpose it to get a 4-by-2 matrix
M = [1 2 3 4; 5 6 7 8].';     % M is equal to [1 5; 2 6; 3 7; 4 8]

% transpose a vector or matrix stored as a variable
A = [1 2; 3 4];
B = A.';                      % B is equal to [1 3; 2 4]

Bei Arrays mit mehr als zwei Dimensionen gibt es keine direkte Sprachsyntax, um sie wörtlich einzugeben. Stattdessen müssen wir Funktionen verwenden, um sie zu konstruieren (wie ones , zeros , rand ) oder indem wir andere Arrays (mit Funktionen wie cat , reshape , permute ) permute . Einige Beispiele:

% a 5-by-2-by-4-by-3 array (4-dimensions)
arr = ones(5, 2, 4, 3);

% a 2-by-3-by-2 array (3-dimensions)
arr = cat(3, [1 2 3; 4 5 6], [7 8 9; 0 1 2]);

% a 5-by-4-by-3-by-2 (4-dimensions)
arr = reshape(1:120, [5 4 3 2]);

Indizierung von Matrizen und Arrays

MATLAB erlaubt verschiedene Methoden, um Elemente von Matrizen und Arrays zu indizieren (zuzugreifen):

  • Indexierung mit Index - Hier können Sie die Position der gewünschten Elemente in jeder Dimension der Matrix separat festlegen.
  • Lineare Indizierung - wobei die Matrix unabhängig von ihren Abmessungen als Vektor behandelt wird. Das heißt, Sie geben jede Position in der Matrix mit einer einzigen Nummer an.
  • Logische Indizierung : Hier verwenden Sie eine logische Matrix (und eine Matrix aus true und false Werten) mit den identischen Dimensionen der Matrix, die Sie als Maske indizieren möchten, als Maske, um anzugeben, welcher Wert zurückgegeben werden soll.

Diese drei Methoden werden nun am Beispiel der folgenden 3-mal-3-Matrix M näher erläutert:

>> M = magic(3)

ans = 

       8    1    6
       3    5    7
       4    9    2

Indexierte Indexierung

Die einfachste Methode für den Zugriff auf ein Element ist die Angabe des Zeilenspaltenindex. Beispiel: Zugriff auf das Element in der zweiten Zeile und dritten Spalte:

>> M(2, 3)

ans =

      7

Die Anzahl der bereitgestellten Subskripte stimmt genau mit der Anzahl der Dimensionen überein, die M hat (zwei in diesem Beispiel).

Beachten Sie, dass die Reihenfolge der Indizes der mathematischen Konvention entspricht: Der Zeilenindex ist der erste. Darüber hinaus beginnen MATLAB-Indizes mit 1 und nicht wie bei den meisten Programmiersprachen mit 0 .

Sie können mehrere Elemente gleichzeitig indizieren, indem Sie für jede Koordinate einen Vektor anstelle einer einzelnen Zahl übergeben. Um beispielsweise die gesamte zweite Zeile zu erhalten, können Sie angeben, dass die erste, zweite und dritte Spalte gewünscht wird:

>> M(2, [1,2,3])

ans =

       3    5    7

In MATLAB wird der Vektor [1,2,3] leichter mit dem Doppelpunktoperator erstellt, dh 1:3 . Sie können dies auch bei der Indizierung verwenden. Um eine ganze Zeile (oder Spalte) auszuwählen, stellt MATLAB eine Verknüpfung bereit, indem Sie Folgendes angeben : Der folgende Code gibt beispielsweise auch die gesamte zweite Zeile zurück

>> M(2, :)

ans =

       3    5    7

MATLAB stellt auch eine Verknüpfung zum Angeben des letzten Elements einer Dimension in Form des Schlüsselworts end bereit. Das Schlüsselwort end funktioniert genau so, als wäre es die Nummer des letzten Elements in dieser Dimension. Wenn Sie also alle Spalten von Spalte 2 bis zur letzten Spalte haben möchten, können Sie Folgendes schreiben:

>> M(2, 2:end)

ans =

       5    7

Die Index-Indexierung kann restriktiv sein, da es nicht möglich ist, einzelne Werte aus verschiedenen Spalten und Zeilen zu extrahieren. Es wird die Kombination aller Zeilen und Spalten extrahiert.

>> M([2,3], [1,3])
ans =

       3    7
       4    2

Beispielsweise kann die Indexierung mit Index nicht nur die Elemente M(2,1) oder M(3,3) extrahieren. Dazu müssen wir die lineare Indizierung in Betracht ziehen.

Lineare Indizierung

Mit MATLAB können Sie n-dimensionale Arrays als eindimensionale Arrays behandeln, wenn Sie mit nur einer Dimension indizieren. Sie können direkt auf das erste Element zugreifen:

>> M(1)

ans = 

       8

Beachten Sie, dass Arrays in der Reihenfolge der Spalten in MATLAB gespeichert werden. Dies bedeutet, dass Sie auf die Elemente zugreifen, indem Sie zuerst die Spalten nach unten verschieben. Also ist M(2) das zweite Element der ersten Spalte, das 3 und M(4) wird das erste Element der zweiten Spalte sein, dh

>> M(4)

ans = 

        1

In MATLAB gibt es integrierte Funktionen, um Index-Indizes in lineare Indizes umzuwandeln und umgekehrt: sub2ind und ind2sub . Sie können die Indizes ( r , c ) manuell in einen linearen Index umwandeln

idx = r + (c-1)*size(M,1)

Um dies zu verstehen, wenn wir uns in der ersten Spalte befinden, ist der lineare Index einfach der Zeilenindex. Die obige Formel gilt für dies, weil für c == 1 (c-1) == 0 . In den nächsten Spalten ist der lineare Index die Zeilennummer plus alle Zeilen der vorherigen Spalten.

Beachten Sie, dass das Schlüsselwort end weiterhin gilt und sich auf das letzte Element des Arrays bezieht, dh M(end) == M(end, end) == 2 .

Sie können auch mehrere Elemente mit linearer Indizierung indizieren. Wenn Sie dies tun, hat die zurückgegebene Matrix dieselbe Form wie die Matrix der Indexvektoren.

M(2:4) gibt einen Zeilenvektor zurück, da 2:4 den Zeilenvektor [2,3,4] :

>> M(2:4)

ans =

        3    4    1

Als ein anderes Beispiel gibt M([1,2;3,4]) eine 2-mal-2-Matrix zurück, da [1,2;3,4] eine 2-mal-2-Matrix ist. Sehen Sie sich den Code unten an, um sich selbst zu überzeugen:

>> M([1,2;3,4])

ans =

       8        3
       4        1

Beachten Sie, dass die Indizierung mit : alone immer einen Spaltenvektor zurückgibt:

>> M(:)

ans = 

        8
        3
        4
        1
        5
        9
        6
        7
        2

Dieses Beispiel veranschaulicht auch die Reihenfolge, in der MATLAB Elemente bei der linearen Indizierung zurückgibt.

Logische Indizierung

Die dritte Indizierungsmethode besteht in der Verwendung einer logischen Matrix, dh einer Matrix, die nur true oder false Werte enthält, als Maske zum Herausfiltern der nicht gewünschten Elemente. Wenn wir zum Beispiel alle Elemente von M finden möchten, die größer als 5 , können wir die logische Matrix verwenden

>> M > 5

ans =

    1    0    1
    0    0    1
    0    1    0

M indizieren und nur die Werte zurückgeben, die größer als 5 wie folgt:

>> M(M > 5)

ans =

        8
        9
        6
        7

Wenn Sie möchten, dass diese Nummer an Ort und Stelle bleibt (dh die Form der Matrix beibehalten), können Sie das logische Kompliment zuweisen

>> M(~(M > 5)) = NaN

ans = 

    8      NaN    6
    NaN    NaN    7
    NaN    9      Nan

Wir können komplizierte Codeblöcke mit if und for Anweisungen reduzieren, indem Sie die logische Indizierung verwenden.

Nehmen Sie das nicht vektorisierte (bereits verkürzt durch lineare Indizierung zu einer einzelnen Schleife):

for elem = 1:numel(M)
  if M(elem) > 5
    M(elem) = M(elem) - 2;
  end
end

Dies kann durch logische Indizierung auf folgenden Code verkürzt werden:

idx = M > 5;
M(idx) = M(idx) - 2;

Oder noch kürzer:

M(M > 5) = M(M > 5) - 2;

Mehr zum Indexieren

Matrizen mit höherer Dimension

Alle oben genannten Methoden verallgemeinern in n-Dimensionen. Wenn wir als Beispiel die dreidimensionale Matrix M3 = rand(3,3,3) , können Sie durch Schreiben auf alle Zeilen und Spalten der zweiten Schicht der dritten Dimension zugreifen

>> M(:,:,2)

Sie können durch lineare Indizierung auf das erste Element des zweiten Slice zugreifen. Die lineare Indizierung wird nur nach allen Zeilen und allen Spalten des ersten Slice in das zweite Slice verschoben. Der lineare Index für dieses Element lautet also

>> M(size(M,1)*size(M,2)+1)

Tatsächlich ist jede Matrix in MATLAB n-dimensional: Es ist nur so, dass die Größe der meisten anderen n-Dimensionen eins ist. Wenn also a = 2 dann ist a(1) == 2 (wie zu erwarten ist), aber auch a(1, 1) == 2 , ebenso wie a(1, 1, 1) == 2 , a(1, 1, 1, ..., 1) == 2 und so weiter. Diese "zusätzlichen" Dimensionen (von Größe 1 ) werden als Singleton-Dimensionen bezeichnet . Mit dem Befehl squeeze werden sie entfernt, und Sie können permute , um die Reihenfolge der Dimensionen zu vertauschen (und gegebenenfalls Singleton-Dimensionen einzuführen).

Eine n-dimensionale Matrix kann auch mit einem m Index (mit m <= n) indiziert werden. Die Regel ist, dass sich die ersten m-1-Indizes normal verhalten, während der letzte (m'-te) Index auf die verbleibenden (n-m + 1) Dimensionen verweist, genauso wie ein linearer Index auf eine (n-m + 1) Dimension verweisen würde Array. Hier ist ein Beispiel:

>> M = reshape(1:24,[2,3,4]);
>> M(1,1)
ans =
     1
>> M(1,10)
ans =
    19
>> M(:,:)
ans =
     1     3     5     7     9    11    13    15    17    19    21    23
     2     4     6     8    10    12    14    16    18    20    22    24

Rückgabe von Elementbereichen

Wenn Sie bei der Indexindexierung mehr als ein Element in mehr als einer Dimension angeben, gibt MATLAB jedes mögliche Koordinatenpaar zurück. Wenn Sie beispielsweise M ([1,2], [1,3]) versuchen, gibt MATLAB M(1,1) und M(2,3) aber auch M(1,3) und M(2,1) . Dies kann uninteressant erscheinen, wenn Sie nach Elementen für eine Liste von Koordinatenpaaren suchen. Beachten Sie jedoch das Beispiel einer größeren Matrix, A = rand(20) (Note A ist jetzt 20 mal- 20 ), in der Sie die erhalten möchten oberer rechter Quadrant. In diesem Fall müssen Sie nicht jedes Koordinatenpaar in diesem Quadranten angeben (und in diesem Fall wären es 100 Paare), sondern nur die 10 Zeilen und die 10 gewünschten Spalten, also A(1:10, 11:end) . Ein derartiges Aufteilen einer Matrix ist weitaus häufiger als das Erfordernis einer Liste von Koordinatenpaaren.

Für den Fall, dass Sie eine Liste von Koordinatenpaaren erhalten möchten, ist die einfachste Lösung die Konvertierung in lineare Indizierung. Betrachten Sie das Problem, bei dem Sie einen Vektor von Spaltenindizes haben, den Sie zurückgeben möchten, wobei jede Zeile des Vektors die Spaltennummer enthält, die Sie für die entsprechende Zeile der Matrix zurückgeben möchten. Zum Beispiel

colIdx = [3;2;1]

In diesem Fall möchten Sie also die Elemente bei (1,3) , (2,2) und (3,1) zurückbekommen. Also mit linearer Indizierung:

>> colIdx = [3;2;1];
>> rowIdx = 1:length(colIdx);
>> idx = sub2ind(size(M), rowIdx, colIdx);
>> M(idx)

ans = 

        6    5    4

Ein Element mehrmals zurückgeben

Mit der Index- und linearen Indizierung können Sie ein Element auch mehrmals zurückgeben, indem Sie dessen Index wiederholen

>> M([1,1,1,2,2,2])

ans = 

        8    8    8    3    3    3

Sie können dies verwenden, um ganze Zeilen und Spalten zu kopieren, um beispielsweise die erste Zeile und die letzte Spalte zu wiederholen

>> M([1, 1:end], [1:end, end])

ans = 

        8    1    6    6 
        8    1    6    6
        3    5    7    7
        4    9    2    2

Weitere Informationen finden Sie hier .

Sich selbst helfen

MATLAB verfügt über viele integrierte Skripts und Funktionen, die von der einfachen Multiplikation bis zur Bilderkennungs-Toolbox reichen. Um Informationen zu einer Funktion zu erhalten, die Sie verwenden möchten, geben Sie Folgendes ein: help functionname in der Befehlszeile. Nehmen wir die help als Beispiel.

Informationen zur Verwendung erhalten Sie, indem Sie Folgendes eingeben:

>> help help

im Befehlsfenster. Dies wird Informationen über die Nutzung der Funktion zurückgeben help . Wenn die gesuchten Informationen immer noch unklar sind, können Sie die Dokumentationsseite der Funktion ausprobieren. Einfach tippen:

>> doc help

im Befehlsfenster. Dies wird die durchsuchbaren Dokumentation auf der Seite für die Funktion öffnen help alle Informationen , die Sie benötigen , um zu verstehen , wie die ‚Hilfe‘ funktioniert.

Diese Prozedur funktioniert für alle integrierten Funktionen und Symbole.

Wenn Sie Ihre eigenen Funktionen entwickeln, können Sie ihnen einen eigenen Hilfeabschnitt geben, indem Sie Kommentare oben in der Funktionsdatei oder direkt nach der Funktionsdeklaration hinzufügen.

Beispiel für eine einfache Funktion multiplyby2 die in der Datei multiplyby2.m gespeichert ist

function [prod]=multiplyby2(num)
% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

    prod=num*2;
end

oder

% function MULTIPLYBY2 accepts a numeric matrix NUM and returns output PROD 
% such that all numbers are multiplied by 2

function [prod]=multiplyby2(num)
    prod=num*2;
end

Dies ist sehr nützlich, wenn Sie den Code Wochen / Monate / Jahre nach dem Schreiben abholen.

Die help und doc bietet viele Informationen. Wenn Sie wissen, wie Sie diese Funktionen verwenden, können Sie schnell Fortschritte erzielen und MATLAB effizient nutzen.

Lese- und Schreibausgabe

Wie alle Programmiersprachen kann Matlab in einer Vielzahl von Formaten lesen und schreiben. Die systemeigene Bibliothek unterstützt eine Vielzahl von Text-, Bild-, Video-, Audio- und Datenformaten, wobei in jedem Versionsupdate weitere Formate enthalten sind. Klicken Sie hier , um die vollständige Liste der unterstützten Dateiformate und die zu importierenden Funktionen anzuzeigen.

Bevor Sie versuchen, Ihre Datei zu laden, müssen Sie sich fragen, wie die Daten aussehen sollen und wie der Computer die Daten für Sie organisieren soll. Angenommen, Sie haben eine TXT / CSV-Datei im folgenden Format:

Fruit,TotalUnits,UnitsLeftAfterSale,SellingPricePerUnit
Apples,200,67,$0.14
Bananas,300,172,$0.11
Pineapple,50,12,$1.74

Wir können sehen, dass die erste Spalte das Format von Strings hat, während die zweite, dritte Spalte numerisch ist, die letzte Spalte die Form von Währung. Nehmen wir an, wir möchten herausfinden, wie viel Umsatz wir heute mit Matlab erzielt haben. Zuerst wollen wir diese txt / csv-Datei laden. Nachdem Sie den Link überprüft haben, können Sie sehen, dass Text- und numerische Textdateien von textscan . Also könnten wir versuchen:

fileID = fopen('dir/test.txt'); %Load file from dir
C = textscan(fileID,'%s %f %f %s','Delimiter',',','HeaderLines',1); %Parse in the txt/csv

Dabei gibt %s , dass das Element ein String-Typ ist. %f schlägt vor, dass das Element ein Float-Typ ist und dass die Datei durch "," begrenzt ist. Die Option HeaderLines fordert Matlab auf, die ersten N-Zeilen zu überspringen, während die 1 unmittelbar danach bedeutet, die erste Zeile (die Kopfzeile) zu überspringen.

Jetzt sind C die Daten, die wir geladen haben, und zwar in Form eines Zellen-Arrays mit 4 Zellen, die jeweils die Datenspalte in der TXT / CSV-Datei enthalten.

Zuerst wollen wir berechnen, wie viele Früchte wir heute verkauft haben, indem wir die dritte Spalte von der zweiten Spalte abziehen. Dies kann folgendermaßen geschehen:

sold = C{2} - C{3}; %C{2} gives the elements inside the second cell (or the second column)

Nun wollen wir diesen Vektor mit dem Preis pro Einheit multiplizieren, also müssen wir zuerst diese Spalte von Strings in eine Spalte von Numbers konvertieren und dann mit Matlab's cell2mat in eine numerische Matrix konvertieren. Neben dem "$" - Zeichen gibt es dafür viele Möglichkeiten. Der direkteste Weg ist die Verwendung eines einfachen Regex:

D = cellfun(@(x)(str2num(regexprep(x, '\$',''))), C{4}, 'UniformOutput', false);%cellfun allows us to avoid looping through each element in the cell.

Oder Sie können eine Schleife verwenden:

for t=1:size(C{4},1)
   D{t} = str2num(regexprep(C{4}{t}, '\$',''));
end

E = cell2mat(D)% converts the cell array into a Matrix

Die Funktion str2num die Zeichenfolge mit "$" - Zeichen in numerische Typen um und cell2mat verwandelt die Zelle mit numerischen Elementen in eine Zahlenmatrix

Jetzt können wir die verkauften Einheiten mit den Stückkosten multiplizieren:

revenue = sold .* E; %element-wise product is denoted by .* in Matlab

totalrevenue = sum(revenue);

Zellenarrays

Elemente derselben Klasse können oft zu Arrays verkettet werden (mit wenigen Ausnahmen, z. B. Funktionskennungen). Numerische Skalare, wird standardmäßig der Klasse double kann in einer Matrix gespeichert werden.

>> A = [1, -2, 3.14, 4/5, 5^6; pi, inf, 7/0, nan, log(0)]
A =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf

Zeichen, die in MATLAB von der Klasse char , können auch mit ähnlicher Syntax in einem Array gespeichert werden. Ein solches Array ähnelt einem String in vielen anderen Programmiersprachen.

>> s = ['MATLAB ','is ','fun']
s =
MATLAB is fun

Beachten Sie, dass die Ergebnisklassen unterschiedlich sind, obwohl beide Klammern [ und ] . Daher sind auch die Operationen, die an ihnen ausgeführt werden können, unterschiedlich.

>> whos
  Name      Size            Bytes  Class     Attributes

  A         2x5                80  double              
  s         1x13               26  char                

In der Tat, das Array s kein Array des Strings ist 'MATLAB ' , 'is ' und 'fun' , es ist nur eine Zeichenfolge - ein Array von 13 Zeichen. Sie würden die gleichen Ergebnisse erhalten, wenn dies durch eine der folgenden Bedingungen definiert würde:

>> s = ['MAT','LAB ','is f','u','n'];
>> s = ['M','A','T','L','A','B,' ','i','s',' ','f','u','n'];

Mit einem regulären MATLAB-Vektor können Sie keine Variablen verschiedener Klassen oder einige andere Zeichenfolgen speichern. Hier ist das cell Array praktisch. Dies ist ein Array von Zellen, die jeweils ein MATLAB-Objekt enthalten können, dessen Klasse sich bei Bedarf in jeder Zelle unterscheiden kann. Verwenden Sie geschweifte Klammern { und } um die Elemente, um sie in einem Zellenarray zu speichern.

>> C = {A; s}
C = 
    [2x5 double]
    'MATLAB is fun'
>> whos C
  Name      Size            Bytes  Class    Attributes

  C         2x1               330  cell 

Standard-MATLAB-Objekte beliebiger Klassen können zusammen in einem Zellenfeld gespeichert werden. Beachten Sie, dass Zellen-Arrays mehr Speicher benötigen, um ihren Inhalt zu speichern.

Der Zugriff auf den Inhalt einer Zelle erfolgt mit geschweiften Klammern { und } .

>> C{1}
ans =
   1.0e+04 *
    0.0001   -0.0002    0.0003    0.0001    1.5625
    0.0003       Inf       Inf       NaN      -Inf

Beachten Sie, dass sich C(1) von C{1} . Während letztere den Inhalt der Zelle zurückgibt (und in unserem Beispiel die Klasse double hat), gibt erstere ein Zellenfeld zurück, das ein Unterfeld von C . In ähnlicher Weise würde D D(4:8,1:3) ein Unterfeld von D dessen Größe 5 mal 3 ist und dessen Klasse cell ist, wenn D ein 10 × 5-Zellenfeld wäre. Und die Syntax C{1:2} hat kein einzelnes zurückgegebenes Objekt, aber sie gibt zwei verschiedene Objekte zurück (ähnlich einer MATLAB-Funktion mit mehreren Rückgabewerten):

>> [x,y] = C{1:2}
x =
                         1                        -2                      3.14                       0.8                     15625
          3.14159265358979                       Inf                       Inf                       NaN                      -Inf
y =
MATLAB is fun

Skripte und Funktionen

MATLAB-Code kann in M-Dateien gespeichert und wieder verwendet werden. M-Dateien haben die Erweiterung .m die automatisch mit MATLAB verbunden wird. Eine M-Datei kann entweder ein Skript oder Funktionen enthalten.

Skripte

Skripts sind einfach Programmdateien, die eine Reihe von MATLAB-Befehlen in einer vordefinierten Reihenfolge ausführen.

Skripts akzeptieren keine Eingaben und auch keine Ausgaben. Funktional sind Skripte gleichbedeutend damit, Befehle direkt in das MATLAB-Befehlsfenster einzugeben und sie wiedergeben zu können.

Ein Beispiel für ein Skript:

length = 10;
width = 3;
area = length * width;

Dieses Skript definiert length , width und area im aktuellen Arbeitsbereich mit den Werten 10 , 3 und 30 .

Wie bereits erwähnt, entspricht das obige Skript dem direkten Eingeben derselben Befehle in das Befehlsfenster.

>> length = 10;
>> width = 3;
>> area = length * width;

Funktionen

Funktionen sind im Vergleich zu Skripten wesentlich flexibler und erweiterbarer. Im Gegensatz zu Skripts können Funktionen Eingaben annehmen und an den Aufrufer zurückgeben. Eine Funktion hat einen eigenen Arbeitsbereich. Dies bedeutet, dass die internen Operationen der Funktionen die Variablen des Aufrufers nicht ändern.

Alle Funktionen werden mit demselben Header-Format definiert:

function [output] = myFunctionName(input)

Das function beginnt mit jedem Funktionsheader. Die Liste der Ausgaben folgt. Die Liste der Ausgaben kann auch eine durch Kommas getrennte Liste der zurückzugebenden Variablen sein.

function [a, b, c] = myFunctionName(input)

Weiter ist der Name der Funktion, die für den Aufruf verwendet wird. Dies ist im Allgemeinen derselbe Name wie der Dateiname. Zum Beispiel würden wir diese Funktion als myFunctionName.m .

Dem Funktionsnamen folgt die Liste der Eingänge. Wie die Ausgänge kann dies auch eine durch Kommas getrennte Liste sein.

function [a, b, c] = myFunctionName(x, y, z)

Wir können das Beispielskript von vorher als wiederverwendbare Funktion wie die folgende umschreiben:

function [area] = calcRecArea(length, width)
   area = length * width;
end

Wir können Funktionen aus anderen Funktionen oder sogar aus Skriptdateien aufrufen. Hier ist ein Beispiel unserer obigen Funktion, die in einer Skriptdatei verwendet wird.

l = 100;
w = 20;
a = calcRecArea(l, w);

Wie zuvor erstellen wir im Arbeitsbereich l , w und a mit den Werten 100 , 20 bzw. 2000 .

Datentypen

Es gibt 16 grundlegende Datentypen oder Klassen in MATLAB. Jede dieser Klassen hat die Form einer Matrix oder eines Arrays. Mit Ausnahme der Funktions-Handles ist diese Matrix oder dieses Array mindestens 0 x 0 groß und kann zu einem n-dimensionalen Array beliebiger Größe heranwachsen. Ein Funktions-Handle ist immer skalar (1-by-1).

Ein wichtiger Moment in MATLAB ist, dass Sie standardmäßig keine Typdeklaration oder Dimensionsanweisungen verwenden müssen. Wenn Sie eine neue Variable definieren, erstellt MATLAB diese automatisch und weist entsprechenden Speicherplatz zu.

Beispiel:

a = 123;
b = [1 2 3];
c = '123';

>> whos
  Name      Size            Bytes  Class     Attributes

  a         1x1                 8  double              
  b         1x3                24  double              
  c         1x3                 6  char    

Wenn die Variable bereits vorhanden ist, ersetzt MATLAB die Originaldaten durch neue und weist bei Bedarf neuen Speicherplatz zu.

Grundlegende Datentypen

Grundlegende Datentypen sind: numerisch, logical , char , cell , struct , table und function_handle .

Numerische Datentypen :

  • Gleitkommazahlen ( Standard )

    MATLAB steht für Fließkommazahlen im Format mit doppelter oder einfacher Genauigkeit. Die Standardeinstellung ist doppelte Genauigkeit, aber Sie können mit einer einfachen Konvertierungsfunktion eine beliebige Zahl einfacher Genauigkeit erstellen:

    a = 1.23;
    b = single(a);
    
    >> whos
      Name      Size            Bytes  Class     Attributes
    
      a         1x1                 8  double              
      b         1x1                 4  single     
    
  • Ganzzahlen

    MATLAB verfügt über vier vorzeichenbehaftete und vier vorzeichenlose Ganzzahlenklassen. Mit signierten Typen können Sie sowohl mit negativen als auch mit positiven Ganzzahlen arbeiten, jedoch nicht so viele Zahlen wie die vorzeichenlosen Typen darstellen, da ein Bit für die Angabe eines positiven oder negativen Vorzeichens für die Zahl verwendet wird. Vorzeichenlose Typen geben Ihnen einen größeren Zahlenbereich, aber diese Zahlen können nur Null oder positiv sein.

    MATLAB unterstützt 1-, 2-, 4- und 8-Byte-Speicher für Ganzzahldaten. Sie können Speicher- und Ausführungszeit für Ihre Programme sparen, wenn Sie den kleinsten ganzzahligen Typ verwenden, der Ihre Daten enthält. Beispielsweise benötigen Sie keine 32-Bit-Ganzzahl, um den Wert 100 zu speichern.

    a = int32(100);
    b = int8(100);
    
    >> whos
      Name      Size            Bytes  Class    Attributes
    
      a         1x1                 4  int32              
      b         1x1                 1  int8               
    

    Um Daten als Ganzzahl zu speichern, müssen Sie den Double-Typ in den gewünschten Integer-Typ konvertieren. Wenn die Zahl, die in eine Ganzzahl umgewandelt wird, einen gebrochenen Teil hat, rundet MATLAB auf die nächste Ganzzahl. Wenn der gebrochene Teil genau 0.5 , wählt MATLAB aus den beiden gleich nahe beieinander liegenden Ganzzahlen diejenige, für die der Absolutwert größer ist.

    a  = int16(456);
    
  • char

    Zeichenarrays bieten die Speicherung von Textdaten in MATLAB. In Übereinstimmung mit der traditionellen Programmierterminologie wird ein Array (eine Folge) von Zeichen als eine Zeichenfolge definiert. In Retail-Releases von MATLAB gibt es keinen expliziten String-Typ.

  • logisch: logische Werte von 1 oder 0, repräsentieren wahr bzw. falsch. Verwendung für relationale Bedingungen und Array-Indexierung. Weil es nur WAHR oder FALSCH ist, hat es eine Größe von 1 Byte.

    a = logical(1);
    
  • Struktur. Ein Strukturarray ist ein Datentyp, der Variablen verschiedener Datentypen unter Verwendung von als Feldern bezeichneten Datencontainern gruppiert. Jedes Feld kann beliebige Datentypen enthalten. Zugriff auf Daten in einer Struktur mit Punktnotation des Formulars structName.fieldName.

    field1 = 'first';
    field2 = 'second';
    value1 = [1 2 3 4 5];
    value2 = 'sometext';
    s = struct(field1,value1,field2,value2);
    

    Um auf Wert1 zuzugreifen, ist jede der folgenden Syntax gleichwertig

    s.first or s.(field1) or s.('first')
    

    Wir können explizit auf ein Feld zugreifen, von dem wir wissen, dass es mit der ersten Methode existieren wird, oder entweder einen String übergeben oder einen String erstellen, um auf das Feld im zweiten Beispiel zuzugreifen. Das dritte Beispiel zeigt, dass die Punktparenthasen-Notation eine Zeichenfolge verwendet, die dieselbe ist, die in der Variablen Feld1 gespeichert ist.

  • Tabellenvariablen können unterschiedliche Größen und Datentypen haben, aber alle Variablen müssen dieselbe Zeilenanzahl haben.

    Age = [15 25 54]';
    Height = [176 190 165]';
    Name = {'Mike', 'Pete', 'Steeve'}';
    T = table(Name,Age, Height);
    
  • Zelle. Es ist sehr nützlich, den MATLAB-Datentyp: cell array ist ein Array, dessen Elemente unterschiedliche Datentypen und Größen haben können. Es ist ein sehr starkes Instrument, um Daten nach Ihren Wünschen zu bearbeiten.

    a = { [1 2 3], 56, 'art'};
    

    oder

    a = cell(3);
    
  • Funktionshandles speichert einen Zeiger auf eine Funktion (z. B. auf anonyme Funktion). Sie können eine Funktion an eine andere Funktion übergeben oder lokale Funktionen von außerhalb der Hauptfunktion aufrufen.

Es gibt viele Instrumente, die mit jedem Datentyp arbeiten können, und integrierte Konvertierungsfunktionen für Datentypen ( str2double , table2cell ).

Zusätzliche Datentypen

Es gibt mehrere zusätzliche Datentypen, die in bestimmten Fällen nützlich sind. Sie sind:

  • Datum und Uhrzeit: Arrays zur Darstellung von Datum, Uhrzeit und Dauer. datetime('now') gibt 21-Jul-2016 16:30:16 .

  • Kategoriale Arrays: Dies ist ein Datentyp zum Speichern von Daten mit Werten aus einer Reihe diskreter Kategorien. Nützlich zum Speichern nicht-numerischer Daten (Speicher wirksam). Kann in einer Tabelle verwendet werden, um Gruppen von Zeilen auszuwählen.

    a = categorical({'a' 'b' 'c'});
    
  • Kartencontainer sind eine Datenstruktur, die die einzigartige Fähigkeit hat, nicht nur durch beliebige numerische Skalarwerte, sondern auch durch den Zeichenvektor zu indizieren. Indizes in die Elemente einer Map werden als Schlüssel bezeichnet. Diese Schlüssel werden zusammen mit den ihnen zugeordneten Datenwerten in der Map gespeichert.

  • Zeitreihen sind Datenvektoren, die über die Zeit in der Reihenfolge oft in regelmäßigen Abständen abgetastet werden. Es ist hilfreich, die Daten in Verbindung mit Zeitschritten zu speichern, und es gibt viele nützliche Methoden, mit denen gearbeitet werden kann.

Anonyme Funktionen und Funktionshandles

Grundlagen

Anonyme Funktionen sind ein mächtiges Werkzeug der MATLAB-Sprache. Dies sind Funktionen, die lokal vorhanden sind, dh: im aktuellen Arbeitsbereich. Sie sind jedoch nicht im MATLAB-Pfad vorhanden, wie dies bei einer regulären Funktion der Fall wäre, z. B. in einer M-Datei. Deshalb werden sie anonym genannt, obwohl sie im Arbeitsbereich wie eine Variable benannt werden können.

Der @ Operator

Verwenden Sie den Operator @ , um anonyme Funktionen und Funktionshandles zu erstellen. Zum Beispiel, um ein Handle für die sin Funktion (Sinus) zu erstellen und es als f :

>> f = @sin
f = 
    @sin

Jetzt ist f ein Griff für die sin . So wie (in der Praxis) ein Türgriff eine Möglichkeit ist, eine Tür zu verwenden, ist ein Funktionsgriff eine Möglichkeit, eine Funktion zu verwenden. Um f , werden Argumente so übergeben, als wäre es die sin Funktion:

>> f(pi/2)
ans =
     1

f akzeptiert alle Eingabeargumente, die die sin Funktion akzeptiert. Wenn sin eine Funktion wäre, die null Eingabeargumente akzeptiert (was andere aber nicht tun, z. B. die peaks Funktion), würde f() verwendet, um sie ohne Eingabeargumente aufzurufen.

Anonyme benutzerdefinierte Funktionen

Anonyme Funktionen einer Variablen

Es ist offensichtlich nicht sinnvoll, ein Handle für eine vorhandene Funktion zu erstellen, wie zum Beispiel sin im obigen Beispiel. In diesem Beispiel ist es irgendwie überflüssig. Es ist jedoch nützlich, anonyme Funktionen zu erstellen, die benutzerdefinierte Aufgaben ausführen, für die andernfalls mehrmals wiederholt werden muss oder eine separate Funktion erstellt werden muss. Als Beispiel für eine benutzerdefinierte anonyme Funktion, die eine Variable als Eingabe akzeptiert, summieren Sie das Sinus- und Cosinus-Quadrat eines Signals:

>> f = @(x) sin(x)+cos(x).^2
f = 
    @(x)sin(x)+cos(x).^2

Jetzt akzeptiert f ein Eingabeargument mit dem Namen x . Dies wurde in Klammern (...) direkt nach dem @ -Operator angegeben. f jetzt eine anonyme Funktion von x : f(x) . Es wird verwendet, indem Sie einen Wert von x an f :

>> f(pi)
ans =
    1.0000

Ein Wertevektor oder eine Variable kann auch an f , sofern sie innerhalb von f gültig verwendet werden:

>> f(1:3) % pass a vector to f
ans =
    1.1334    1.0825    1.1212
>> n = 5:7;
>> f(n) % pass n to f
ans =
   -0.8785    0.6425    1.2254

Anonyme Funktionen von mehr als einer Variablen

In der gleichen Weise können anonyme Funktionen erstellt werden, um mehr als eine Variable zu akzeptieren. Ein Beispiel für eine anonyme Funktion, die drei Variablen akzeptiert:

>> f = @(x,y,z) x.^2 + y.^2 - z.^2
f = 
    @(x,y,z)x.^2+y.^2-z.^2
>> f(2,3,4)
ans =
    -3

Anonyme Funktionen parametrieren

Variablen im Arbeitsbereich können innerhalb der Definition anonymer Funktionen verwendet werden. Dies wird als Parametrieren bezeichnet. Um beispielsweise eine Konstante c = 2 in einer anonymen Funktion zu verwenden:

>> c = 2;
>> f = @(x) c*x
f = 
    @(x)c*x
>> f(3)
ans =
     6

f(3) verwendete die Variable c als Parameter, um sich mit dem angegebenen x zu multiplizieren. Wenn der Wert von c an diesem Punkt auf einen anderen Wert gesetzt wird, dann f(3) aufgerufen wird, ist das Ergebnis nicht unterschiedlich. Der Wert von c ist der Wert zum Zeitpunkt der Erstellung der anonymen Funktion:

>> c = 2;
>> f = @(x) c*x;
>> f(3)
ans =
     6
>> c = 3;
>> f(3)
ans =
     6

Eingabeargumente für eine anonyme Funktion beziehen sich nicht auf Arbeitsbereichsvariablen

Beachten Sie, dass die Verwendung des Namens von Variablen im Arbeitsbereich als eines der Eingabeargumente einer anonymen Funktion (dh, @(...) ) die Werte dieser Variablen nicht verwendet. Stattdessen werden sie im Rahmen der anonymen Funktion als verschiedene Variablen behandelt, d. H. Die anonyme Funktion hat einen privaten Arbeitsbereich, in dem die Eingabevariablen niemals auf die Variablen aus dem Hauptarbeitsbereich verweisen. Der Hauptarbeitsbereich und der Arbeitsbereich der anonymen Funktion kennen den Inhalt des anderen nicht. Ein Beispiel zur Veranschaulichung:

>> x = 3 % x in main workspace
x =
     3
>> f = @(x) x+1; % here x refers to a private x variable
>> f(5)
ans =
     6
>> x
x =
     3

Der Wert von x aus dem Hauptarbeitsbereich wird innerhalb von f nicht verwendet. Auch im Hauptarbeitsbereich wurde x berührt. Im Rahmen von f sind die Variablennamen zwischen den Klammern nach dem @ -Operator unabhängig von den Hauptvariablen des Arbeitsbereichs.

Anonyme Funktionen werden in Variablen gespeichert

Eine anonyme Funktion (oder genauer das auf eine anonyme Funktion gerichtete Funktionshandle) wird wie jeder andere Wert im aktuellen Arbeitsbereich gespeichert: In einer Variablen (wie oben beschrieben), in einem Zellenfeld ( {@(x)x.^2,@(x)x+1} ) oder sogar in einer Eigenschaft (wie h.ButtonDownFcn für interaktive Grafiken). Dies bedeutet, dass die anonyme Funktion wie jeder andere Wert behandelt werden kann. Wenn es in einer Variablen gespeichert wird, hat es einen Namen im aktuellen Arbeitsbereich und kann wie Variablen, die Zahlen enthalten, geändert und gelöscht werden.

Anders @sin : Ein Funktionshandle (ob in der @sin Form oder für eine anonyme Funktion) ist einfach ein Wert, der in einer Variablen gespeichert werden kann, genau wie eine numerische Matrix.

Erweiterte Verwendung

Übergeben von Funktionshandles an andere Funktionen

Da Funktionshandles wie Variablen behandelt werden, können sie an Funktionen übergeben werden, die Funktionshandles als Eingabeargumente akzeptieren.

Ein Beispiel: Eine Funktion wird in einer M-Datei erstellt, die ein Funktionshandle und eine Skalarzahl akzeptiert. Dann ruft sie das Funktionshandle auf, indem sie 3 übergibt, und fügt dann die Skalarzahl zum Ergebnis hinzu. Das Ergebnis wird zurückgegeben.

Inhalte von funHandleDemo.m :

function y = funHandleDemo(fun,x)
y = fun(3);
y = y + x;

Speichern Sie es irgendwo im Pfad, zB im aktuellen Ordner von MATLAB. Jetzt kann funHandleDemo beispielsweise wie folgt verwendet werden:

>> f = @(x) x^2; % an anonymous function
>> y = funHandleDemo(f,10) % pass f and a scalar to funHandleDemo
y =
    19

Das Handle einer anderen vorhandenen Funktion kann an funHandleDemo :

>> y = funHandleDemo(@sin,-5)
y =
   -4.8589

Beachten Sie, wie Sie mit @sin schnell auf die sin Funktion zugreifen konnten, ohne sie vorher mit f = @sin in einer Variablen zu f = @sin .

Verwendung von bsxfun , cellfun und ähnlichen Funktionen mit anonymen Funktionen

MATLAB verfügt über einige integrierte Funktionen, die anonyme Funktionen als Eingabe akzeptieren. Dies ist eine Möglichkeit, viele Berechnungen mit einer minimalen Anzahl von Codezeilen durchzuführen. Zum Beispiel bsxfun , das Element-für-Element-Binäroperationen durchführt, das heißt: Es wendet eine Funktion auf Element und Element auf zwei Vektoren oder Matrizen an. Normalerweise erfordert dies die Verwendung von for -loops, was aus Gründen der Geschwindigkeit häufig eine Vorbelegung erfordert. Mit bsxfun dieser Prozess beschleunigt. Das folgende Beispiel veranschaulicht dies anhand von tic und toc , zwei Funktionen, mit denen sich die toc Code bestimmen lässt. Er berechnet die Differenz jedes Matrixelements vom Matrixspaltenmittelwert.

A = rand(50); % 50-by-50 matrix of random values between 0 and 1

% method 1: slow and lots of lines of code
tic
meanA = mean(A); % mean of every matrix column: a row vector
% pre-allocate result for speed, remove this for even worse performance
result = zeros(size(A));
for j = 1:size(A,1)
    result(j,:) = A(j,:) - meanA;
end
toc
clear result % make sure method 2 creates its own result

% method 2: fast and only one line of code
tic
result = bsxfun(@minus,A,mean(A));
toc

Das Ausführen des obigen Beispiels führt zu zwei Ausgaben:

Elapsed time is 0.015153 seconds.
Elapsed time is 0.007884 seconds.

Diese Zeilen stammen von den toc Funktionen, die die verstrichene Zeit seit dem letzten Aufruf der tic Funktion tic .

Der Aufruf von bsxfun wendet die Funktion im ersten Eingabeargument auf die beiden anderen Eingabeargumente an. @minus ist ein langer Name für dieselbe Operation wie das Minuszeichen. Eine andere anonyme Funktion oder ein anderes Handle ( @ ) als eine andere Funktion könnte angegeben worden sein, solange A und mean(A) als Eingaben akzeptiert werden, um ein aussagekräftiges Ergebnis zu erzeugen.

Vor allem bei großen Datenmengen in großen Matrizen kann bsxfun die Dinge bsxfun beschleunigen. Es macht den Code auch sauberer, obwohl es für bsxfun , die MATLAB oder bsxfun nicht kennen, möglicherweise schwieriger zu interpretieren ist. (Beachten Sie, dass in MATLAB R2016a und später viele Operationen, die zuvor bsxfun verwendet haben, bsxfun nicht mehr benötigen; A-mean(A) arbeitet direkt und kann in manchen Fällen sogar noch schneller sein.)