std::pow(std::valarray)

来自cppreference.com
 
C++
 
数值库
 
std::valarray
成员函数
非成员函数
辅助类
推导指引 (C++17)
 
<tbody> </tbody>
在标头 <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)
See More

计算值的幂。

1) 计算数值数组 base 中各元素的幂，指数由来自数值数组 exp 的对应元素指定。

若 base.size() != exp.size() 则行为未定义。

2) 计算数值数组 base 中每个元素的 vexp 次幂。
3) 计算 vbase 的各值以数值数组 exp 中的元素定义次数的幂。

参数

base - 含底数值的数值数组
exp - 含指数值的数值数组
vbase - 定义底数的值
vexp - 定义指数的值

返回值

含有指数结果的数值数组。

注解

用无限定函数 (pow) 进行计算。若该函数不可用，则会由于实参依赖查找而使用 std::pow。

函数可以实现为拥有不同于 std::valarray 的返回类型。此时替换它的类型拥有下列属性：

  • 提供 std::valarray 的所有 const 成员函数。
  • 能从替换类型构造 std::valarray、std::slice_array、std::gslice_array、std::mask_array 和 std::indirect_array。
  • 所有接受一个 const std::valarray& 类型参数的函数 ，除了 begin() 和 end()(C++11 起)也应该接受替换类型。
  • 所有接受两个 const std::valarray& 类型参数的函数都应该接受 const std::valarray& 和替换类型的每种组合。
  • 返回类型添加不多于两层嵌套在最深层嵌套的参数类型上的模板。

示例

运行此代码
#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};
}

输出： 

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

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告 应用于 出版时的行为 正确行为
LWG 3074 C++98 (2-3) 从标量和 valarray 两者推导 T，禁止混合类型的调用 仅从 valarray 推导 T

参阅

 应用函数 std::sqrt 到 valarray 的每个元素
(函数模板) [编辑]
(C++11)(C++11)
 求某数的给定次幂（xy）
(函数) [编辑]
复数幂，一或两个实参可为复数
(函数模板) [编辑]