Lanczos Gamma-Approximation Rechner

🎯 Lanczos-Formel

Die fundamentale Lanczos-Approximation:

\[\text{Für } \Re(z) > -(g+\frac{1}{2}):\] \[\Gamma(z+1) = \sqrt{2\pi} \left(z + g + \frac{1}{2}\right)^{z+\frac{1}{2}} \exp\left(-(z+g+\frac{1}{2})\right) A_g(z)\] \[\text{wobei } A_g(z) = \frac{1}{2}p_0(g) + \sum_{k=1}^{N} p_k(g)\frac{z}{z+k}\] \[\text{und die Parameter } g \text{ und Koeffizienten } p_k(g) \text{ optimal gewählt sind}\]

🔄 Partialbruch-Darstellung

Optimierte numerische Form:

\[\text{Durch Vorberechnung geeigneter Koeffizienten } \{c_k\}:\] \[A_g(z) = c_0 + \sum_{k=1}^N \frac{c_k}{z + k}\] \[\text{Diese Form minimiert Rundungsfehler und erlaubt:}\] \[\text{• Wenige Multiplikationen}\] \[\text{• Wenige Potenzen und Exponentialfunktionen}\] \[\text{• Kleine Lookup-Tabellen}\]

📊 Koeffizienten-Beispiel

Typische Lanczos-Koeffizienten für g=7:

\[c_0 = 0{,}99999999999980993\] \[c_1 = 676{,}5203681218851\] \[c_2 = -1259{,}1392167224028\] \[c_3 = 771{,}32342877765313\] \[c_4 = -176{,}61502916214059\] \[c_5 = 12{,}507343278686905\] \[c_6 = -0{,}13857109526572012\] \[c_7 = 9{,}9843695780195716 \times 10^{-6}\]

📝 Beispiel 1: Genauigkeitsvergleich

Aufgabe: Vergleich Lanczos vs. Stirling für Γ(2.5)
Exakter Wert: Γ(2.5) = 1.5√π ≈ 1.329340388
Berechnung:

\[\text{Lanczos-Approximation: } \Gamma_L(2{,}5) \approx 1{,}329340388179137\] \[\text{Stirling-Approximation: } \Gamma_S(2{,}5) \approx 1{,}369094516\] \[\text{Exakt: } \Gamma(2{,}5) = \frac{3\sqrt{\pi}}{4} \approx 1{,}329340388179137\] \[\text{Relativer Fehler Lanczos: } \epsilon_L \approx 10^{-15}\] \[\text{Relativer Fehler Stirling: } \epsilon_S \approx 3{,}0\%\]

Ergebnis: Lanczos ist um Größenordnungen genauer

📝 Beispiel 2: Implementierungs-Performance

Aufgabe: Rechenaufwand der Lanczos-Methode
Operationen für Γ(x):
Analyse:

\[\text{Lanczos-Aufwand:}\] \[\text{• } N \text{ Divisionen (typisch } N = 8\text{)}\] \[\text{• } 1 \text{ Potenz } (z+g+0{,}5)^{z+0{,}5}\] \[\text{• } 1 \text{ Exponentialfunktion } e^{-(z+g+0{,}5)}\] \[\text{• } O(N) \text{ Multiplikationen und Additionen}\] \[\text{Stirling-Aufwand ähnlich, aber weniger genau}\] \[\text{Direktes Integral: } O(\infty) \text{ - nicht praktikabel}\]

Vorteil: Optimales Verhältnis von Genauigkeit zu Rechenzeit

📝 Beispiel 3: Reflektionsformel-Anwendung

Aufgabe: Berechnung für negative Argumente
Problem: Lanczos gilt nur für Re(z) > -(g+1/2)
Lösung:

\[\text{Für } z < 0{,}5 \text{ verwende Reflektionsformel:}\] \[\Gamma(z) = \frac{\pi}{\sin(\pi z) \Gamma(1-z)}\] \[\text{Beispiel: } \Gamma(-0{,}5)\] \[\Gamma(-0{,}5) = \frac{\pi}{\sin(-0{,}5\pi) \Gamma(1{,}5)}\] \[= \frac{\pi}{-\sin(0{,}5\pi) \cdot \frac{\sqrt{\pi}}{2}} = \frac{\pi}{-1 \cdot \frac{\sqrt{\pi}}{2}} = -2\sqrt{\pi}\]

Strategie: Kombiniere Lanczos mit Reflektionsformel für vollständige Abdeckung

📊 Genauigkeitsvergleich

✅ Vorteile der Lanczos-Approximation

Überlegene Eigenschaften der Lanczos-Methode:

\[\text{✓ Konstante relative Genauigkeit über weiten Bereich}\] \[\text{✓ Schnelle Konvergenz mit wenigen Termen}\] \[\text{✓ Numerisch stabile Implementation}\] \[\text{✓ Industriestandard in wissenschaftlichen Bibliotheken}\] \[\text{✓ Optimales Genauigkeit-zu-Geschwindigkeit Verhältnis}\] \[\text{✓ Gut dokumentierte Koeffizienten verfügbar}\]

⚠️ Einschränkungen und Herausforderungen

Aspekte, die zu beachten sind:

\[\text{⚠ Koeffizientenberechnung ist komplex}\] \[\text{⚠ Benötigt vorberechnete Tabellen}\] \[\text{⚠ Für Re(z) < -(g+1/2) sind zusätzliche Formeln nötig}\] \[\text{⚠ Implementierung erfordert Sorgfalt für numerische Stabilität}\] \[\text{⚠ Weniger intuitiv als Stirling-Formel}\]

💻 Code-Implementierungen

Professionelle Implementierung der Lanczos-Approximation:

Python (Vollständige Implementierung):
import math

def lanczos_gamma(x):
  """Lanczos-Approximation für Gamma-Funktion"""
  if x < 0.5:
    # Reflektionsformel
    return math.pi / (math.sin(math.pi * x) * lanczos_gamma(1 - x))

  # Lanczos-Koeffizienten für g=7
  g = 7
  coeff = [0.99999999999980993, 676.5203681218851, ...]

  x -= 1
  a = coeff[0]
  for i in range(1, g + 2):
    a += coeff[i] / (x + i)

  t = x + g + 0.5
  sqrt_2pi = math.sqrt(2 * math.pi)
  return sqrt_2pi * (t ** (x + 0.5)) * math.exp(-t) * a

C++ (Hochoptimiert):
#include <cmath>
const double lanczos_coeff[9] = {
  0.99999999999980993, 676.5203681218851, ...
};

double lanczos_gamma(double x) {
  if (x < 0.5) return M_PI / (sin(M_PI * x) * lanczos_gamma(1 - x));
  // Implementation...
}

🎯 Produktions-Implementation

Robuste Implementierung für produktive Systeme:

Numerische Stabilität:
def stable_lanczos_gamma(x):
  """Numerisch stabile Lanczos-Implementation"""
  if x <= 0:
    if x == int(x): # Negative ganze Zahl
      raise ValueError("Gamma hat Pole bei negativen ganzen Zahlen")
    return math.pi / (math.sin(math.pi * x) * stable_lanczos_gamma(1 - x))

  if x < 1:
    return stable_lanczos_gamma(x + 1) / x

  # Für x >= 1 verwende standard Lanczos
  return lanczos_core(x)

Logarithmische Version (für große x):
def log_lanczos_gamma(x):
  """Log-Gamma mit Lanczos für numerische Stabilität"""
  # Verhindert Overflow bei großen x
  log_sqrt_2pi = 0.5 * math.log(2 * math.pi)
  return log_sqrt_2pi + (x - 0.5) * math.log(x + g + 0.5) - (x + g + 0.5) + math.log(A_g)

Multi-Precision:
from decimal import Decimal, getcontext
getcontext().prec = 50 # 50 Dezimalstellen
# Hochpräzise Koeffizienten verwenden...

🎯 Performance-Optimierung

Optimierungsstrategien für maximale Effizienz:

\[\text{Lookup-Tabellen für kleine ganzzahlige Argumente}\] \[\text{Caching häufig verwendeter Zwischenergebnisse}\] \[\text{SIMD-Vektorisierung für Batch-Berechnungen}\] \[\text{Asymptotische Expansion für sehr große Argumente}\] \[\text{Optimierte Polynomauswertung (Horner-Schema)}\] \[\text{Thread-lokale Koeffizientenspeicher}\]