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,
• ihren Code dokumentieren und debuggen.

1. Programmierrichtlinien

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.

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

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

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

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;

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

1. Optimieren Sie den Quelltext mit logischer Indizierung.

LogischeIndizes.m 

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

5. Vorallokation

Der Quelltext alloziert Speicher zur Laufzeit. Das ist ineffizient.

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

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

6. Eingaben prüfen

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

1. Nutzen Sie die Funktionen arguments und arguments, um das Rauschen zu entfernen.
2. Prüfen Sie mit arguments, dass der Übergabewert positiv ist.

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

8. FTF eines Signals

Gegeben:

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

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)

---

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