Modellierung und Simulation - Programmiertechniken

Autor:	Prof. Dr.-Ing. Schneider
Lektion:	12
Termin:	03.07.2026

Einleitung

MATLAB^® ist eines der wichtigsten Werkzeuge für die numerische Berechnung, Datenanalyse und Simulation in den Ingenieur- und Naturwissenschaften. Neben der korrekten Umsetzung eines Algorithmus spielt dabei auch die Qualität des Programmcodes eine entscheidende Rolle. Gut strukturierter, effizienter und wartbarer Code erleichtert nicht nur die Fehlersuche und Weiterentwicklung, sondern verbessert häufig auch die Ausführungsgeschwindigkeit. In diesem Kurs lernen die Studierenden grundlegende und fortgeschrittene Programmiertechniken in MATLAB^® kennen. Anhand praxisnaher Beispiele und Optimierungsaufgaben werden typische Programmierfehler identifiziert und bestehender Code schrittweise verbessert. Ziel ist es, moderne MATLAB^®-Programme zu entwickeln, die übersichtlich, leistungsfähig und leicht wiederverwendbar sind.

Lernziele

Nach dem Kurs können die Teilnehmenden:

• effizienten und gut lesbaren MATLAB^®-Code schreiben,
• Funktionen und Skripte sinnvoll einsetzen,
• Vektorisierung anstelle unnötiger Schleifen verwenden,
• Eingaben überprüfen,
• Code modular strukturieren,
• typische MATLAB^®-Funktionen zur Datenverarbeitung anwenden,
• Programme lesbar, wartbar und wiederverwendbar strukturieren,
• ihren Code dokumentieren und debuggen.

1. Programmierrichtlinien

Aufgaben

1. Analysieren Sie den nachfolgenden Quelltext unter Berücksichtigung der Programmierrichtlinien für MATLAB^®.
2. Optimieren Sie den Quelltext.

a=5;
b=3;
c=a*b;
disp(c)

Lesbarkeit.m 

nLaenge = 5; % Verwenden Sie lesbare Variablennamen.
nBreite = 3;

nFlaeche = nLaenge * nBreite; % Rücken Sie Quelltext zur besseren Lesbarkeit ein.

fprintf('Fläche = %.2d\n', nFlaeche); % Verwenden Sie hilfreiche Kommentare.

Erkenntnisse

• Kommentare und Lesbare Variablen machen Quelltext verständlicher.
• Das Einrücken verbessert die Lesbarkeit.

2. Skripte und Funktionen

Ein Skript

• arbeitet im Workspace.
• ist leicht zu schreiben.
• ist schlecht wiederverwendbar.

radius = 3;
A = pi*radius^2;

Die Vorteile eine Funktion sind

• Wiederverwendbarkeit
• eigener Workspace
• einfach testbar

Aufgabe
Wandeln Sie das Skript in die Funktion berechneKreis um und starten Sie diese mit der Funktion testBerechneKreis.

berechneKreis.m 

function [fA,fU] = berechneKreis(fRadius)
fA = pi*fRadius.^2;
fU = 2*pi*fRadius;
end

Erkenntnisse

• Wiederkehrende Berechnungen sollten in Funktionen ausgelagert werden.
• Funktionen fördern die Wiederverwendbarkeit und Wartbarkeit des Codes.
• Ein- und Ausgabeparameter strukturieren den Datenaustausch.

3. Vektorisierung

Der folgende Code berechnet $y=3x^2+2x-5$ mittels einer Schleife.

x=-10:0.1:10
for i=1:length(x)
    y(i)=3*x(i)^2+2*x(i)-5;
end

Aufgabe

1. Ersetzen Sie die Schleife durch eine vektorisierte Berechnung.
2. Messen Sie die Zeitersparnis mittels tic und toc.

Vektorisierung.m 

y=3.*x.^2+2.*x-5;

Erkenntnisse

• MATLAB^® ist für Vektor- und Matrixoperationen optimiert.
• Schleifen können häufig durch elementweise Operationen ersetzt werden.
• Vektorisierter Code ist meist kürzer, besser lesbar und schneller.
• Elementweise Operatoren (.*, ./, .^) sind sicher anzuwenden.

4. Logische Indizes

Der Quelltext sucht ineffizient alle Werte > 0.

x = randn(1000,1);
j=0;
for i=1:length(x)
    if x>0
j=j+1;
     xPos(j)=i;
    end
end

Aufgabe
Optimieren Sie den Quelltext mit logischer Indizierung.

LogischeIndizes.m 

positive = x>0;
xPos = x(positive);

Erkenntnis Die Verwendung logischer Indizes beschleunigt die Programmlaufzeit und macht den Quelltext lesbarer.

5. Vorallokation (Preallocation)

Eine Vorallokation (Preallocation) in MATLAB bedeutet, dass der benötigte Speicher für ein Array bereits vor einer Schleife reserviert wird. Dies ist eine der wichtigsten Maßnahmen zur Optimierung der Laufzeit von MATLAB-Programmen.

Wenn ein Array innerhalb einer Schleife schrittweise wächst, muss MATLAB bei jeder Vergrößerung:

• neuen Speicher reservieren,
• die bisherigen Daten in den neuen Speicher kopieren,
• den alten Speicher freigeben.

Dieser Vorgang kostet Zeit und wird bei großen Arrays sehr ineffizient.

for i=1:10000
    y(i)=i^2;
end

Aufgaben

1. Optimieren Sie den Quelltext mit Vorallokation.
2. Messen Sie die Zeitersparnis mittels tic und toc.

Vorallokation.m 

y=zeros(10000,1);
for i=1:10000
    y(i)=i^2;
end

Erkenntnisse
Vorallokation ist besonders sinnvoll, wenn

• die Größe des Arrays bereits bekannt ist,
• Werte innerhalb einer Schleife berechnet werden,
• große Datenmengen verarbeitet werden,
• Echtzeitanwendungen oder effiziente Algorithmen entwickelt werden.
• Ein Array sollte möglichst nie innerhalb einer Schleife wachsen. Reserviere den benötigten Speicher vorher mit zeros, ones, nan, cell oder einer passenden Vorallokationsfunktion.

6. Eingaben prüfen

Aufgaben

1. Schreiben Sie eine Funktion Wurzel, die die Wurzel berechnet.
2. Prüfen Sie mit arguments, dass der Übergabewert positiv ist.

pruefeEingaben.m 

function y = Wurzel(x)

arguments
    x (1,1) double {mustBePositive}
end

y = sqrt(x);

end

7. Rauschen entfernen

x = x + 0.3*randn(size(x));
end

Aufgabe
Nutzen Sie die Funktionen movmean und lowpass(), um das Rauschen zu entfernen.

entferneRauschen.m 

clear;clc;close all

%% Signal
fs = 1000;
t = 0:1/fs:2;
signal = sin(2*pi*20*t);

%% Rauschen
noiseSignal = signal + 0.3*randn(size(signal));

%% Moving Average
filtered = movmean(noiseSignal,15);

%% Darstellung
figure

subplot(3,1,1)
plot(t,signal)
title('Original')
grid on

subplot(3,1,2)
plot(t,noiseSignal)
title('Mit Rauschen')
grid on

subplot(3,1,3)
plot(t,filtered)
title('Gefiltert')
grid on

Erkenntnisse

• Filter reduzieren unerwünschte Signalanteile wie Rauschen.
• Unterschiedliche Filter beeinflussen das Signal unterschiedlich stark.
• Die Wahl der Filterparameter ist ein Kompromiss zwischen Glättung und Signalerhalt.
• Messergebnisse sollten vor und nach der Filterung verglichen werden.

8. FTF eines Signals

Gegeben:

signal = randn(5000,1);
signal = signal + sin(2*pi*40*(0:4999)'/1000);

Aufgaben
Erstellen Sie ein Programm mit folgenden Funktionen:

• main.m
• generateSignal()
• filterSignal()
• calculateFFT()
• plotResults()

main.m 

clear
clc
close all

fs = 1000;

signal = generateSignal(fs);

filtered = filterSignal(signal);

[f,A] = calculateFFT(filtered,fs);

plotResults(signal,filtered,f,A,fs);

generateSignal.m 

function signal = generateSignal(fs)

t = 0:1/fs:5;

signal = sin(2*pi*40*t) ...
       + 0.4*sin(2*pi*150*t);

signal = signal + 0.3*randn(size(signal));

end

filterSignal.m 

function y = filterSignal(x)

y = movmean(x,15);

end

calculateFFT.m 

function [f,A] = calculateFFT(signal,fs)

N = length(signal);

Y = fft(signal);

P2 = abs(Y)/N;

P1 = P2(1:N/2+1);

P1(2:end-1)=2*P1(2:end-1);

f = fs*(0:N/2)/N;

A = P1;

end

plotResults.m 

function plotResults(signal,filtered,f,A,fs)

t = (0:length(signal)-1)/fs;

figure

subplot(3,1,1)
plot(t,signal)
title('Originalsignal')
grid on

subplot(3,1,2)
plot(t,filtered)
title('Gefiltertes Signal')
grid on

subplot(3,1,3)
plot(f,A)

xlim([0 250])

title('FFT')
xlabel('Frequenz [Hz]')
ylabel('Amplitude')
grid on

Bestimmen Sie folgende Werte und stellen Sie diese dar

• Signalenergie berechnen
• Spitzenwert bestimmen
• Ereignisse oberhalb eines Schwellwerts markieren
• dominante Frequenz bestimmen
• Ergebnisse grafisch darstellen

Signalparameter.m 

%%Signalenergie
energy = sum(filtered.^2);
fprintf("Signalenergie = %.2f\n",energy)

%% Spitzenwert
peak = max(abs(filtered));
fprintf("Maximalwert = %.2f\n",peak)

%% Ereigniserkennung
threshold = 1.0;
eventIdx = abs(filtered) > threshold;

figure
plot(filtered)
hold on
plot(find(eventIdx),filtered(eventIdx),'ro')
grid on
title('Erkannte Ereignisse')

%% Dominante Frequenz bestimmen
[peakAmplitude,index] = max(A);
dominantFrequency = f(index);
fprintf("Dominante Frequenz = %.1f Hz\n",dominantFrequency)

Erkenntnisse

• MATLAB^® stellt leistungsfähige Funktionen für die Frequenzanalyse bereit.
• Die FFT ermöglicht die Untersuchung der Frequenzanteile eines Signals.
• Das Amplitudenspektrum muss korrekt skaliert werden.
• Zeit- und Frequenzbereich ergänzen sich bei der Signalanalyse.

9. Quelltext optimieren

Gegeben ist folgender Quelltext:

x = rand(1,100000);
for i = 1:length(x)
    if x(i) < 0.5
        y(i) = 0;
    else
        y(i) = sqrt(x(i));
    end
end

Aufgabe
Optimieren Sie den Quelltext.

Optimierung.m 

x = rand(1,100000);
y = zeros(size(x));
idx = x >= 0.5;
y(idx) = sqrt(x(idx));

Erkenntnis
Die Optimierung eines Quelltextes erhöht die Lesbarkeit, Wiederverwendbarkeit und Laufzeit.

10. Anonyme Funktionen (@-Operator)

Gegeben ist folgender Quelltext:

clear
clc

x = 0:0.01:10;

for i = 1:length(x)
    y(i) = sin(x(i)) + cos(x(i));
end

plot(x,y)
grid on

Aufgaben

1. Optimieren Sie den Code.
2. Verwenden Sie den @-Operator.
3. Definieren Sie eine anonyme Funktion.
4. Der Code soll auch für andere Eingangsvektoren funktionieren.

AnonymeFunktionen.m 

clear
clc

f = @(x) sin(x) + cos(x);

x = 0:0.01:10;

y = f(x);

plot(x,y)
grid on

Erkenntnisse

• Der @-Operator erzeugt Function Handles.
• Anonyme Funktionen eignen sich für kurze mathematische Ausdrücke.
• Function Handles erhöhen die Wiederverwendbarkeit von Berechnungen.
• Änderungen an einer Funktion wirken sich automatisch auf alle Aufrufe aus.

11. Function Handle mehrfach verwenden

Gegeben ist folgender Quelltext:

x = linspace(0,2*pi,500);

y1 = sin(x);
y2 = sin(2*x);
y3 = sin(3*x);

plot(x,y1)
hold on
plot(x,y2)
plot(x,y3)
grid on

1. Verwenden Sie einen Function Handle.
2. Berechnen Sie beliebige Harmonische.

FunctionHandle.m 

wave = @(f,x) sin(f*x);

x = linspace(0,2*pi,500);

plot(x,wave(1,x))
hold on
plot(x,wave(2,x))
plot(x,wave(3,x))
grid on

Erkenntnisse

• Allgemeine Funktionen sind flexibler als mehrfach kopierter Code.
• Parameter ermöglichen die Wiederverwendung derselben Funktion.
• Function Handles erleichtern die Entwicklung generischer Programme.
• Redundanter Code sollte vermieden werden.

12. Mehrfaches Kopieren vermeiden

Gegeben ist folgender Quelltext:

figure

subplot(2,2,1)
plot(x1,y1)

subplot(2,2,2)
plot(x2,y2)

subplot(2,2,3)
plot(x3,y3)

subplot(2,2,4)
plot(x4,y4)

Aufgabe

1. Optimieren Sie den Code mit einer Schleife.

OptimierungMitSchleife.m 

X = {x1,x2,x3,x4};
Y = {y1,y2,y3,y4};

figure

for k = 1:4

    subplot(2,2,k)

    plot(X{k},Y{k})

    grid on

end

Erkenntnisse

• Wiederkehrende Programmteile sollten automatisiert werden.
• Schleifen können redundanten Quelltext erheblich reduzieren.
• Zellarrays eignen sich zum Verwalten mehrerer Datensätze.
• Kürzerer Code ist meist leichter zu warten.

13. Objektorientierung

Gegeben ist folgender Quelltext:

radius = 5;

A = pi*radius^2;
U = 2*pi*radius;

fprintf("Fläche %.2f\n",A)
fprintf("Umfang %.2f\n",U)

Aufgabe
Erstellen Sie eine Klasse

Circle

mit

• Radius
• Fläche
• Umfang

Circle.m 

classdef Circle

    properties
        Radius
    end

    methods

        function obj = Circle(r)

            obj.Radius = r;

        end

        function A = area(obj)

            A = pi*obj.Radius^2;

        end

        function U = circumference(obj)

            U = 2*pi*obj.Radius;

        end

    end

end

startCircle.m 

c = Circle(5);
c.area()
c.circumference()

Erkenntnisse

• Objekte fassen Daten und Funktionen logisch zusammen.
• Klassen modellieren reale oder technische Objekte.
• Eigenschaften (properties) speichern den Zustand eines Objekts.
• Methoden (methods) beschreiben das Verhalten des Objekts.
• OOP verbessert die Struktur größerer Softwareprojekte.

14. Modultests

Gegeben ist folgender Quelltext:

function y = add(a,b)
y = a+b;
end

Es existieren keine Tests.

Aufgabe
Schreiben Sie eine MATLAB-Testklasse.

TestAdd.m 

classdef TestAdd < matlab.unittest.TestCase

    methods(Test)

        function positiveNumbers(testCase)

            act = add(2,3);

            exp = 5;

            testCase.verifyEqual(act,exp)

        end

        function negativeNumbers(testCase)

            act = add(-1,-2);

            exp = -3;

            testCase.verifyEqual(act,exp)

        end

        function zeros(testCase)

            testCase.verifyEqual(add(0,0),0)

        end

    end

end

Ausführung:

runtests

Erkenntnisse

• Software sollte systematisch getestet werden.
• Modultests (Unit-Tests) prüfen Funktionen automatisch auf korrektes Verhalten.
• Änderungen am Code können schnell auf Fehler überprüft werden.
• Automatisierte Tests erhöhen die Zuverlässigkeit von Software.

15. Grafische Benutzeroberfläche

Gegeben ist folgender Quelltext:

x = 0:0.01:10;
plot(x,sin(x))

Aufgabe
Erweitern Sie das Programm um einen Schieberegler, mit dem die Frequenz des Sinussignals verändert werden kann.

Nützliche MATLAB-Befehle: uifigure, uislider, Callback-Funktionen, Function Handles (@) Schreiben Sie eine MATLAB-Testklasse.

GrafischeBenutzeroberflaeche.m 

fig = uifigure;
ax = uiaxes(fig);
s = uislider(fig);
s.ValueChangedFcn = @(src,event) plot(ax,0:0.01:10,sin(src.Value*(0:0.01:10)));

Erkenntnisse

• Interaktive Programme verbessern die Bedienbarkeit.
• Callbacks reagieren auf Benutzereingaben.
• Function Handles verbinden GUI-Elemente mit Programmfunktionen.
• MATLAB eignet sich auch zur Entwicklung einfacher grafischer Anwendungen.

16. Profiling

Gegeben ist folgender Quelltext:

for i=1:10000
    A = rand(100);
    B = inv(A);
end

Aufgabe
Analysieren Sie den Code mit dem MATLAB-Profiler und optimieren Sie ihn.

Nützliche MATLAB-Befehle: profile on, profile viewer Schreiben Sie eine MATLAB-Testklasse.

Profiling.m 

profile on
for i=1:10000
    A = rand(100);
    B = A\eye(100);
end
profile viewer

Erkenntnisse

• Optimierungen sollten gezielt an den langsamsten Programmteilen erfolgen.
• Der MATLAB-Profiler unterstützt die Analyse der Laufzeit.
• Nicht jede Optimierung bringt einen messbaren Vorteil.
• Numerisch geeignete Algorithmen sind oft gleichzeitig schneller.

17. Struktur statt vieler Variablen

Gegeben ist folgender Quelltext:

xMean = mean(x);
xStd = std(x);
xMax = max(x);
xMin = min(x);

Aufgabe
Fassen Sie alle Ergebnisse in einer Struktur zusammen.

Struktur.m 

stats.mean = mean(x);
stats.std = std(x);
stats.max = max(x);
stats.min = min(x);

disp(stats)

Erkenntnisse

• Zusammengehörige Informationen sollten gemeinsam gespeichert werden.
• Strukturen verbessern die Übersichtlichkeit komplexer Daten.
• Ergebnisse können komfortabel zwischen Funktionen ausgetauscht werden.
• Die Anzahl einzelner Variablen wird reduziert.

18. Tabellen statt Schleifen

Gegeben ist folgender Quelltext:

for i=1:length(name)
  fprintf("%s %.1f\n",name{i},punkte(i))
end

Aufgabe
Nutzen Sie table.

Tabellen.m 

T = table(name',punkte');
disp(T)

Erkenntnisse

• Verwenden Sie table, wenn Daten aus mehreren zusammengehörigen Variablen bestehen und jede Zeile eine Beobachtung bzw. Messung beschreibt.
• Tabellen machen den Quelltext lesbarer und erleichtern die Datenanalyse.

19. length oder numel

Gegeben ist folgender Quelltext:

A = rand(5,8);
summe = 0;
for i = 1:length(A)
    summe = summe + A(i);
end
disp(summe)

Aufgabe
Optimieren Sie den Code. Achten Sie darauf, dass die Lösung auch für beliebig dimensionierte Matrizen korrekt funktioniert.

vermeideSchleifen.m 

A = rand(5,8);
summe = sum(A,'all');
disp(summe)

Erkenntnise

• length() liefert nur die größte Dimension eines Arrays und ist daher für Matrizen oft ungeeignet.
• Für alle Elemente eines Arrays eignen sich Funktionen wie numel() oder direkt MATLAB-Funktionen (sum, mean, max).
• Bevorzugen Sie eingebaute MATLAB^®-Funktionen gegenüber selbst geschriebenen Schleifen.

20. find vermeiden

Gegeben ist folgender Quelltext:

x = randn(1000,1);
idx = find(x > 2);
y = x(idx);

Aufgabe
Optimieren Sie den Code.

vermeideFind.m 

x = randn(1000,1);
y = x(x>2);

Erkenntnisse

• find() wird häufig unnötig eingesetzt.
• Logische Indizes sind kompakter, besser lesbar und in vielen Fällen effizienter.
• MATLAB^® unterstützt logische Array-Operationen direkt.

21. Matrixmultiplikation

Gegeben ist folgender Quelltext:

A = rand(500);
B = rand(500);
for i=1:500
    for j=1:500
        C(i,j)=0;
        for k=1:500
            C(i,j)=C(i,j)+A(i,k)*B(k,j);
        end
    end
end

Aufgabe
Nutzen Sie MATLAB effizient.

Matrixmultiplikation.m 

C = A*B;

Erkenntnis
Die eingebaute Matrixmultiplikation ist hochoptimiert.

22. Schleife durch arrayfun

Gegeben ist folgender Quelltext:

x = 1:100;
for i=1:length(x)
    y(i)=factorial(x(i));
end

Aufgabe
Optimieren Sie den Quelltext.

optimiereSchleife.m 

x = 1:100;
y = arrayfun(@factorial,x);

Erkenntnisse

• arrayfun() ermöglicht die elementweise Anwendung von Funktionen auf Arrays.
• Der Code wird kompakter und oft besser lesbar.
• Nicht jede Schleife muss durch arrayfun() ersetzt werden; häufig sind vektorisierte Ausdrücke noch effizienter.

23. switch statt viele if

Gegeben ist folgender Quelltext:

mode = 2;
if mode==1
    disp("Start")
elseif mode==2
    disp("Stop")
elseif mode==3
    disp("Pause")
elseif mode==4
    disp("Reset")
end

Aufgabe
Verbessern Sie die Lesbarkeit.

nutzeSwitchCase.m 

switch mode
    case 1
        disp("Start")
    case 2
        disp("Stop")
    case 3
        disp("Pause")
    case 4
        disp("Reset")
end

Erkenntnisse

• Mehrere if-elseif-Abfragen mit festen Zuständen lassen sich übersichtlicher mit switch formulieren.
• switch verbessert die Lesbarkeit und reduziert die Fehleranfälligkeit.
• Die Wahl der passenden Kontrollstruktur erhöht die Verständlichkeit des Programms.

23. Magische Zahlen

Gegeben ist folgender Quelltext:

signal = randn(1000,1);
filtered = movmean(signal,17);
plot(filtered)
ylim([-3 3])

Aufgabe
Verbessern Sie die Wartbarkeit.

nutzeSwitchCase.m 

windowSize = 17;
yLimit = 3;
signal = randn(1000,1);
filtered = movmean(signal,windowSize);
plot(filtered)
ylim([-yLimit yLimit])

Erkenntnisse

• Zahlenwerte im Quelltext sollten möglichst vermieden werden.
• Konstanten sollten über sprechende Variablennamen definiert werden.
• Änderungen an Parametern werden dadurch einfacher und sicherer.

---

→ MATLAB^® Befehlsübersicht
→ zurück zum Hauptartikel: BSE Modellierung und Simulation - SoSe26