EMZETT.
Login

Emzett Wiki

MATLAB: Projekte: Simulation und Algorithmen

Properties1
tagsprogrammiersprachen, matlab

5 Min. Lesezeit

Kurz: Nullstellen mit der Newton-Iteration x ← x − f(x)/f’(x):

Teil des Kurses MATLAB

Kapitel 7 von 8 im Kurs MATLAB (Abschnitt „Projekte“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Projekt 1: Newton-Verfahren

Nullstellen mit der Newton-Iteration x ← x − f(x)/f'(x):

1;
function [x, schritte] = newton(f, df, x0, tol)
    x = x0;
    schritte = 0;
    while abs(f(x)) > tol && schritte < 50
        x = x - f(x) / df(x);
        schritte = schritte + 1;
    end
end
 
f = @(x) x.^2 - 2;
df = @(x) 2 * x;
[x, n] = newton(f, df, 1, 1e-12);
fprintf('sqrt(2) = %.10f nach %d Schritten (Fehler %.1e)\n', x, n, abs(x - sqrt(2)));
 
[x2, n2] = newton(@(x) cos(x) - x, @(x) -sin(x) - 1, 0.5, 1e-12);
fprintf('Lösung von cos(x) = x: %.8f nach %d Schritten\n', x2, n2);

Ausgabe:

sqrt(2) = 1.4142135624 nach 5 Schritten (Fehler 0.0e+00)
Lösung von cos(x) = x: 0.73908513 nach 4 Schritten

Projekt 2: Monte-Carlo-Simulation von π

Ein Punkt im Einheitsquadrat liegt mit Wahrscheinlichkeit π/4 im Viertelkreis. Wir nutzen einen einfachen, reproduzierbaren Zufallsgenerator (LCG), damit die Ausgabe immer gleich ist:

1;
function [z, s] = lcg(s)
    s = mod(1103515245 * s + 12345, 2^31);
    z = s / 2^31;
end
 
s = 42;
n = 20000;
innen = 0;
for k = 1:n
    [x, s] = lcg(s);
    [y, s] = lcg(s);
    if x^2 + y^2 <= 1
        innen = innen + 1;
    end
end
schaetzung = 4 * innen / n;
fprintf('pi ~ %.3f (Abweichung %.3f)\n', schaetzung, abs(schaetzung - pi));
 
% Vektorisiert mit eingebautem Zufall: Ergebnis hängt vom Zufall ab, aber die Genauigkeit stimmt
p = 4 * mean(sum(rand(2, 100000).^2) <= 1);
fprintf('Vektorisiert plausibel: %d\n', abs(p - pi) < 0.05);

Ausgabe:

pi ~ 3.150 (Abweichung 0.008)
Vektorisiert plausibel: 1

Projekt 3: Das Spiel des Lebens

Conways Game of Life auf einem Gitter, rein mit Matrixoperationen:

1;
function G = schritt(G)
    nachbarn = conv2(double(G), [1 1 1; 1 0 1; 1 1 1], 'same');
    G = (G & (nachbarn == 2 | nachbarn == 3)) | (~G & nachbarn == 3);
end
 
G = false(6, 6);
G(2, 3) = true; G(3, 4) = true; G(4, 2:4) = true;    % ein "Gleiter"
for t = 0:3
    fprintf('Generation %d (lebende Zellen: %d)\n', t, sum(G(:)));
    for i = 1:6
        fprintf('%s\n', char(G(i, :) * ('#' - '.') + '.'));
    end
    G = schritt(G);
end

Ausgabe:

Generation 0 (lebende Zellen: 5)
......
..#...
...#..
.###..
......
......
Generation 1 (lebende Zellen: 5)
......
......
.#.#..
..##..
..#...
......
Generation 2 (lebende Zellen: 5)
......
......
...#..
.#.#..
..##..
......
Generation 3 (lebende Zellen: 5)
......
......
..#...
...##.
..##..
......

Projekt 4: Signalverarbeitung

Ein verrauschtes Signal glätten und im Frequenzbereich analysieren:

fs = 100;                              % Abtastrate in Hz
t = (0:fs-1) / fs;                     % eine Sekunde
signal = sin(2*pi*5*t) + 0.5*sin(2*pi*20*t);     % 5 Hz und 20 Hz
 
spektrum = abs(fft(signal)) / (fs/2);
[amp, idx] = sort(spektrum(1:fs/2), 'descend');
frequenzen = idx(1:2) - 1;             % Index k entspricht k Hz bei 1 s Länge
fprintf('Dominante Frequenzen: %d Hz (%.2f) und %d Hz (%.2f)\n', frequenzen(1), amp(1), frequenzen(2), amp(2));
 
glatt = filter(ones(1, 5) / 5, 1, signal);       % gleitender Mittelwert über 5 Werte
fprintf('Energie: Original %.2f, geglättet %.2f\n', sum(signal.^2), sum(glatt.^2));
fprintf('Geglättetes Signal ist kleiner: %d\n', max(abs(glatt(10:end))) < max(abs(signal)));

Ausgabe:

Dominante Frequenzen: 5 Hz (1.00) und 20 Hz (0.50)
Energie: Original 62.50, geglättet 40.75
Geglättetes Signal ist kleiner: 1

Projekt 5: Lineare Regression von Hand

x = [1 2 3 4 5 6]';
y = [2.2 4.1 6.2 7.8 10.1 12.1]';
X = [ones(size(x)), x];               % Entwurfsmatrix
beta = (X' * X) \ (X' * y);           % Normalengleichung
beta2 = X \ y;                        % bequem und stabiler
fprintf('y = %.3f + %.3f x\n', beta(1), beta(2));
fprintf('Gleich wie backslash: %d\n', norm(beta - beta2) < 1e-10);
res = y - X * beta;
r2 = 1 - sum(res.^2) / sum((y - mean(y)).^2);
fprintf('R^2 = %.4f\n', r2);
fprintf('Prognose x = 10: %.2f\n', [1 10] * beta);

Ausgabe:

y = 0.173 + 1.974 x
Gleich wie backslash: 1
R^2 = 0.9986
Prognose x = 10: 19.92

Merke

  • Mit Matrixoperationen (conv2, fft, \, filter) werden komplexe Algorithmen kurz
  • Funktionen können Zustand zurückgeben (LCG) und so Reproduzierbarkeit schaffen
  • Newton, Monte Carlo, Game of Life, FFT und Regression sind klassische Übungsprojekte
  • Prüfe Ergebnisse gegen Referenzen (sqrt, norm, exakte Lösungen)

Übungsaufgabe

Erweitere das Newton-Verfahren um eine Ausgabe jedes Zwischenschritts und finde die Nullstelle von x^3 - 2x - 5.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Diagramme, Dateien und Skripte

Weiter: Referenz und Spickzettel

Alle Kapitel: MATLAB im Überblick

Graphansicht

Backlinks