Difference between revisions of "cpp/numeric/math/log1p"

Latest revision as of 09:31, 15 October 2023

Defined in header `<cmath>`
	(1)
float log1p ( float num ); double log1p ( double num ); long double log1p ( long double num );			(until C++23)
/* floating-point-type / log1p ( / floating-point-type */ num );			(since C++23) (constexpr since C++26)
float log1pf( float num );		(2)	(since C++11) (constexpr since C++26)
long double log1pl( long double num );		(3)	(since C++11) (constexpr since C++26)
Additional overloads (since C++11)
Defined in header `<cmath>`
template< class Integer > double log1p ( Integer num );		(A)	(constexpr since C++26)

1-3) Computes the natural (base e) logarithm of 1 + num. This function is more precise than the expression std::log(1 + num) if num is close to zero. The library provides overloads of std::log1p for all cv-unqualified floating-point types as the type of the parameter.(since C++23)

A) Additional overloads are provided for all integer types, which are treated as double.

(since C++11)

If num1 or num2 has type long double, then std::log1p(num1, num2) has the same effect as std::log1p(static_cast<long double>(num1),
static_cast<long double>(num2)).
Otherwise, if num1 and/or num2 has type double or an integer type, then std::log1p(num1, num2) has the same effect as std::log1p(static_cast<double>(num1),
static_cast<double>(num2)).
Otherwise, if num1 or num2 has type float, then std::log1p(num1, num2) has the same effect as std::log1p(static_cast<float>(num1),
static_cast<float>(num2)).

(until C++23)

If num1 and num2 have arithmetic types, then std::log1p(num1, num2) has the same effect as std::log1p(static_cast</* common-floating-point-type */>(num1),
static_cast</* common-floating-point-type */>(num2)), where /* common-floating-point-type */ is the floating-point type with the greatest floating-point conversion rank and greatest floating-point conversion subrank between the types of num1 and num2, arguments of integer type are considered to have the same floating-point conversion rank as double.

If no such floating-point type with the greatest rank and subrank exists, then overload resolution does not result in a usable candidate from the overloads provided.

(since C++23)

[edit] Example

Run this code

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::cout << "log1p(0) = " << log1p(0) << '\n'
              << "Interest earned in 2 days on $100, compounded daily at 1%\n"
              << "    on a 30/360 calendar = "
              << 100 * expm1(2 * log1p(0.01 / 360)) << '\n'
              << "log(1+1e-16) = " << std::log(1 + 1e-16)
              << ", but log1p(1e-16) = " << std::log1p(1e-16) << '\n';
 
    // special values
    std::cout << "log1p(-0) = " << std::log1p(-0.0) << '\n'
              << "log1p(+Inf) = " << std::log1p(INFINITY) << '\n';
 
    // error handling
    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 raised\n";
}

Possible output:

log1p(0) = 0
Interest earned in 2 days on $100, compounded daily at 1%
    on a 30/360 calendar = 0.00555563
log(1+1e-16) = 0, but log1p(1e-16) = 1e-16
log1p(-0) = -0
log1p(+Inf) = inf
log1p(-1) = -inf
    errno == ERANGE: Result too large
    FE_DIVBYZERO raised

[edit] See also

loglogflogl (C++11)(C++11)	computes natural (base e) logarithm (${\small\ln{x}}$ $ln(x)$ ) (function) [edit]
log10log10flog10l (C++11)(C++11)	computes common (base 10) logarithm (${\small\log_{10}{x}}$ $log 10 (x)$ ) (function) [edit]
log2log2flog2l (C++11)(C++11)(C++11)	base 2 logarithm of the given number (${\small\log_{2}{x}}$ $log 2 (x)$ ) (function) [edit]
expm1expm1fexpm1l (C++11)(C++11)(C++11)	returns e raised to the given power, minus one (${\small e^x-1}$ $e x -1$ ) (function) [edit]
C documentation for log1p

@@ Line 1: / Line 1: @@
 {{cpp/title|log1p|log1pf|log1pl}}
 {{cpp/numeric/math/navbar}}
-{{dcl begin}}
+{{cpp/numeric/math/declarations
-{{dcl header|cmath}}
+|family=log1p
-{{dcl|since=c++11|num=1|
+|param1=num
-float       log1p ( float arg );
+|constexpr_since=26
-float       log1pf( float arg );
+|desc=Computes the {{enwiki|Natural logarithm|natural (base ''e'') logarithm}} of {{c|1 + num}}. This function is more precise than the expression {{c|std::log(1 + num)}} if {{c|num}} is close to zero.
 }}
-{{dcl|since=c++11|num=2|
-double      log1p ( double arg );
-}}
-{{dcl|since=c++11|num=3|
-long double log1p ( long double arg );
-long double log1pl( long double arg );
-}}
-{{dcl|since=c++11|num=4|
-double      log1p ( IntegralType arg );
-}}
-{{dcl end}}
-@1-3@ Computes the natural (base {{c|e}}) logarithm of {{c|1 + arg}}. This function is more precise than the expression {{c|std::log(1 + arg)}} if {{tt|arg}} is close to zero.
-@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to {{v|2}} (the argument is cast to {{c|double}}).
 ===Parameters===
 {{par begin}}
-{{par|arg|value of floating-point or [[cpp/types/is_integral|Integral type]]}}
+{{par|num|floating-point or integer value}}
 {{par end}}
 ===Return value===
-If no errors occur {{math|ln(1+arg)}} is returned.
+If no errors occur {{math|ln(1+num)}} is returned.
-If a domain error occurs, an implementation-defined value is returned (NaN where supported)
+If a domain error occurs, an implementation-defined value is returned (NaN where supported).
 If a pole error occurs, {{lc|HUGE_VAL|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.
@@ Line 39: / Line 25: @@
 Errors are reported as specified in {{lc|math_errhandling}}.
-Domain error occurs if {{tt|arg}} is less than {{math|-1}}.
+Domain error occurs if {{c|num}} is less than {{math|-1}}.
-Pole error may occur if {{tt|arg}} is {{math|-1}}.
+Pole error may occur if {{c|num}} is {{math|-1}}.
 If the implementation supports IEEE floating-point arithmetic (IEC 60559),
-* If the argument is ±0, it is returned unmodified
+* If the argument is ±0, it is returned unmodified.
 * If the argument is -1, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
 * If the argument is less than -1, NaN is returned and {{lc|FE_INVALID}} is raised.
-* If the argument is +∞, +∞ is returned
+* If the argument is +∞, +∞ is returned.
-* If the argument is NaN, NaN is returned
+* If the argument is NaN, NaN is returned.
 ===Notes===
-The functions {{lc|std::expm1}} and {{tt|std::log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1+x){{su|p=n}}-1}} can be expressed as {{c|std::expm1(n * std::log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.
+The functions {{lc|std::expm1}} and {{tt|std::log1p}} are useful for financial calculations, for example, when calculating small daily interest rates: {{math|(1 + x){{su|p=n}} - 1}} can be expressed as {{c|std::expm1(n * std::log1p(x))}}. These functions also simplify writing accurate inverse hyperbolic functions.
+{{cpp/numeric/math/additional overload note|log1p}}
 ===Example===
@@ Line 67: / Line 55: @@
      std::cout << "log1p(0) = " << log1p(0) << '\n'
                << "Interest earned in 2 days on $100, compounded daily at 1%\n"
-               << " on a 30/360 calendar = "
+               << "    on a 30/360 calendar = "
-               << 100*expm1(2*log1p(0.01/360)) << '\n'
+               << 100 * expm1(2 * log1p(0.01 / 360)) << '\n'
-               << "log(1+1e-16) = " << std::log(1+1e-16)
+               << "log(1+1e-16) = " << std::log(1 + 1e-16)
                << ", but log1p(1e-16) = " << std::log1p(1e-16) << '\n';
      // special values
      std::cout << "log1p(-0) = " << std::log1p(-0.0) << '\n'
                << "log1p(+Inf) = " << std::log1p(INFINITY) << '\n';
      // error handling
      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';
@@ Line 87: / Line 79: @@
 log1p(0) = 0
 Interest earned in 2 days on $100, compounded daily at 1%
- on a 30/360 calendar = 0.00555563
+    on a 30/360 calendar = 0.00555563
 log(1+1e-16) = 0, but log1p(1e-16) = 1e-16
 log1p(-0) = -0

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/numeric/math/log1p"

Latest revision as of 09:31, 15 October 2023

Contents

[edit] Parameters

[edit] Return value

[edit] Error handling

[edit] Notes

[edit] Example

[edit] See also

Navigation

Toolbox

loglogflogl (C++11)(C++11)	computes natural (base e) logarithm (\({\small\ln{x}}\) $ln(x)$ ) (function) [edit]
log10log10flog10l (C++11)(C++11)	computes common (base 10) logarithm (\({\small\log_{10}{x}}\) $log 10 (x)$ ) (function) [edit]
log2log2flog2l (C++11)(C++11)(C++11)	base 2 logarithm of the given number (\({\small\log_{2}{x}}\) $log 2 (x)$ ) (function) [edit]
expm1expm1fexpm1l (C++11)(C++11)(C++11)	returns e raised to the given power, minus one (\({\small e^x-1}\) $e x -1$ ) (function) [edit]
C documentation for log1p