Log-Gamma Funktion Rechner

📊 Grunddefinition

Die Log-Gamma-Funktion und ihre Eigenschaften:

\[\text{Definition für } x > 0: \ln \Gamma(x) = \ln\left(\int_0^\infty t^{x-1} e^{-t} \, dt\right)\] \[\text{Funktionalgleichung: } \ln \Gamma(x+1) = \ln x + \ln \Gamma(x)\] \[\text{Für natürliche Zahlen: } \ln \Gamma(n) = \ln((n-1)!) = \sum_{k=1}^{n-1} \ln k\] \[\text{Spezialwerte: } \ln \Gamma(1) = 0, \quad \ln \Gamma(1/2) = \frac{1}{2}\ln \pi\]

🔄 Binet-Formel

Integraldarstellung der Log-Gamma-Funktion:

\[\ln \Gamma(z) = \left(z - \frac{1}{2}\right) \ln z - z + \frac{1}{2}\ln(2\pi) + 2\int_0^\infty \frac{\arctan(t/z)}{e^{2\pi t} - 1} \, dt\] \[\text{Diese Darstellung ist für die analytische Fortsetzung wichtig}\] \[\text{und bietet eine alternative Berechnungsmethode}\]

📊 Stirling-Asymptotik

Asymptotische Entwicklung für große Argumente:

\[\ln \Gamma(z) \sim \left(z - \frac{1}{2}\right) \ln z - z + \frac{1}{2}\ln(2\pi) + \sum_{k=1}^N \frac{B_{2k}}{2k(2k-1)z^{2k-1}}\] \[\text{Wobei } B_{2k} \text{ die Bernoulli-Zahlen sind:}\] \[B_2 = \frac{1}{6}, \quad B_4 = -\frac{1}{30}, \quad B_6 = \frac{1}{42}, \quad B_8 = -\frac{1}{30}, \ldots\] \[\text{Erste Korrekturterme: } \frac{1}{12z} - \frac{1}{360z^3} + \frac{1}{1260z^5} - \ldots\]

📝 Beispiel 1: Große Fakultäten

Aufgabe: Berechnung von ln(100!)
Problem: 100! ist zu groß für direkte Berechnung
Lösung:

\[\ln(100!) = \ln \Gamma(101) = \sum_{k=1}^{100} \ln k\] \[\text{Direkte Summation: } \ln(100!) = \ln 1 + \ln 2 + \cdots + \ln 100\] \[\approx 363{,}7394 \text{ (exakter Wert)}\] \[\text{Stirling-Approximation: } \ln \Gamma(101) \approx 100{,}5 \ln(100) - 100 + 0{,}5 \ln(200\pi)\] \[\approx 100{,}5 \cdot 4{,}605 - 100 + 2{,}83 \approx 363{,}734\] \[\text{Relativer Fehler: } < 0{,}001\%\]

Vorteil: Numerisch stabile Berechnung ohne Overflow

📝 Beispiel 2: Statistische Anwendung

Aufgabe: Log-Likelihood einer Gamma-Verteilung
Dichte: f(x|α,β) = (β^α/Γ(α)) x^(α-1) e^(-βx)
Berechnung:

\[\text{Log-Likelihood für } n \text{ Beobachtungen:}\] \[\ell(\alpha, \beta) = \sum_{i=1}^n \ln f(x_i|\alpha, \beta)\] \[= \sum_{i=1}^n [\alpha \ln \beta - \ln \Gamma(\alpha) + (\alpha-1) \ln x_i - \beta x_i]\] \[= n\alpha \ln \beta - n \ln \Gamma(\alpha) + (\alpha-1) \sum_{i=1}^n \ln x_i - \beta \sum_{i=1}^n x_i\] \[\text{Der Term } -n \ln \Gamma(\alpha) \text{ erfordert stabile Berechnung}\]

Wichtigkeit: Ohne Log-Gamma wäre Maximum-Likelihood-Schätzung problematisch

📝 Beispiel 3: Digamma-Funktion

Aufgabe: Ableitung der Log-Gamma-Funktion
Definition: ψ(x) = d/dx ln Γ(x)
Berechnung:

\[\text{Digamma-Funktion: } \psi(x) = \frac{d}{dx} \ln \Gamma(x) = \frac{\Gamma'(x)}{\Gamma(x)}\] \[\text{Rekursionsrelation: } \psi(x+1) = \psi(x) + \frac{1}{x}\] \[\text{Asymptotische Entwicklung: } \psi(x) \approx \ln x - \frac{1}{2x} - \frac{1}{12x^2} + \frac{1}{120x^4} - \ldots\] \[\text{Spezialwerte: } \psi(1) = -\gamma \text{ (Euler-Mascheroni-Konstante)}\] \[\psi(1/2) = -\gamma - 2\ln 2, \quad \psi(2) = 1 - \gamma\]

Anwendung: Optimierung statistischer Modelle, Variationsparameter

✅ Vorteile der Log-Gamma-Funktion

Numerische Vorteile gegenüber der regulären Gamma-Funktion:

\[\text{✓ Keine Overflow-Probleme bei großen Argumenten}\] \[\text{✓ Bessere numerische Stabilität}\] \[\text{✓ Effiziente Berechenbarkeit durch Stirling-Approximation}\] \[\text{✓ Direkte Verwendung in Log-Likelihood-Funktionen}\] \[\text{✓ Glatte Funktion ohne extreme Steigungen}\] \[\text{✓ Additive Eigenschaften: } \ln \Gamma(x+1) = \ln x + \ln \Gamma(x)\]

⚠️ Numerische Herausforderungen

Aspekte, die beachtet werden müssen:

\[\text{⚠ Pole bei negativen ganzen Zahlen bleiben bestehen}\] \[\text{⚠ Benötigt spezielle Algorithmen für kleine Argumente}\] \[\text{⚠ Analytische Fortsetzung für komplexe Argumente komplex}\] \[\text{⚠ Asymptotische Reihen sind divergent}\]

📊 Log-Gamma Werte

💻 Code-Implementierungen

Effiziente Implementierung der Log-Gamma-Funktion:

Python (SciPy):
from scipy.special import loggamma, digamma, polygamma
import numpy as np

# Log-Gamma-Funktion
result = loggamma(x) # ln(Γ(x))
digamma_val = digamma(x) # ψ(x) = d/dx ln(Γ(x))

# Eigene Implementation (vereinfacht)
def log_gamma_stirling(x):
  """Stirling-Approximation für ln(Γ(x))"""
  if x < 1:
    # Rekursion: ln(Γ(x)) = ln(Γ(x+1)) - ln(x)
    return log_gamma_stirling(x + 1) - np.log(x)
  
  # Stirling-Approximation
  return (x - 0.5) * np.log(x) - x + 0.5 * np.log(2 * np.pi)

R:
result <- lgamma(x) # Log-Gamma
digamma_val <- digamma(x) # Digamma
trigamma_val <- trigamma(x) # Trigamma

MATLAB:
result = gammaln(x); % Log-Gamma
psi_val = psi(x); % Digamma (in Statistics Toolbox)

🎯 Hochpräzise Implementation

Professionelle Implementierung mit Fehlerbehandlung:

C++ (Numerically Stable):
#include <cmath>
#include <stdexcept>

double log_gamma(double x) {
  if (x <= 0) {
    if (x == floor(x)) {
      throw std::domain_error("log_gamma: pole at negative integer");
    }
    // Reflection formula: ln(Γ(x)) = ln(π) - ln(sin(πx)) - ln(Γ(1-x))
    return log(M_PI) - log(sin(M_PI * x)) - log_gamma(1 - x);
  }

  // For x > 0, use Stirling series or Lanczos
  if (x < 12) {
    // Use recurrence to get x >= 12
    double result = 0;
    while (x < 12) {
      result -= log(x);
      x += 1;
    }
    return result + log_gamma_stirling(x);
  }

  return log_gamma_stirling(x);
}

double log_gamma_stirling(double x) {
  // Stirling series with correction terms
  double inv_x = 1.0 / x;
  double inv_x2 = inv_x * inv_x;
  
  return (x - 0.5) * log(x) - x + 0.5 * log(2 * M_PI) +
         inv_x / 12 - inv_x2 * inv_x / 360 + inv_x2 * inv_x2 * inv_x / 1260;
}

🎯 Statistische Anwendung

Verwendung in statistischen Modellen:

Gamma-Verteilung Log-Likelihood:
def gamma_log_likelihood(data, alpha, beta):
  """Log-Likelihood für Gamma-Verteilung"""
  n = len(data)
  sum_log_x = np.sum(np.log(data))
  sum_x = np.sum(data)
  
  return (n * alpha * np.log(beta) -
         n * loggamma(alpha) +
         (alpha - 1) * sum_log_x -
         beta * sum_x)

Beta-Funktion über Log-Gamma:
def log_beta(a, b):
  """Logarithmische Beta-Funktion"""
  return loggamma(a) + loggamma(b) - loggamma(a + b)

Multinomial-Koeffizient:
def log_multinomial_coeff(n, k_list):
  """Log des multinomialen Koeffizienten"""
  return loggamma(n + 1) - np.sum([loggamma(k + 1) for k in k_list])