Namespaces
Variants

std:: log1p, std:: log1pf, std:: log1pl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert im Header <cmath>
(1)
float log1p ( float num ) ;

double log1p ( double num ) ;

long double log1p ( long double num ) ;
(bis C++23)
/*floating-point-type*/
log1p ( /*floating-point-type*/ num ) ;
(seit C++23)
(constexpr seit C++26)
float log1pf ( float num ) ;
(2) (seit C++11)
(constexpr seit C++26)
long double log1pl ( long double num ) ;
(3) (seit C++11)
(constexpr seit C++26)
SIMD-Überladung (seit C++26)
Definiert im Header <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

log1p ( const V & v_num ) ;
(S) (seit C++26)
Definiert im Header <cmath>
template < class Integer >
double log1p ( Integer num ) ;
(A) (constexpr seit C++26)
1-3) Berechnet den natürlichen Logarithmus (Basis- e ) von 1 + num . Diese Funktion ist präziser als der Ausdruck std:: log ( 1 + num ) , wenn num nahe null liegt. Die Bibliothek stellt Überladungen von std::log1p für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::log1p auf v_num aus.
(Siehe math-floating-point und deduced-simd-t für deren Definitionen.)
(since C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

num - Gleitkomma- oder Ganzzahlwert

Rückgabewert

Wenn keine Fehler auftreten, wird ln(1+num) zurückgegeben.

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben (NaN, sofern unterstützt).

Wenn ein Polfehler auftritt, -HUGE_VAL , -HUGE_VALF , oder -HUGE_VALL wird zurückgegeben.

Wenn ein Bereichsfehler aufgrund von Unterlauf auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Ein Domänenfehler tritt auf, wenn num kleiner als -1 ist.

Polfehler kann auftreten, wenn num den Wert -1 hat.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (IEC 60559) unterstützt,

  • Wenn das Argument ±0 ist, wird es unverändert zurückgegeben.
  • Wenn das Argument -1 ist, wird -∞ zurückgegeben und FE_DIVBYZERO ausgelöst.
  • Wenn das Argument kleiner als -1 ist, wird NaN zurückgegeben und FE_INVALID ausgelöst.
  • Wenn das Argument +∞ ist, wird +∞ zurückgegeben.
  • Wenn das Argument NaN ist, wird NaN zurückgegeben.

Hinweise

Die Funktionen std::expm1 und std::log1p sind nützlich für Finanzberechnungen, zum Beispiel bei der Berechnung kleiner täglicher Zinssätze: (1 + x) n
- 1 kann ausgedrückt werden als std:: expm1 ( n * std :: log1p ( x ) ) . Diese Funktionen vereinfachen auch das Schreiben genauer inverser hyperbolischer Funktionen.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr Argument num vom Ganzzahltyp std :: log1p ( num ) dieselbe Wirkung hat wie std :: log1p ( static_cast < double > ( num ) ) .

Beispiel

Diesen Code ausführen 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "log1p(0) = " << log1p(0) << '\n'
              << "Zinsertrag über 2 Tage bei $100, täglich verzinst mit 1%\n"
              << "    auf einem 30/360 Kalender = "
              << 100 * expm1(2 * log1p(0.01 / 360)) << '\n'
              << "log(1+1e-16) = " << std::log(1 + 1e-16)
              << ", aber log1p(1e-16) = " << std::log1p(1e-16) << '\n';
    // spezielle Werte
    std::cout << "log1p(-0) = " << std::log1p(-0.0) << '\n'
              << "log1p(+Inf) = " << std::log1p(INFINITY) << '\n';
    // Fehlerbehandlung
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "log1p(-1) = " << std::log1p(-1) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO ausgelöst\n";
}

Mögliche Ausgabe: 

log1p(0) = 0
Zinsertrag über 2 Tage bei $100, täglich verzinst mit 1%
    auf einem 30/360 Kalender = 0.00555563
log(1+1e-16) = 0, aber log1p(1e-16) = 1e-16
log1p(-0) = -0
log1p(+Inf) = inf
log1p(-1) = -inf
    errno == ERANGE: Ergebnis zu groß
    FE_DIVBYZERO ausgelöst

Siehe auch

(C++11) (C++11)
berechnet den natürlichen Logarithmus (Basis e ) ( ln(x) )
(Funktion)
(C++11) (C++11)
berechnet den dekadischen Logarithmus (Basis 10 ) ( log 10 (x) )
(Funktion)
(C++11) (C++11) (C++11)
Logarithmus zur Basis 2 der gegebenen Zahl ( log 2 (x) )
(Funktion)
(C++11) (C++11) (C++11)
gibt e hoch der gegebenen Potenz minus 1 zurück ( e x -1 )
(Funktion)
C-Dokumentation für log1p