Difference between revisions of "cpp/numeric/complex/pow"
From cppreference.com
m (Version fix.) |
m (Minor fix.) |
||
| Line 16: | Line 16: | ||
}} | }} | ||
{{dcl h|[[#Notes|Additional overloads]] {{mark since c++11}}}} | {{dcl h|[[#Notes|Additional overloads]] {{mark since c++11}}}} | ||
| + | {{dcl header|complex}} | ||
{{dcl rev multi|num=A|dcl1= | {{dcl rev multi|num=A|dcl1= | ||
template< class T1, class T2 > | template< class T1, class T2 > | ||
Revision as of 22:27, 12 March 2023
| Defined in header <complex>
|
||
| template< class T > std::complex<T> pow( const std::complex<T>& x, const std::complex<T>& y ); |
(1) | |
| template< class T > std::complex<T> pow( const std::complex<T>& x, const T& y ); |
(2) | |
| template< class T > std::complex<T> pow( const T& x, const std::complex<T>& y ); |
(3) | |
| Additional overloads (since C++11) |
||
| Defined in header <complex>
|
||
| (A) | ||
template< class T1, class T2 > std::complex</* common-type */> |
(until C++23) | |
| template< class T1, class T2 > std::complex<std::common_type_t<T1, T2>> |
(since C++23) | |
| (B) | ||
template< class T, class NonComplex > std::complex</* common-type */> |
(until C++23) | |
| template< class T, class NonComplex > std::complex<std::common_type_t<T, NonComplex>> |
(since C++23) | |
| (C) | ||
template< class T, class NonComplex > std::complex</* common-type */> |
(until C++23) | |
| template< class T, class NonComplex > std::complex<std::common_type_t<T, NonComplex>> |
(since C++23) | |
1-3) Computes complex x raised to a complex power y with a branch cut along the negative real axis for the first argument.
|
A-C) Additional overloads are provided. base and exponent are treated as complex numbers with positive zero imaginary component.
|
(since C++11) |
Contents |
Parameters
| x | - | base as a complex value |
| y | - | exponent as a complex value |
| base | - | base as a non-complex value |
| exponent | - | exponent as a non-complex value |
Return value
1-3,A) If no errors occur, the complex power xy, is returned.
Errors and special cases are handled as if the operation is implemented by std::exp(y * std::log(x)).
The result of std::pow(0, 0) is implementation-defined.
B) Same as (1-3,A), except that y is replaced with exponent.
C) Same as (1-3,A), except that x is replaced with base.
Notes
The additional overloads are not required to be provided exactly as (A-C). They only need to be sufficient to ensure that for their first argument base and second argument exponent:
|
If base and/or exponent has type std::complex<T>:
|
(until C++23) |
|
If one argument has type std::complex<T1> and the other argument has type If std::common_type_t<T1, T2> is not well-formed, then the program is ill-formed. |
(since C++23) |
Example
Run this code
#include <iostream> #include <complex> int main() { std::cout << std::fixed; std::complex<double> z(1, 2); std::cout << "(1,2)^2 = " << std::pow(z, 2) << '\n'; std::complex<double> z2(-1, 0); // square root of -1 std::cout << "-1^0.5 = " << std::pow(z2, 0.5) << '\n'; std::complex<double> z3(-1, -0.0); // other side of the cut std::cout << "(-1,-0)^0.5 = " << std::pow(z3, 0.5) << '\n'; std::complex<double> i(0, 1); // i^i = exp(-pi/2) std::cout << "i^i = " << std::pow(i, i) << '\n'; }
Output:
(1,2)^2 = (-3.000000,4.000000) -1^0.5 = (0.000000,1.000000) (-1,-0)^0.5 = (0.000000,-1.000000) i^i = (0.207880,0.000000)
See also
| complex square root in the range of the right half-plane (function template) | |
| (C++11)(C++11) |
raises a number to the given power (xy) (function) |
| applies the function std::pow to two valarrays or a valarray and a value (function template) | |
| C documentation for cpow
| |
