MATLAB in 10 Minuten lernen
MATLAB (Matrix Laboratory) ist eine Hochsprache und Entwicklungsumgebung für numerische Berechnungen, Algorithmusentwicklung und Datenvisualisierung. MATLAB, ursprünglich in den späten 1970er Jahren entwickelt, ist zu einem unverzichtbaren Werkzeug in den Bereichen Ingenieurwesen, Naturwissenschaften und Mathematik geworden.
In diesem Tutorial lernst du die Grundlagen von MATLAB und kannst direkt mit dieser leistungsstarken计算环境 loslegen.
1. Dein erstes MATLAB-Programm
Erstelle eine Skriptdatei namens hello.m oder gib die Befehle direkt im MATLAB-Befehlsfenster ein.
disp('Hello, World!')
Oder du verwendest die fprintf-Funktion:
fprintf('Hello, World!\n')
Die Ausgabe sieht so aus:
Hello, World!
Die Funktion disp() zeigt den Inhalt direkt an, während fprintf() mehr Formatierungskontrolle bietet, ähnlich wie Cs printf.
2. Grundlegende Syntax
MATLAB hat seine eigenen Syntaxregeln, die sich von den meisten universell einsetzbaren Programmiersprachen unterscheiden. Das Verständnis dieser Grundlagen ist wichtig, um sauberen und wartbaren Code zu schreiben.
2.1 Kommentare
Einzeilige Kommentare beginnen mit dem Prozentzeichen %:
% Dies ist ein Kommentar
x = 10; % Weist x den Wert 10 zu
Mehrzeilige Kommentare verwenden %{ und %}:
%{
Dies ist ein mehrzeiliger Kommentar.
Er kann sich über mehrere Zeilen erstrecken.
%}
2.2 Semikolons
Das Semikolon ; unterdrückt die Ausgabe. Ohne Semikolon zeigt MATLAB das Ergebnis an:
x = 5 % Zeigt: x = 5
y = 10; % Keine Ausgabe, aber y wird zugewiesen
2.3 Groß- und Kleinschreibung
MATLAB unterscheidet zwischen Groß- und Kleinschreibung. A und a sind unterschiedliche Variablen:
A = 5;
a = 10;
disp(A) % Ausgabe: 5
disp(a) % Ausgabe: 10
2.4 Variablennamen
Variablennamen müssen mit einem Buchstaben beginnen, gefolgt von Buchstaben, Zahlen oder Unterstrichen:
gueltiger_name = 1;
ein_weiterer_gueltiger_name_123 = 2;
% 123ungueltig = 3; % Fehler: kann nicht mit einer Zahl beginnen
2.5 Grundlegende Operationen
MATLAB glänzt besonders bei Matrixoperationen. Eine Matrix zu erstellen ist ganz einfach:
A = [1 2 3; 4 5 6; 7 8 9] % 3x3 Matrix
Ausgabe:
A =
1 2 3
4 5 6
7 8 9
3. Variablen und Datentypen
MATLAB verwendet dynamische Typisierung. Variablen werden bei der Zuweisung erstellt und ihr Typ wird durch den zugewiesenen Wert bestimmt.
3.1 Numerische Typen
MATLAB speichert standardmäßig alle Zahlen als Gleitkommazahlen mit doppelter Genauigkeit:
% Ganzzahl
int_num = 42;
% Gleitkommazahl
float_num = 3.14159;
% Wissenschaftliche Notation
sci_num = 2.5e-3; % 0.0025
3.2 Strings
String-Variablen verwenden einfache Anführungszeichen:
str = 'Hello, MATLAB';
str2 = "Hello, MATLAB"; % String-Array (R2016b+)
String-Verkettung:
str1 = 'Hello';
str2 = 'World';
combined = [str1 ', ' str2]; % 'Hello, World'
3.3 Logische Werte (Boolean)
Logische Werte sind true oder false:
flag = true;
result = false;
% Logische Operationen
a = true;
b = false;
and_result = a && b; % false
or_result = a || b; % true
not_result = ~a; % false
3.4 Zeichenarrays vs. Strings
MATLAB hat sowohl Zeichenarrays als auch String-Objekte:
% Zeichenarray (ältere Methode)
char_arr = 'Hello';
% String-Objekt (moderne Methode, R2016b+)
str_obj = "Hello";
% Mit String-Objekten lässt sich leichter arbeiten
name = "Alice";
greeting = "Hello, " + name; % Funktioniert ganz natürlich
4. Datenstrukturen
MATLAB bietet verschiedene Datenstrukturen für unterschiedliche Anwendungsfälle.
4.1 Vektoren
Ein Vektor ist ein eindimensionales Array:
% Zeilenvektor
row_vec = [1 2 3 4 5];
% Spaltenvektor
col_vec = [1; 2; 3; 4; 5];
% Mit dem Doppelpunkt-Operator
range_vec = 1:5; % [1 2 3 4 5]
step_vec = 0:2:10; % [0 2 4 6 8 10]
% linspace für gleichmäßig verteilte Werte
lin_vec = linspace(0, 10, 5); % [0 2.5 5 7.5 10]
4.2 Matrizen
Matrizen bilden das Fundament von MATLAB:
% Direkte Matrizerstellung
A = [1 2 3; 4 5 6; 7 8 9];
% Auf Elemente zugreifen
element = A(2, 3); % Gibt 6 zurück (Zeile 2, Spalte 3)
% Matrixoperationen
B = A'; % Transponierte
C = A * B; % Matrixmultiplikation
D = A .* B; % Elementweise Multiplikation
4.3 Cell-Arrays
Cell-Arrays können verschiedene Datentypen speichern:
% Cell-Array erstellen
cell_arr = {1, 'hello', [1 2 3], true};
% Auf Zellinhalt mit geschweiften Klammern zugreifen
data = cell_arr{2}; % Gibt 'hello' zurück
% Mit Klammern auf Zelle zugreifen
sub_cell = cell_arr(1:2); % Gibt {1, 'hello'} zurück
4.4 Strukturen
Strukturen funktionieren wie Dictionaries mit benannten Feldern:
% Struktur erstellen
student.name = 'John';
student.age = 20;
student.major = 'Engineering';
% Auf Felder zugreifen
disp(student.name); % Ausgabe: John
% Array von Strukturen
students(1).name = 'Alice';
students(1).age = 21;
students(2).name = 'Bob';
students(2).age = 22;
4.5 Tabellen
Tabellen eignen sich gut für tabellarische Daten:
% Tabelle erstellen
Age = [25; 30; 35];
Name = {'Alice'; 'Bob'; 'Charlie'};
Salary = [50000; 60000; 70000];
T = table(Name, Age, Salary);
% Auf Daten zugreifen
disp(T.Age);
disp(T.Name{1});
5. Operatoren
MATLAB bietet verschiedene Operatoren für arithmetische, Vergleichs- und logische Operationen.
5.1 Arithmetische Operatoren
a = 10;
b = 3;
sum = a + b; % 13
diff = a - b; % 7
prod = a * b; % 30
quot = a / b; % 3.3333
int_div = floor(a/b); % 3
mod = mod(a, b); % 1 (Rest)
pow = a ^ b; % 1000
5.2 Elementweise Operatoren
Elementweise Operatoren arbeiten mit entsprechenden Elementen:
A = [1 2 3];
B = [4 5 6];
C = A .* B; % Elementweise: [4 10 18]
D = A.^2; % Elementweise quadriert: [1 4 9]
5.3 Vergleichsoperatoren
x = 5;
y = 10;
eq = (x == y); % false
neq = (x ~= y); % true
gt = (x > y); % false
lt = (x < y); % true
ge = (x >= y); % false
le = (x <= y); % true
5.4 Logische Operatoren
a = true;
b = false;
and_op = a & b; % false (elementweises UND)
or_op = a | b; % true (elementweises ODER)
not_op = ~a; % false
and_short = a && b; % false (Kurzschluss-UND)
or_short = a || b; % true (Kurzschluss-ODER)
6. Kontrollstrukturen
MATLAB bietet die üblichen Kontrollstrukturen, aber mit einer anderen Syntax als Sprachen wie Python.
6.1 if-elseif-else
score = 85;
if score >= 90
grade = 'A';
elseif score >= 80
grade = 'B';
elseif score >= 70
grade = 'C';
else
grade = 'F';
end
disp(grade) % Ausgabe: B
6.2 switch
Die switch-Anweisung vergleicht einen einzelnen Ausdruck mit mehreren Fällen:
day = 'Monday';
switch day
case {'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday'}
disp('Weekday');
case {'Saturday', 'Sunday'}
disp('Weekend');
otherwise
disp('Invalid day');
end
6.3 for-Schleifen
Die for-Schleife iteriert über einen Bereich oder ein Array:
% Über einen Bereich iterieren
for i = 1:5
disp(i);
end
% Über ein Array iterieren
fruits = {'apple', 'banana', 'orange'};
for fruit = fruits
disp(fruit{1});
end
% Verschachtelte Schleifen für Matrixoperationen
A = [1 2; 3 4];
B = zeros(2, 2);
for i = 1:2
for j = 1:2
B(i, j) = A(i, j) * 2;
end
end
6.4 while-Schleifen
count = 0;
while count < 5
disp(count);
count = count + 1;
end
6.5 Schleifensteuerung
Die break-Anweisung beendet die Schleife und continue springt zur nächsten Iteration:
% break verwenden
for i = 1:10
if i == 5
break;
end
disp(i);
end
% Ausgabe: 1 2 3 4
% continue verwenden
for i = 1:5
if mod(i, 2) == 0
continue; % Gerade Zahlen überspringen
end
disp(i);
end
% Ausgabe: 1 3 5
7. Ein- und Ausgabe
7.1 Benutzereingabe
Verwende die Funktion input(), um Benutzereingaben zu erhalten:
% Numerische Eingabe erhalten
num = input('Enter a number: ');
% String-Eingabe erhalten
name = input('Enter your name: ', 's');
% Ausdruckseingabe (wertet die Eingabe aus)
expr = input('Enter an expression: ');
7.2 Ausgabe anzeigen
Mehrere Funktionen zeigen Ausgaben an:
% disp - einfache Anzeige
disp('Hello');
disp([1 2 3]);
% fprintf - formatierte Ausgabe
name = 'Alice';
age = 25;
fprintf('Name: %s, Age: %d\n', name, age);
% sprintf - formatierten String erstellen
str = sprintf('Value: %.2f', 3.14159);
disp(str);
7.3 Formatspezifizierer
Häufige Formatspezifizierer in MATLAB:
% %s - String
% %d - Ganzzahl
% %f - Gleitkommazahl
% %.2f - Gleitkommazahl mit 2 Dezimalstellen
% %e - Wissenschaftliche Notation
fprintf('%d %.2f %e\n', 42, 3.14159, 1000)
% Ausgabe: 42 3.14 1.000000e+03
8. Funktionen
Funktionen in MATLAB werden normalerweise in separaten Dateien definiert, aber anonyme Funktionen bieten die Möglichkeit, Funktionen inline zu erstellen.
8.1 Anonyme Funktionen
Anonyme Funktionen erstellen einfache Funktionen ohne separate Dateien:
% Einzelner Input
square = @(x) x^2;
disp(square(5)); % Ausgabe: 25
% Mehrere Inputs
add = @(x, y) x + y;
disp(add(3, 4)); % Ausgabe: 7
% Mehrere Ausdrücke
hypot = @(x, y) sqrt(x^2 + y^2);
disp(hypot(3, 4)); % Ausgabe: 5
8.2 Funktionsdateien
Erstelle eine Datei namens myfunc.m:
function y = myfunc(x)
y = x^2 + 1;
end
Die Funktion aufrufen:
result = myfunc(5); % Ausgabe: 26
8.3 Funktionen mit mehreren Ausgaben
function [sum, prod] = calc(x, y)
sum = x + y;
prod = x * y;
end
Mit mehreren Ausgaben aufrufen:
[s, p] = calc(3, 4);
disp(s); % 7
disp(p); % 12
8.4 Variable Argumente
Verwende varargin und varargout für variable Argumente:
function result = sum_all(varargin)
result = 0;
for i = 1:length(varargin)
result = result + varargin{i};
end
end
% Mit beliebig vielen Argumenten aufrufen
total = sum_all(1, 2, 3, 4, 5); % Ausgabe: 15
9. Skriptdateien
Skripte sind .m-Dateien, die eine Sequenz von MATLAB-Befehlen enthalten. Sie arbeiten mit Daten im Workspace:
% Speichern als myscript.m
% Statistiken für einen Datensatz berechnen
data = [1 2 3 4 5 6 7 8 9 10];
mean_val = mean(data);
std_val = std(data);
max_val = max(data);
min_val = min(data);
fprintf('Mean: %.2f\n', mean_val);
fprintf('Std: %.2f\n', std_val);
fprintf('Max: %d\n', max_val);
fprintf('Min: %d\n', min_val);
10. Fehlerbehandlung
Verwende try-catch für die Fehlerbehandlung:
try
result = risky_operation();
catch ME
fprintf('Error: %s\n', ME.message);
% Den Fehler behandeln
result = 0;
end
error() verwenden, um Fehler auszulösen:
function result = divide(a, b)
if b == 0
error('Division by zero is not allowed');
end
result = a / b;
end
11. Dateioperationen
11.1 Daten speichern und laden
% Variablen in Datei speichern
x = [1 2 3];
y = 'hello';
save('data.mat', 'x', 'y');
% Variablen aus Datei laden
load('data.mat');
% In Textdatei speichern
writematrix(x, 'data.txt');
% Aus Textdatei lesen
data = readmatrix('data.txt');
11.2 Textdateioperationen
% In Textdatei schreiben
fid = fopen('output.txt', 'w');
fprintf(fid, 'Line 1\n');
fprintf(fid, 'Line 2\n');
fclose(fid);
% Aus Textdatei lesen
fid = fopen('output.txt', 'r');
while ~feof(fid)
line = fgetl(fid);
if ischar(line)
disp(line);
end
end
fclose(fid);
textscan für strukturiertes Lesen verwenden:
fid = fopen('data.txt', 'r');
format = '%s %d %f';
C = textscan(fid, format);
fclose(fid);
name = C{1};
age = C{2};
score = C{3};
12. Plotten
MATLABs Plotfunktionen gehören zu seinen stärksten Features.
12.1 Grundlegendes 2D-Plotten
x = 0:0.1:2*pi;
y = sin(x);
plot(x, y);
xlabel('x');
ylabel('sin(x)');
title('Sine Wave');
grid on;
12.2 Mehrere Plots
x = 0:0.1:2*pi;
% Subplots
subplot(2, 1, 1);
plot(x, sin(x));
title('Sine');
subplot(2, 1, 2);
plot(x, cos(x));
title('Cosine');
12.3 Plot-Anpassung
x = 0:0.1:10;
y1 = x;
y2 = x.^2;
plot(x, y1, 'b-', 'LineWidth', 2); % Blaue durchgezogene Linie
hold on;
plot(x, y2, 'r--', 'LineWidth', 2); % Rote gestrichelte Linie
hold off;
xlabel('X');
ylabel('Y');
legend('Linear', 'Quadratic');
title('Linear vs Quadratic');
grid on;
12.4 Andere Plottypen
% Balkendiagramm
bar([1 2 3 4], [10 20 15 25]);
% Histogramm
data = randn(1000, 1);
histogram(data, 30);
% Streudiagramm
x = rand(100, 1);
y = 2*x + randn(100, 1)*0.1;
scatter(x, y);