std:: hypot, std:: hypotf, std:: hypotl
|
Défini dans l'en-tête
<cmath>
|
||
| (1) | ||
|
float
hypot
(
float
x,
float
y
)
;
double
hypot
(
double
x,
double
y
)
;
|
(depuis C++11)
(jusqu'à C++23) |
|
|
/*floating-point-type*/
hypot
(
/*floating-point-type*/
x,
|
(depuis C++23)
(constexpr depuis C++26) |
|
|
float
hypotf
(
float
x,
float
y
)
;
|
(2) |
(depuis C++11)
(constexpr depuis C++26) |
|
long
double
hypotl
(
long
double
x,
long
double
y
)
;
|
(3) |
(depuis C++11)
(constexpr depuis C++26) |
| (4) | ||
|
float
hypot
(
float
x,
float
y,
float
z
)
;
double
hypot
(
double
x,
double
y,
double
z
)
;
|
(depuis C++17)
(jusqu'à C++23) |
|
|
/*floating-point-type*/
hypot
(
/*floating-point-type*/
x,
|
(depuis C++23)
(constexpr depuis C++26) |
|
|
Défini dans l'en-tête
<cmath>
|
||
|
template
<
class
Arithmetic1, Arithmetic2
>
/*common-floating-point-type*/
|
(A) |
(depuis C++11)
(constexpr depuis C++26) |
|
template
<
class
Arithmetic1, Arithmetic2, Arithmetic3
>
/*common-floating-point-type*/
|
(B) | (depuis C++17) |
std::hypot
pour tous les types à virgule flottante non qualifiés cv comme type des paramètres
x
et
y
.
(depuis C++23)
std::hypot
pour tous les types à virgule flottante non qualifiés cv comme type des paramètres
x
,
y
et
z
.
(depuis C++23)
La valeur calculée par la version à deux arguments de cette fonction est la longueur de l'hypoténuse d'un triangle rectangle dont les côtés ont pour longueur
x
et
y
, ou la distance du point
(x,y)
par rapport à l'origine
(0,0)
, ou le module d'un nombre complexe
x+
i
y
.
La valeur calculée par la version à trois arguments de cette fonction est la distance du point
(x,y,z)
par rapport à l'origine
(0,0,0)
.
Table des matières |
Paramètres
| x, y, z | - | valeurs à virgule flottante ou entières |
Valeur de retour
+y 2
, est retournée.
+y 2
+z 2
, est retournée.
Si 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 due à un dépassement inférieur se produit, le résultat correct (après arrondi) est retourné.
Gestion des erreurs
Les erreurs sont signalées comme spécifié dans math_errhandling .
Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),
- std :: hypot ( x, y ) , std :: hypot ( y, x ) , et std :: hypot ( x, - y ) sont équivalents.
- si l'un des arguments est ±0, std :: hypot ( x, y ) est équivalent à std::fabs appelé avec l'argument non nul.
- si l'un des arguments est ±∞, std :: hypot ( x, y ) renvoie +∞ même si l'autre argument est NaN.
- sinon, si l'un des arguments est NaN, NaN est renvoyé.
Notes
Les implémentations garantissent généralement une précision inférieure à 1 ulp (Unité du Dernier Rang — Unité de Moindre Précision) : GNU , BSD .
std :: hypot ( x, y ) est équivalent à std :: abs ( std:: complex < double > ( x, y ) ) .
POSIX spécifie qu'un dépassement inférieur ne peut se produire que lorsque les deux arguments sont sous-normaux et que le résultat correct est également sous-normal (ceci interdit les implémentations naïves).
|
La distance entre deux points
|
(depuis C++17) |
Les surcharges supplémentaires ne sont pas requises d'être fournies exactement comme (A,B) . Elles doivent seulement être suffisantes pour garantir que pour leur premier argument num1 , deuxième argument num2 et le troisième argument optionnel num3 :
|
(jusqu'à C++23) |
|
Si num1 , num2 et num3 ont des types arithmétiques, alors
où /*common-floating-point-type*/ est le type à virgule flottante ayant le plus grand rang de conversion en virgule flottante et le plus grand sous-rang de conversion en virgule flottante parmi les types de num1 , num2 et num3 , 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 sous-rang n'existe, alors la résolution de surcharge ne résulte pas en un candidat utilisable parmi les surcharges fournies. |
(depuis C++23) |
| Macro de test de fonctionnalité | Valeur | Norme | Fonctionnalité |
|---|---|---|---|
__cpp_lib_hypot
|
201603L
|
(C++17) |
Surcharge à 3 arguments de
std::hypot
(4,B)
|
Exemple
#include <cerrno> #include <cfenv> #include <cfloat> #include <cmath> #include <cstring> #include <iostream> // #pragma STDC FENV_ACCESS ON struct Point3D { float x, y, z; }; int main() { // utilisation typique std::cout << "(1,1) cartésien correspond à (" << std::hypot(1, 1) << ',' << std::atan2(1,1) << ") polaire\n"; Point3D a{3.14, 2.71, 9.87}, b{1.14, 5.71, 3.87}; // C++17 possède une surcharge hypot à 3 arguments : std::cout << "distance(a,b) = " << std::hypot(a.x - b.x, a.y - b.y, a.z - b.z) << '\n'; // valeurs spéciales std::cout << "hypot(NAN,INFINITY) = " << std::hypot(NAN, INFINITY) << '\n'; // gestion des erreurs errno = 0; std::feclearexcept(FE_ALL_EXCEPT); std::cout << "hypot(DBL_MAX,DBL_MAX) = " << std::hypot(DBL_MAX, DBL_MAX) << '\n'; if (errno == ERANGE) std::cout << " errno = ERANGE " << std::strerror(errno) << '\n'; if (std::fetestexcept(FE_OVERFLOW)) std::cout << " FE_OVERFLOW déclenchée\n"; }
Sortie :
(1,1) cartésien correspond à (1.41421,0.785398) polaire
distance(a,b) = 7
hypot(NAN,INFINITY) = inf
hypot(DBL_MAX,DBL_MAX) = inf
errno = ERANGE Résultat numérique hors limites
FE_OVERFLOW déclenchée
Voir aussi
|
(C++11)
(C++11)
|
élève un nombre à la puissance donnée (
x
y
)
(fonction) |
|
(C++11)
(C++11)
|
calcule la racine carrée (
√
x
)
(fonction) |
|
(C++11)
(C++11)
(C++11)
|
calcule la racine cubique (
3
√
x
)
(fonction) |
|
retourne la magnitude d'un nombre complexe
(modèle de fonction) |
|
|
Documentation C
pour
hypot
|
|