std::pow(std::valarray)
Depuis fr.cppreference.net
| Défini dans l'en-tête <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) | |
Élève une valeur à une puissance.
1) Calcule les valeurs de chaque élément du tableau numérique
base élevé à la puissance spécifiée par l'élément correspondant du tableau numérique exp.Le comportement est indéfini si base.size() != exp.size().
2) Calcule les valeurs de chaque élément du tableau numérique
base élevé à la puissance vexp.3) Calcule les valeurs de
vbase élevé à la puissance définie par les éléments du tableau numérique exp.Paramètres
| base | - | tableau numérique contenant les valeurs de la base |
| exp | - | tableau numérique contenant les valeurs de l'exposant |
| vbase | - | une valeur définissant la base |
| vexp | - | une valeur définissant l'exposant |
Valeur de retour
Un tableau numérique contenant les résultats de l'exponentiation.
Notes
Une fonction non qualifiée (pow) est utilisée pour effectuer le calcul. Si une telle fonction n'est pas disponible, std::pow est utilisé en raison de la recherche dépendante des arguments.
La fonction peut être implémentée avec un type de retour différent de std::valarray. Dans ce cas, le type de remplacement possède les propriétés suivantes :
- Toutes les
constfonctions membres de std::valarray sont fournies. - std::valarray, std::slice_array, std::gslice_array, std::mask_array et std::indirect_array peuvent être construits à partir du type de remplacement.
- Pour toute fonction prenant un
const std::valarray<T>&sauf begin() et end()(depuis C++11), des fonctions identiques prenant les types de remplacement doivent être ajoutées ; - Pour toute fonction prenant deux
const std::valarray<T>&arguments, des fonctions identiques prenant chaque combinaison deconst std::valarray<T>&et des types de remplacement doivent être ajoutées. - Le type de retour n'ajoute pas plus de deux niveaux d'imbrication de template par rapport au type d'argument le plus profondément imbriqué.
Exemple
Exécuter ce code
#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.exposants.size()) os << sup[r.exposants[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}; }
Sortie :
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
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | S'applique à | Comportement publié | Comportement corrigé |
|---|---|---|---|
| LWG 3074 | C++98 |
T
est déduit à la fois du scalaire et du
valarray
pour
(2,3)
, empêchant les appels de types mixtes
|
déduire uniquement
T
à partir du
valarray
|
Voir aussi
|
applique la fonction
std::sqrt
à chaque élément du valarray
(modèle de fonction) |
|
|
(C++11)
(C++11)
|
élève un nombre à la puissance donnée (
x
y
)
(fonction) |
|
puissance complexe, un ou les deux arguments peuvent être un nombre complexe
(modèle de fonction) |