Namespaces
Variants

    std::pow(std::valarray)

    Von de.cppreference.net
     
    C++
     
    Numerikbibliothek
     
    std::valarray
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Hilfsklassen
    Deduktionsleitfäden (C++17)
     
    Definiert 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)

    Hebt einen Wert zur Potenz.

    1) Berechnet die Werte jedes Elements im numerischen Array base potenziert mit dem durch das entsprechende Element aus dem numerischen Array exp angegebenen Exponenten.

    Das Verhalten ist undefiniert, wenn base.size() != exp.size().

    2) Berechnet die Werte jedes Elements im numerischen Array base potenziert mit vexp.
    3) Berechnet die Werte von vbase potenziert mit dem durch die Elemente im numerischen Array exp angegebenen Exponenten.

    Parameter

    base - numerisches Array mit den Werten der Basis
    exp - numerisches Array mit den Werten des Exponenten
    vbase - ein Wert, der die Basis definiert
    vexp - ein Wert, der den Exponenten definiert

    Rückgabewert

    Ein numerisches Array, das die Ergebnisse der Potenzierung enthält.

    Anmerkungen

    Die unqualifizierte Funktion (pow) wird verwendet, um die Berechnung durchzuführen. Wenn eine solche Funktion nicht verfügbar ist, wird std::pow aufgrund von argumentabhängiger Suche verwendet.

    Die Funktion kann mit einem Rückgabetyp implementiert werden, der sich von std::valarray unterscheidet. In diesem Fall hat der Ersatztyp die folgenden Eigenschaften:

    • Alle const Mitgliedsfunktionen von std::valarray werden bereitgestellt.
    • std::valarray, std::slice_array, std::gslice_array, std::mask_array und std::indirect_array können aus dem Ersatztyp konstruiert werden.
    • Für jede Funktion, die ein const std::valarray<T>& außer begin() und end()(seit C++11) nimmt, müssen identische Funktionen, die die Ersatztypen nehmen, hinzugefügt werden;
    • Für jede Funktion, die zwei const std::valarray<T>& Argumente nimmt, müssen identische Funktionen, die jede Kombination von const std::valarray<T>& und Ersatztypen nehmen, hinzugefügt werden.
    • Der Rückgabetyp fügt nicht mehr als zwei Ebenen von Templateschachtelung über dem am tiefsten verschachtelten Argumenttyp hinzu.

    Beispiel

    Diesen Code ausführen 
    #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.Basisklassen.size(); ++n)
        {
            os << std::left << r.Basisklassen[n] << std::left;
            if (n < r.Exponenten.size())
                os << sup[r.Exponenten[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"
        << "Basis : " << show{bases}
        << "exp  : " << show{exponents}
        << "pow  : " << show{bases, exponents, powers1}
        << '\n'
        << "pow(const std::valarray<T>& base, const value_type& vexp); (2)\n"
        << "Basis : " << 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};
}

    Ausgabe: 

    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

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 3074 C++98 T wird sowohl vom Skalar als auch vom valarray für (2,3) abgeleitet, was gemischte Typaufrufe verhindert leite T nur vom valarray ab

    Siehe auch

    		wendet die Funktion std::sqrt auf jedes Element des valarray an
    (Funktions-Template)
    (C++11) (C++11)
    		potenziert eine Zahl mit dem gegebenen Exponenten ( x y )
    (Funktion)
    		komplexe Potenz, ein oder beide Argumente können komplexe Zahlen sein
    (Funktions-Template)