Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | numeric‎ | math
m (Undo revision 106555 by 98.24.33.186 (talk) that's not a c++20 concept)
m (., headers sorted, fmt)
 
(6 intermediate revisions by 5 users not shown)
Line 1: Line 1:
−
{{cpp/title|log2}}
+
{{cpp/title|log2|log2f|log2l}}
 
{{cpp/numeric/math/navbar}}
 
{{cpp/numeric/math/navbar}}
−
{{dcl begin}}
+
{{cpp/numeric/math/declarations
−
{{dcl header | cmath}}
+
|family=log2
−
{{dcl | since=c++11 |num=1|
+
|param1=num
−
float      log2( float arg );
+
|constexpr_since=26
 +
|desc=Computes the {{enwiki|Binary logarithm|binary (base-''2'') logarithm}} of {{c|num}}.
 
}}
 
}}
−
{{dcl | since=c++11 |num=2|
 
−
double      log2( double arg );
 
−
}}
 
−
{{dcl | since=c++11 |num=3|
 
−
long double log2( long double arg );
 
−
}}
 
−
{{dcl | since=c++11 |num=4|
 
−
double      log2( Integral arg );
 
−
}}
 
−
{{dcl end}}
 
−
 
−
@1-3@ Computes the binary (base-''2'') logarithm of {{c|arg}}.
 
−
@4@ A set of overloads or a function template accepting an argument of any [[cpp/types/is_integral|integral type]]. Equivalent to 2) (the argument is cast to {{c|double}}).
 
  
 
===Parameters===
 
===Parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | arg | value of floating-point or [[cpp/types/is_integral|Integral type]]}}
+
{{par|num|floating-point or integer value}}
 
{{par end}}
 
{{par end}}
  
 
===Return value===
 
===Return value===
−
If no errors occur, the base-''2'' logarithm of {{tt|arg}} ({{math|log{{su|b=2}}(arg)}} or {{math|lb(arg)}}) is returned.
+
If no errors occur, the base-''2'' logarithm of {{c|num}} ({{math|log{{su|b=2}}(num)}} or {{math|lb(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, {{tt|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.
+
If a pole error occurs, {{lc|HUGE_VAL|-HUGE_VAL}}, {{tt|-HUGE_VALF}}, or {{tt|-HUGE_VALL}} is returned.
  
 
===Error handling===
 
===Error handling===
−
Errors are reported as specified in [[cpp/numeric/math/math_errhandling|math_errhandling]]
+
Errors are reported as specified in {{lc|math_errhandling}}.
  
−
Domain error occurs if {{tt|arg}} is less than zero.
+
Domain error occurs if {{c|num}} is less than zero.
  
−
Pole error may occur if {{tt|arg}} is zero.
+
Pole error may occur if {{c|num}} is zero.
  
 
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
 
If the implementation supports IEEE floating-point arithmetic (IEC 60559),
 
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
 
* If the argument is ±0, -∞ is returned and {{lc|FE_DIVBYZERO}} is raised.
−
* If the argument is 1, +0 is returned
+
* If the argument is 1, +0 is returned.
 
* If the argument is negative, NaN is returned and {{lc|FE_INVALID}} is raised.
 
* If the argument is negative, 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===
 
===Notes===
−
For integer {{tt|arg}}, the binary logarithm can be interpreted as the zero-based index of the most significant 1 bit in the input.
+
For integer {{c|num}}, the binary logarithm can be interpreted as the zero-based index of the most significant 1 bit in the input.
 +
 
 +
{{cpp/numeric/math/additional integer overload note|log2}}
  
 
===Example===
 
===Example===
−
{{example|code=
+
{{example
−
#include <iostream>
+
|code=
−
#include <cmath>
+
 
#include <cerrno>
 
#include <cerrno>
−
#include <cstring>
 
 
#include <cfenv>
 
#include <cfenv>
−
#pragma STDC FENV_ACCESS ON
+
#include <cmath>
 +
#include <cstring>
 +
#include <iostream>
 +
// #pragma STDC FENV_ACCESS ON
 +
 
 
int main()
 
int main()
 
{
 
{
Line 63: Line 55:
 
               << "log2(0x020f) = " << std::log2(0x020f)
 
               << "log2(0x020f) = " << std::log2(0x020f)
 
               << " (highest set bit is in position 9)\n"
 
               << " (highest set bit is in position 9)\n"
−
               << "base-5 logarithm of 125 = " << std::log2(125)/std::log2(5) << '\n';
+
               << "base-5 logarithm of 125 = "
 +
              << std::log2(125) / std::log2(5) << '\n';
 +
 
 
     // special values
 
     // special values
 
     std::cout << "log2(1) = " << std::log2(1) << '\n'
 
     std::cout << "log2(1) = " << std::log2(1) << '\n'
 
               << "log2(+Inf) = " << std::log2(INFINITY) << '\n';
 
               << "log2(+Inf) = " << std::log2(INFINITY) << '\n';
−
     // error handling  
+
 
−
     errno=0; std::feclearexcept(FE_ALL_EXCEPT);
+
     // error handling
 +
     errno = 0;
 +
    std::feclearexcept(FE_ALL_EXCEPT);
 +
 
 
     std::cout << "log2(0) = " << std::log2(0) << '\n';
 
     std::cout << "log2(0) = " << std::log2(0) << '\n';
−
     if(errno == ERANGE)
+
 
 +
     if (errno == ERANGE)
 
         std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
 
         std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
−
     if(std::fetestexcept(FE_DIVBYZERO))
+
     if (std::fetestexcept(FE_DIVBYZERO))
 
         std::cout << "    FE_DIVBYZERO raised\n";
 
         std::cout << "    FE_DIVBYZERO raised\n";
 
}
 
}
Line 87: Line 85:
 
     FE_DIVBYZERO raised
 
     FE_DIVBYZERO raised
 
}}
 
}}
 +
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/numeric/math/dsc log}}
+
{{dsc inc|cpp/numeric/math/dsc log}}
−
{{dsc inc | cpp/numeric/math/dsc log10}}
+
{{dsc inc|cpp/numeric/math/dsc log10}}
−
{{dsc inc | cpp/numeric/math/dsc log1p}}
+
{{dsc inc|cpp/numeric/math/dsc log1p}}
−
{{dsc inc | cpp/numeric/math/dsc exp2}}
+
{{dsc inc|cpp/numeric/math/dsc exp2}}
−
{{dsc see c | c/numeric/math/log2}}
+
{{dsc see c|c/numeric/math/log2}}
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/numeric/math/log2]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/numeric/math/log2]]
+
−
[[fr:cpp/numeric/math/log2]]
+
−
[[it:cpp/numeric/math/log2]]
+
−
[[ja:cpp/numeric/math/log2]]
+
−
[[pt:cpp/numeric/math/log2]]
+
−
[[ru:cpp/numeric/math/log2]]
+
−
[[zh:cpp/numeric/math/log2]]
+

Latest revision as of 09:33, 15 October 2023

 
C++
 
Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
(C++26)
(C++26)
(C++26)
(C++26)
(C++26)

Generic numeric operations
Bit operations
(C++20)    
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++23)
(C++20)
 
Common mathematical functions
Functions
Basic operations
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Exponential functions
(C++11)
(C++11)

(C++11)
log2
(C++11)
Power functions
(C++11)
(C++11)
Trigonometric and
hyperbolic functions
(C++11)
(C++11)
(C++11)

Error and gamma functions
(C++11)
(C++11)
(C++11)
(C++11)
Nearest integer floating point operations
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Floating point manipulation functions
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
 
Defined in header <cmath>
(1)
float       log2 ( float num );

double      log2 ( double num );

long double log2 ( long double num );
 (until C++23)
/* floating-point-type */
            log2 ( /* floating-point-type */ num );
 (since C++23)
(constexpr since C++26)
float       log2f( float num );
 (2) (since C++11)
(constexpr since C++26)
long double log2l( long double num );
 (3) (since C++11)
(constexpr since C++26)
Additional overloads (since C++11)
Defined in header <cmath>
template< class Integer >
double      log2 ( Integer num );
 (A) (constexpr since C++26)
1-3) Computes the binary (base-2) logarithm of num. The library provides overloads of std::log2 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)

Contents

[edit] Parameters

num - floating-point or integer value

[edit] Return value

If no errors occur, the base-2 logarithm of num (log2(num) or lb(num)) is returned.

If a domain error occurs, an implementation-defined value is returned (NaN where supported).

If a pole error occurs, -HUGE_VAL, -HUGE_VALF, or -HUGE_VALL is returned.

[edit] Error handling

Errors are reported as specified in math_errhandling.

Domain error occurs if num is less than zero.

Pole error may occur if num is zero.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

  • If the argument is ±0, -∞ is returned and FE_DIVBYZERO is raised.
  • If the argument is 1, +0 is returned.
  • If the argument is negative, NaN is returned and FE_INVALID is raised.
  • If the argument is +∞, +∞ is returned.
  • If the argument is NaN, NaN is returned.

[edit] Notes

For integer num, the binary logarithm can be interpreted as the zero-based index of the most significant 1 bit in the input.

The additional overloads are not required to be provided exactly as (A). They only need to be sufficient to ensure that for their argument num of integer type, std::log2(num) has the same effect as std::log2(static_cast<double>(num)).

[edit] Example

Run this code
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::cout << "log2(65536) = " << std::log2(65536) << '\n'
              << "log2(0.125) = " << std::log2(0.125) << '\n'
              << "log2(0x020f) = " << std::log2(0x020f)
              << " (highest set bit is in position 9)\n"
              << "base-5 logarithm of 125 = "
              << std::log2(125) / std::log2(5) << '\n';
 
    // special values
    std::cout << "log2(1) = " << std::log2(1) << '\n'
              << "log2(+Inf) = " << std::log2(INFINITY) << '\n';
 
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "log2(0) = " << std::log2(0) << '\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: 

log2(65536) = 16
log2(0.125) = -3
log2(0x020f) = 9.04166 (highest set bit is in position 9)
base-5 logarithm of 125 = 3
log2(1) = 0
log2(+Inf) = inf
log2(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised

[edit] See also

(C++11)(C++11)
 computes natural (base e) logarithm (ln(x))
(function) [edit]
(C++11)(C++11)
 computes common (base 10) logarithm (log10(x))
(function) [edit]
(C++11)(C++11)(C++11)
 natural logarithm (to base e) of 1 plus the given number (ln(1+x))
(function) [edit]
(C++11)(C++11)(C++11)
 returns 2 raised to the given power (2x)
(function) [edit]
C documentation for log2
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/log2&oldid=160741"