log1p()

Die Funktion log1p() in PHP berechnet den natürlichen Logarithmus von 1 + x, also ln(1 + x), auf eine Art und Weise, die auch dann präzise bleibt, wenn x sehr nahe an null liegt. Diese Seite behandelt die Syntax, das Präzisionsproblem, das die Funktion löst, die Rückgabewerte an den Grenzen ihres Definitionsbereichs und wann man sie statt des einfachen log() verwenden sollte.

Syntax

log1p(float $num): float

• $num — der Wert, der zu 1 addiert wird. Muss größer als -1 sein, um ein endliches Ergebnis zu liefern.
• Rückgabewert — ein float, der dem natürlichen Logarithmus (Basis e) von 1 + $num entspricht.

Was log1p() bewirkt

Mathematisch ist log1p($num) identisch mit log(1 + $num). Der Unterschied liegt in der numerischen Genauigkeit. Gleitkommazahlen haben eine begrenzte Präzision, weshalb bei der Berechnung von 1 + $num für ein sehr kleines $num ein Großteil der signifikanten Stellen von $num bei der Addition verloren geht, bevor der Logarithmus überhaupt gebildet wird. Dieses Phänomen wird als katastrophale Auslöschung bezeichnet.

log1p() ist so implementiert, dass ln(1 + x) direkt berechnet wird, ohne die Zwischensumme zu bilden, sodass diese Stellen erhalten bleiben. Für kleine Eingaben ist sie das richtige Werkzeug; für große Eingaben liefern beide Funktionen übereinstimmende Ergebnisse.

Einfaches Beispiel

Wir übergeben einen sehr kleinen Wert an log1p() und geben das Ergebnis aus. Die Ausgabe ist der natürliche Logarithmus von 1.0001, ausgedrückt in wissenschaftlicher Notation (9.9995...E-5 bedeutet 0.000099995...).

Warum log1p() log(1 + $x) für kleine Werte überlegen ist

Vergleichen Sie beide Ansätze für dieselbe winzige Eingabe:

<?php
$x = 1e-15;

echo log1p($x), "\n";   // 1.0E-15               (accurate)
echo log(1 + $x), "\n"; // 1.1102230246252E-15  (wrong)
?>

Das erwartete Ergebnis ist ungefähr 1e-15. log1p() gibt es nahezu exakt zurück, während log(1 + $x) etwa 11 % zu groß ist, weil 1 + 1e-15 in doppelter Gleitkomma-Präzision bereits schlecht gerundet wird. Je kleiner die Eingabe, desto größer der relative Fehler der naiven Version – genau das ist der Grund, warum log1p() existiert.

Definitionsbereich und Grenzfälle

Das Argument muss größer als -1 sein. Beobachten Sie das Verhalten an den Grenzen:

<?php
var_dump(log1p(0));      // float(0)     — ln(1) = 0
var_dump(log1p(M_E - 1)); // float(1)    — ln(e) = 1
var_dump(log1p(-1));     // float(-INF)  — ln(0) is negative infinity
var_dump(log1p(-2));     // float(NAN)   — undefined: 1 + (-2) = -1 < 0
?>

• log1p(0) gibt 0 zurück, da ln(1) = 0.
• Bei $num = -1 ist der innere Wert 0, und der Logarithmus strebt gegen negative Unendlichkeit (-INF).
• Für $num < -1 ist das Ergebnis NAN (kein gültiger Wert), da der Logarithmus eines nicht-positiven Werts für reelle Zahlen undefiniert ist.

Schützen Sie sich vor ungültigen Eingaben, bevor Sie die Funktion aufrufen:

<?php
function safeLog1p(float $num): ?float
{
    if ($num <= -1) {
        return null; // outside the valid domain
    }
    return log1p($num);
}

var_dump(safeLog1p(0.5));  // float(0.4054651081081644)
var_dump(safeLog1p(-1.5)); // NULL
?>

Wann man sie verwenden sollte

log1p() ist eine Präzisionsoptimierung und lohnt sich immer dann, wenn Sie mit Werten arbeiten, die nahe null liegen:

• Finanzen — Umrechnung eines kleinen Zins- oder Wachstumssatzes r in einen kontinuierlich aufgezinsten Satz mit log1p($r).
• Statistik und maschinelles Lernen — Berechnung von Log-Wahrscheinlichkeiten oder Log-Likelihoods, bei denen einzelne Werte winzig sind.
• Wissenschaftliches Rechnen — jede Formel der Form ln(1 + x), bei der x klein sein kann.

Für alltägliche Eingaben, die nicht nahe null liegen, ist log() vollkommen ausreichend; beide liefern praktisch denselben Wert. Die Umkehroperation – die Wiederherstellung von x aus log1p(x) – ist expm1(), das e^x - 1 mit demselben Präzisionsvorteil berechnet.

Verwandte Funktionen

• log() — natürlicher Logarithmus oder Logarithmus zu einer beliebigen Basis.
• log10() — Logarithmus zur Basis 10.
• exp() — e hoch einer Potenz (die Umkehrfunktion von log()).
• expm1() — berechnet e^x - 1 präzise; die Umkehrfunktion von log1p().
• PHP Math Functions — Übersicht der mathematischen Bibliothek von PHP.

Fazit

log1p() berechnet ln(1 + x) und bewahrt dabei die Genauigkeit für Eingaben nahe null, bei denen das naive log(1 + $x) an Präzision verliert. Denken Sie daran, dass das Argument größer als -1 sein muss, dass -1 den Wert -INF ergibt und dass Werte unter -1 NAN liefern. Verwenden Sie die Funktion in Finanz-, Statistik- und wissenschaftlichem Code, wenn kleine Werte eine Rolle spielen.

Übungen