Maschinengenauigkeit und Finite-Differenzen: Ein praktischer Leitfaden für Math1426

Einleitung: Warum numerische Analysis heute wichtig ist

Im Zeitalter von KI-Modellen, die auf Milliarden von Parametern trainiert werden, und Finanzalgorithmen, die in Millisekunden über Millionen entscheiden, ist das Verständnis numerischer Fehlerquellen entscheidend. Dein Math1426-Homework 1 zur numerischen Analysis führt dich genau in diese Thematik ein. Wir schauen uns die Maschinengenauigkeit im IEEE-Doppelgenauigkeitsformat an und optimieren einen Finite-Differenzen-Operator.

1. Maschinengenauigkeit im IEEE-Double-Format

Die Maschinengenauigkeit (oft als eps bezeichnet) ist der Abstand zwischen 1.0 und der nächstkleineren darstellbaren Zahl größer als 1.0. Im IEEE-754-Doppelgenauigkeitsformat (64 Bit) beträgt sie 2-52 ≈ 2,22 × 10-16. Das bedeutet: Jede Gleitkommaoperation hat einen relativen Fehler in dieser Größenordnung.

Praktische Relevanz: Wenn du eine numerische Ableitung berechnest, wirst du bei zu kleinem h (z.B. h < 10-8) durch Auslöschung katastrophale Fehler erhalten – dein Ergebnis wird von Rundungsfehlern dominiert. Bei zu großem h dominiert der Diskretisierungsfehler. Die optimale Schrittweite liegt im Bereich √eps ≈ 10-8.

2. Finite-Differenzen-Formel mit O(h²)-Fehler

Gegeben sei eine dreimal stetig differenzierbare Funktion f. Wir suchen Koeffizienten a, b ∈ ℝ für die Formel:

f'(x) ≈ a·f(x+h) + b·f(x) + a·f(x-h)

Damit der Fehler O(h²) ist, muss die Taylorentwicklung bis zur zweiten Ordnung exakt sein:

• Genauigkeit für Konstante: a + b + a = 0 → 2a + b = 0
• Genauigkeit für lineare Terme: a·h + 0 + a·(-h) = 1 → 0 ≠ 1? Hier liegt ein häufiger Fehler: Die Formel ist zentriert, daher liefert der lineare Term automatisch null. Stattdessen fordern wir, dass die erste Ableitung korrekt approximiert wird:

Taylor: f(x+h) = f + hf' + h²/2 f'' + h³/6 f''' + ...
f(x-h) = f - hf' + h²/2 f'' - h³/6 f''' + ...
Einsetzen: a(f+hf'+...) + b f + a(f-hf'+...) = (2a+b)f + (a h - a h)f' + (a h²/2 + a h²/2) f'' + ...

Damit der Fehler O(h²) wird, muss der Koeffizient von f verschwinden (2a+b=0) und der von f' gleich 1 sein (0 = 1? – das ist unmöglich). Korrektur: Die Formel ist zentriert, daher kann sie die erste Ableitung nicht direkt approximieren, wenn a und b symmetrisch sind. Tatsächlich ist die übliche zentrierte Differenz: f'(x) ≈ (f(x+h)-f(x-h))/(2h). Das ist ein Spezialfall mit a=1/(2h), b=0. Für O(h²) benötigen wir a = 1/(2h) und b = 0. Dann ist der Fehler O(h²).

Allgemein: Für die gegebene Formel mit a, b unabhängig von h? Nein, a und b sind reelle Konstanten, die nicht von h abhängen. Dann kann die Formel nie die erste Ableitung approximieren, da der Koeffizient von f' immer 0 ist. Daher: Die Aufgabenstellung meint vermutlich eine Formel wie f'(x) ≈ a·f(x+h) + b·f(x) + c·f(x-h) mit drei Koeffizienten. Oder aber a und b dürfen von h abhängen. Wir interpretieren hier: a = 1/(2h), b = 0 liefert O(h²).

3. Numerische Evaluation und Plot

Wir setzen f(x) = sin(x) und betrachten x=0 und x=1. Die exakte Ableitung ist cos(x). Für verschiedene h (z.B. 10-1 bis 10-16) berechnen wir den Fehler |f'(x) - (f(x+h)-f(x-h))/(2h)| und plotten ihn doppeltlogarithmisch.

Erwartete Beobachtungen:

• Für große h (z.B. h=0.1) dominiert der Diskretisierungsfehler O(h²). Im Log-Log-Plot steigt der Fehler mit Steigung 2.
• Für sehr kleine h (z.B. h=10-12) dominieren Rundungsfehler. Der Fehler steigt wieder an, da Auslöschung eintritt.
• Das Minimum liegt bei h ≈ 10-8 (≈ √eps).

Empfehlung: Verwende die Formel für h zwischen 10-5 und 10-3, um einen Fehler unter 10-10 zu erhalten. Vermeide h < 10-8 wegen Rundungsfehlern.

4. Implementierung in Python (Beispiel)

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return np.sin(x)

def df_exact(x):
    return np.cos(x)

def central_diff(f, x, h):
    return (f(x+h) - f(x-h)) / (2*h)

x_vals = [0, 1]
h_vals = np.logspace(-1, -16, 100)

for x in x_vals:
    errors = []
    for h in h_vals:
        num = central_diff(f, x, h)
        err = abs(num - df_exact(x))
        errors.append(err)
    plt.loglog(h_vals, errors, label=f'x={x}')

plt.xlabel('h')
plt.ylabel('Fehler')
plt.legend()
plt.grid(True)
plt.show()

5. Interpretation und Bezug zu aktuellen Trends

Stell dir vor, du trainierst ein KI-Modell wie einen Large Language Model (LLM). Die numerische Stabilität der Gradientenberechnung (die im Wesentlichen finite Differenzen nutzt) beeinflusst, ob dein Modell konvergiert oder divergiert. Ähnlich wie bei der Wahl des optimalen h musst du die Lernrate (learning rate) so wählen, dass weder Oszillation noch Stillstand auftritt. Auch in der Finanzmathematik bei der Bewertung von Optionen (z.B. Black-Scholes) werden finite Differenzen eingesetzt – ein falsches h könnte zu Fehlbewertungen in Millionenhöhe führen.

6. Fazit

Die Maschinengenauigkeit setzt eine natürliche Grenze für numerische Differentiation. Durch die Kombination von Diskretisierungs- und Rundungsfehleranalyse findest du die optimale Schrittweite. Für Math1426 solltest du den Plot interpretieren können: Das Tal der Fehlerkurve zeigt den Bereich, in dem die Formel zuverlässig ist. Nutze diese Erkenntnisse für deine weiteren numerischen Projekte – ob in der Simulation physikalischer Systeme oder im Training neuronaler Netze.