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

Latest revision as of 04:18, 18 May 2024

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

1-3) Computes 2 raised to the given power num. The library provides overloads of std::exp2 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)

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
 
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::cout << "exp2(4) = " << std::exp2(4) << '\n'
              << "exp2(0.5) = " << std::exp2(0.5) << '\n'
              << "exp2(-4) = " << std::exp2(-4) << '\n';
 
    // special values
    std::cout << "exp2(-0) = " << std::exp2(-0.0) << '\n'
              << "exp2(-Inf) = " << std::exp2(-INFINITY) << '\n';
 
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    const double inf = std::exp2(1024);
    const bool is_range_error = errno == ERANGE;
 
    std::cout << "exp2(1024) = " << inf << '\n';
    if (is_range_error)
        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
    if (std::fetestexcept(FE_OVERFLOW))
        std::cout << "    FE_OVERFLOW raised\n";
}

Possible output:

exp2(4) = 16
exp2(0.5) = 1.41421
exp2(-4) = 0.0625
exp2(-0) = 1
exp2(-Inf) = 0
exp2(1024) = inf
    errno == ERANGE: Numerical result out of range
    FE_OVERFLOW raised

[edit] See also

expexpfexpl (C++11)(C++11)	returns e raised to the given power (${\small e^x}$ $e 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]
ldexpldexpfldexpl (C++11)(C++11)	multiplies a number by 2 raised to an integral power (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]
C documentation for exp2

@@ Line 1: / Line 1: @@
-{{cpp/title|exp2}}
+{{cpp/title|exp2|exp2f|exp2l}}
 {{cpp/numeric/math/navbar}}
-{{ddcl list begin}}
+{{cpp/numeric/math/declarations
-{{ddcl list header | cmath}}
+|family=exp2
-{{ddcl list item | notes={{mark since c++11}} |
+|param1=num
-double      exp2( double n );
+|constexpr_since=26
+|desc=Computes 2 raised to the given power {{c|num}}.
 }}
-{{ddcl list item | notes={{mark since c++11}} |
-float       exp2( float n );
-}}
-{{ddcl list item | notes={{mark since c++11}} |
-long double exp2( long double n );
-}}
-{{ddcl list item | notes={{mark since c++11}} |
-double      exp2( Integral n );
-}}
-{{ddcl list end}}
-Computes 2 raised to the given power {{tt|n}}
 ===Parameters===
-{{param list begin}}
+{{par begin}}
-{{param list item | n | floating point value}}
+{{par|num|floating-point or integer value}}
-{{param list end}}
+{{par end}}
 ===Return value===
+If no errors occur, the base-''2'' exponential of {{c|num}} ({{math|2{{su|p=num}}}}) is returned.
-raised to the {{tt|n}} (i.e. {{tt|2<sup>n</sup>}})
+If a range error due to overflow occurs, {{lc|HUGE_VAL|+HUGE_VAL}}, {{tt|+HUGE_VALF}}, or {{tt|+HUGE_VALL}} is returned.
-If the result is too large for the underlying type, range error occurs and HUGE_VAL is returned.
+If a range error occurs due to underflow, the correct result (after rounding) is returned.
-===See also===
+===Error handling===
+Errors are reported as specified in {{lc|math_errhandling}}.
-{{dcl list begin}}
+If the implementation supports IEEE floating-point arithmetic (IEC 60559),
-{{dcl list template | cpp/numeric/math/dcl list exp}}
+* If the argument is ±0, 1 is returned.
-{{dcl list template | cpp/numeric/math/dcl list log2}}
+* If the argument is -∞, +0 is returned.
-{{dcl list template | cpp/numeric/math/dcl list log}}
+* If the argument is +∞, +∞ is returned.
-{{dcl list template | cpp/numeric/math/dcl list pow}}
+* If the argument is NaN, NaN is returned.
-{{dcl list end}}
+===Notes===
+{{cpp/numeric/math/additional integer overload note|exp2}}
+For integral exponents, it may be preferable to use {{lc|std::ldexp}}.
+===Example===
+{{example
+|code=
+#include <cerrno>
+#include <cfenv>
+#include <cmath>
+#include <cstring>
+#include <iostream>
+// #pragma STDC FENV_ACCESS ON
+int main()
+{
+    std::cout << "exp2(4) = " << std::exp2(4) << '\n'
+              << "exp2(0.5) = " << std::exp2(0.5) << '\n'
+              << "exp2(-4) = " << std::exp2(-4) << '\n';
+    // special values
+    std::cout << "exp2(-0) = " << std::exp2(-0.0) << '\n'
+              << "exp2(-Inf) = " << std::exp2(-INFINITY) << '\n';
+    // error handling
+    errno = 0;
+    std::feclearexcept(FE_ALL_EXCEPT);
+    const double inf = std::exp2(1024);
+    const bool is_range_error = errno == ERANGE;
+    std::cout << "exp2(1024) = " << inf << '\n';
+    if (is_range_error)
+        std::cout << "    errno == ERANGE: " << std::strerror(ERANGE) << '\n';
+    if (std::fetestexcept(FE_OVERFLOW))
+        std::cout << "    FE_OVERFLOW raised\n";
+}
+|p=true
+|output=
+exp2(4) = 16
+exp2(0.5) = 1.41421
+exp2(-4) = 0.0625
+exp2(-0) = 1
+exp2(-Inf) = 0
+exp2(1024) = inf
+    errno == ERANGE: Numerical result out of range
+    FE_OVERFLOW raised
+}}
+===See also===
+{{dsc begin}}
+{{dsc inc|cpp/numeric/math/dsc exp}}
+{{dsc inc|cpp/numeric/math/dsc expm1}}
+{{dsc inc|cpp/numeric/math/dsc ldexp}}
+{{dsc inc|cpp/numeric/math/dsc log2}}
+{{dsc see c|c/numeric/math/exp2}}
+{{dsc end}}
-[[de:cpp/numeric/math/exp2]]
+{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
-[[es:cpp/numeric/math/exp2]]
-[[fr:cpp/numeric/math/exp2]]
-[[it:cpp/numeric/math/exp2]]
-[[ja:cpp/numeric/math/exp2]]
-[[pt:cpp/numeric/math/exp2]]
-[[ru:cpp/numeric/math/exp2]]
-[[zh:cpp/numeric/math/exp2]]

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/exp2"

Latest revision as of 04:18, 18 May 2024

Contents

[edit] Parameters

[edit] Return value

[edit] Error handling

[edit] Notes

[edit] Example

[edit] See also

Navigation

Toolbox

expexpfexpl (C++11)(C++11)	returns e raised to the given power (\({\small e^x}\) $e 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]
ldexpldexpfldexpl (C++11)(C++11)	multiplies a number by 2 raised to an integral power (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]
C documentation for exp2