Defined in header <valarray> | ||
---|---|---|
template< class T > std::valarray<T> pow( const std::valarray<T>& base, const std::valarray<T>& exp ); | (1) | |
template< class T > std::valarray<T> pow( const std::valarray<T>& base, const typename std::valarray<T>::value_type& vexp ); | (2) | |
template< class T > std::valarray<T> pow( const typename std::valarray<T>::value_type& vbase, const std::valarray<T>& exp ); | (3) |
Raises a value to a power.
base
raised to the power specified by the corresponding element from the numeric array exp
.The behavior is undefined if base.size() != exp.size()
.
base
raised to the power vexp
.vbase
raised to the power defined by the elements in the numeric array exp
.base | - | numeric array containing the values of the base |
exp | - | numeric array containing the values of the exponent |
vbase | - | a value defining the base |
vexp | - | a value defining the exponent |
A numeric array containing the results of exponentiation.
Unqualified function (pow
) is used to perform the computation. If such function is not available, std::pow
is used due to argument-dependent lookup.
The function can be implemented with the return type different from std::valarray
. In this case, the replacement type has the following properties:
std::valarray
are provided. std::valarray
, std::slice_array
, std::gslice_array
, std::mask_array
and std::indirect_array
can be constructed from the replacement type. begin()
and end()
(since C++11) should also accept the replacement type. #include <cmath> #include <cstddef> #include <iomanip> #include <iostream> #include <valarray> class show { friend std::ostream& operator<< (std::ostream& os, show const& r) { constexpr char const* sup[] { "\u2070", "\u00B9", "\u00B2", "\u00B3", "\u2074", "\u2075", "\u2076", "\u2077", "\u2078", "\u2079", }; for (std::size_t n = 0; n != r.bases.size(); ++n) { os << std::left << r.bases[n] << std::left; if (n < r.exponents.size()) os << sup[r.exponents[n] % 10] << " "; else os << " "; } if (r.results.size() != 0) { os << "="; for (std::size_t n = 0; n != r.results.size(); ++n) os << " " << r.results[n]; } return os << '\n'; } public: std::valarray<int> bases{}, exponents{}, results{}; }; int main() { constexpr int base { 2 }; constexpr int exponent { 5 }; const std::valarray<int> bases { 1, 2, 3, 4, 5, 6, 7 }; const std::valarray<int> exponents { 0, 1, 2, 3, 4, 5, 6 }; const std::valarray<int> powers1 = std::pow(bases, exponents); const std::valarray<int> powers2 = std::pow(bases, exponent); const std::valarray<int> powers3 = std::pow(base, exponents); std::cout << "pow( const std::valarray<T>& base, const std::valarray<T>& exp ); (1)\n" << "base : " << show{bases} << "exp : " << show{exponents} << "pow : " << show{bases, exponents, powers1} << '\n' << "pow( const std::valarray<T>& base, const value_type& vexp ); (2)\n" << "base : " << show{bases} << "vexp : " << exponent << '\n' << "pow : " << show{bases, std::valarray<int>(exponent, bases.size()), powers2} << '\n' << "pow( const value_type& vbase, const std::valarray<T>& exp ); (3)\n" << "vbase: " << base << '\n' << "exp : " << show{exponents} << "pow : " << show{std::valarray<int>(base, bases.size()), exponents, powers3}; }
Output:
pow( const std::valarray<T>& base, const std::valarray<T>& exp ); (1) base : 1 2 3 4 5 6 7 exp : 0 1 2 3 4 5 6 pow : 1⁰ 2¹ 3² 4³ 5⁴ 6⁵ 7⁶ = 1 2 9 64 625 7776 117649 pow( const std::valarray<T>& base, const value_type& vexp ); (2) base : 1 2 3 4 5 6 7 vexp : 5 pow : 1⁵ 2⁵ 3⁵ 4⁵ 5⁵ 6⁵ 7⁵ = 1 32 243 1024 3125 7776 16807 pow( const value_type& vbase, const std::valarray<T>& exp ); (3) vbase: 2 exp : 0 1 2 3 4 5 6 pow : 2⁰ 2¹ 2² 2³ 2⁴ 2⁵ 2⁶ = 1 2 4 8 16 32 64
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 3074 | C++98 | T is deduced from both the scalar and the valarray for (2-3), disallowing mixed-type calls | only deduce T from the valarray |
applies the function std::sqrt to each element of valarray (function template) |
|
(C++11)(C++11) | raises a number to the given power (\(\small{x^y}\)xy) (function) |
complex power, one or both arguments may be a complex number (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/numeric/valarray/pow