std::pow(std::valarray)

Определён в заголовочном файле <valarray>

Определён в заголовочном файле `<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)

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)

Возводит значение в степень.

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.
Для каждой функции, принимающей conststd::valarray<T>& за исключением begin() и end()(начиная с C++11), должны быть добавлены идентичные функции, принимающие замещающие типы;
Для каждой функции, принимающей два аргумента типа conststd::valarray<T>&, должны быть добавлены идентичные функции, принимающие каждую комбинацию типов conststd::valarray<T>& и замещающих типов.
Тип возвращаемого значения не должен добавлять более двух уровней вложенности шаблонов относительно типа самого глубоко вложенного аргумента.

Пример

#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	`T` выводится и из скалярного значения, и из `valarray` для (2,3), что запрещает вызовы со смешанными типами	выводить `T` только из `valarray`

См. также

sqrt(std::valarray)	применяет функцию `std::sqrt` к каждому элементу valarray (шаблон функции)
powpowfpowl (C++11)(C++11)	возводит число в заданную степень (\(\small{x^y}\)x^y) (функция)
pow(std::complex)	комплексная степень; один или оба аргумента могут быть комплексными числами (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/numeric/valarray/pow