std:: pow, std:: powf, std:: powl

From cppreference.net

Défini dans l'en-tête `<cmath>`
	(1)
float pow ( float base, float exp ) ; double pow ( double base, double exp ) ; long double pow ( long double base, long double exp ) ;			(jusqu'à C++23)
/* floating-point-type / pow ( / floating-point-type / base, / floating-point-type */ exp )			(depuis C++23) (constexpr depuis C++26)
float pow ( float base, int exp ) ; double pow ( double base, int exp ) ; long double pow ( long double base, int exp ) ;		(2)	(jusqu'à C++11)
float powf ( float base, float exp ) ;		(3)	(depuis C++11) (constexpr depuis C++26)
long double powl ( long double base, long double exp ) ;		(4)	(depuis C++11) (constexpr depuis C++26)
Surcharges supplémentaires (depuis C++11)
Défini dans l'en-tête `<cmath>`
template < class Arithmetic1, class Arithmetic2 > /* common-floating-point-type */ pow ( Arithmetic1 base, Arithmetic2 exp ) ;		(A)	(constexpr depuis C++26)

1-4) Calcule la valeur de base élevée à la puissance exp . La bibliothèque fournit des surcharges de


          std::pow

pour tous les types à virgule flottante non qualifiés cv comme type des paramètres base et exp . (depuis C++23)

A) Des surcharges supplémentaires sont fournies pour toutes les autres combinaisons de types arithmétiques.

(depuis C++11)

Table des matières

Paramètres

base	-	base sous forme de valeur à virgule flottante ou entière
exp	-	exposant sous forme de valeur à virgule flottante ou entière

Valeur de retour

Si aucune erreur ne se produit, base élevé à la puissance exp ( $base exp$ ), est retourné.

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée (NaN là où supporté).

Si une erreur de pôle ou une erreur de plage due à un dépassement de capacité se produit, ±HUGE_VAL , ±HUGE_VALF , ou ±HUGE_VALL est renvoyé.

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct (après arrondi) est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si base est fini et négatif et exp est fini et non entier, une erreur de domaine se produit et une erreur de plage peut survenir.

Si base est zéro et exp est zéro, une erreur de domaine peut survenir.

Si base est zéro et exp est négatif, une erreur de domaine ou une erreur de pôle peut survenir.

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

pow ( + 0 , exp ) , où exp est un entier impair négatif, retourne +∞ et lève FE_DIVBYZERO .
pow ( - 0 , exp ) , où exp est un entier impair négatif, retourne -∞ et lève FE_DIVBYZERO .
pow ( ± 0 , exp ) , où exp est négatif, fini, et est un entier pair ou un non-entier, retourne +∞ et lève FE_DIVBYZERO .
pow ( ± 0 , - ∞ ) retourne +∞ et peut lever FE_DIVBYZERO .
pow ( + 0 , exp ) , où exp est un entier impair positif, retourne +0.
pow ( - 0 , exp ) , où exp est un entier impair positif, retourne -0.
pow ( ± 0 , exp ) , où exp est non-entier positif ou un entier pair positif, retourne +0.
pow ( - 1 , ±∞ ) retourne 1.
pow ( + 1 , exp ) retourne 1 pour tout exp , même lorsque exp est NaN.
pow ( base, ± 0 ) retourne 1 pour toute base , même lorsque base est NaN.
pow ( base, exp ) retourne NaN et lève FE_INVALID si base est finie et négative et exp est fini et non-entier.
pow ( base, - ∞ ) retourne +∞ pour tout |base| < 1 .
pow ( base, - ∞ ) retourne +0 pour tout |base| > 1 .
pow ( base, + ∞ ) retourne +0 pour tout |base| < 1 .
pow ( base, + ∞ ) retourne +∞ pour tout |base| > 1 .
pow ( - ∞, exp ) retourne -0 si exp est un entier impair négatif.
pow ( - ∞, exp ) retourne +0 si exp est un non-entier négatif ou un entier pair négatif.
pow ( - ∞, exp ) retourne -∞ si exp est un entier impair positif.
pow ( - ∞, exp ) retourne +∞ si exp est un non-entier positif ou un entier pair positif.
pow ( + ∞, exp ) retourne +0 pour tout exp négatif.
pow ( + ∞, exp ) retourne +∞ pour tout exp positif.
sauf indication contraire ci-dessus, si un argument est NaN, NaN est retourné.

Notes

C++98 a ajouté des surcharges où exp a le type int en plus du C pow() , et le type de retour de std :: pow ( float , int ) était float . Cependant, les surcharges supplémentaires introduites en C++11 spécifient que std :: pow ( float , int ) doit retourner double . LWG issue 550 a été soulevée pour cibler ce conflit, et la résolution est de supprimer les surcharges supplémentaires avec int exp .

Bien que std::pow ne puisse pas être utilisé pour obtenir une racine d'un nombre négatif, std::cbrt est fourni pour le cas courant où exp est 1/3.

Les surcharges supplémentaires ne sont pas tenues d'être fournies exactement comme (A) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 et second argument num2 :

Si num1 ou num2 a le type long double , alors std :: pow ( num1, num2 ) a le même effet que std :: pow ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ) .
Sinon, si num1 et/ou num2 a le type double ou un type entier, alors std :: pow ( num1, num2 ) a le même effet que std :: pow ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ) .
Sinon, si num1 ou num2 a le type float , alors std :: pow ( num1, num2 ) a le même effet que std :: pow ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ) .

(jusqu'en C++23)

Si num1 et num2 ont des types arithmétiques, alors std :: pow ( num1, num2 ) a le même effet que std :: pow ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et la plus grande sous-catégorie de conversion en virgule flottante entre les types de num1 et num2 , les arguments de type entier sont considérés comme ayant le même rang de conversion en virgule flottante que double .

Si aucun tel type à virgule flottante avec le plus grand rang et la plus grande sous-catégorie n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies.

(depuis C++23)

Exemple

Exécuter ce code

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    // utilisation typique
    std::cout << "pow(2, 10) = " << std::pow(2, 10) << '\n'
              << "pow(2, 0.5) = " << std::pow(2, 0.5) << '\n'
              << "pow(-2, -3) = " << std::pow(-2, -3) << '\n';
    // valeurs spéciales
    std::cout << "pow(-1, NAN) = " << std::pow(-1, NAN) << '\n'
              << "pow(+1, NAN) = " << std::pow(+1, NAN) << '\n'
              << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
              << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';
    // gestion des erreurs
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-1, 1/3) = " << std::pow(-1, 1.0 / 3) << '\n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID levée\n";
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO levée\n";
}

Sortie possible :

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

Voir aussi

sqrt sqrtf sqrtl (C++11) (C++11)	calcule la racine carrée ( $\sqrt x$ ) (fonction)
cbrt cbrtf cbrtl (C++11) (C++11) (C++11)	calcule la racine cubique ( $3 \sqrt x$ ) (fonction)
hypot hypotf hypotl (C++11) (C++11) (C++11)	calcule l'hypoténuse $\sqrt x 2 +y 2$ et $\sqrt x 2 +y 2 +z 2$ (depuis C++17) (fonction)
pow (std::complex)	puissance complexe, un ou deux arguments peuvent être un nombre complexe (modèle de fonction)
pow (std::valarray)	applique la fonction std::pow à deux valarrays ou à un valarray et une valeur (modèle de fonction)
Documentation C pour pow

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants