std:: hypot, std:: hypotf, std:: hypotl
|
Definido en el encabezado
<cmath>
|
||
| (1) | ||
|
float
hypot
(
float
x,
float
y
)
;
double
hypot
(
double
x,
double
y
)
;
|
(desde C++11)
(hasta C++23) |
|
|
/*floating-point-type*/
hypot
(
/*floating-point-type*/
x,
|
(desde C++23)
(constexpr desde C++26) |
|
|
float
hypotf
(
float
x,
float
y
)
;
|
(2) |
(desde C++11)
(constexpr desde C++26) |
|
long
double
hypotl
(
long
double
x,
long
double
y
)
;
|
(3) |
(desde C++11)
(constexpr desde C++26) |
| (4) | ||
|
float
hypot
(
float
x,
float
y,
float
z
)
;
double
hypot
(
double
x,
double
y,
double
z
)
;
|
(desde C++17)
(hasta C++23) |
|
|
/*floating-point-type*/
hypot
(
/*floating-point-type*/
x,
|
(desde C++23)
(constexpr desde C++26) |
|
|
Definido en el encabezado
<cmath>
|
||
|
template
<
class
Arithmetic1, Arithmetic2
>
/*common-floating-point-type*/
|
(A) |
(desde C++11)
(constexpr desde C++26) |
|
template
<
class
Arithmetic1, Arithmetic2, Arithmetic3
>
/*common-floating-point-type*/
|
(B) | (desde C++17) |
std::hypot
para todos los tipos de punto flotante sin calificación cv como tipo de los parámetros
x
y
y
.
(desde C++23)
std::hypot
para todos los tipos de punto flotante sin calificación cv como tipo de los parámetros
x
,
y
y
z
.
(since C++23)
El valor calculado por la versión de dos argumentos de esta función es la longitud de la hipotenusa de un triángulo rectángulo con lados de longitud
x
y
y
, o la distancia del punto
(x,y)
desde el origen
(0,0)
, o la magnitud de un número complejo
x+
i
y
.
El valor calculado por la versión de tres argumentos de esta función es la distancia del punto
(x,y,z)
desde el origen
(0,0,0)
.
Contenidos |
Parámetros
| x, y, z | - | valores de punto flotante o enteros |
Valor de retorno
+y 2
.
+y 2
+z 2
.
Si ocurre un error de rango debido a desbordamiento,
+HUGE_VAL
,
+HUGE_VALF
, o
+HUGE_VALL
es devuelto.
Si ocurre un error de rango debido a desbordamiento inferior, se devuelve el resultado correcto (después del redondeo).
Manejo de errores
Los errores se reportan como se especifica en math_errhandling .
Si la implementación soporta aritmética de punto flotante IEEE (IEC 60559),
- std :: hypot ( x, y ) , std :: hypot ( y, x ) , y std :: hypot ( x, - y ) son equivalentes.
- si uno de los argumentos es ±0, std :: hypot ( x, y ) es equivalente a std::fabs llamado con el argumento no cero.
- si uno de los argumentos es ±∞, std :: hypot ( x, y ) devuelve +∞ incluso si el otro argumento es NaN.
- en caso contrario, si alguno de los argumentos es NaN, se devuelve NaN.
Notas
Las implementaciones suelen garantizar una precisión de menos de 1 ulp (Unit in the Last Place — Unidad de Mínima Precisión): GNU , BSD .
std :: hypot ( x, y ) es equivalente a std :: abs ( std:: complex < double > ( x, y ) ) .
POSIX especifica que el desbordamiento por cero (underflow) solo puede ocurrir cuando ambos argumentos son subnormales y el resultado correcto también es subnormal (esto prohíbe implementaciones ingenuas).
|
La distancia entre dos puntos
|
(since C++17) |
Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A,B) . Solo necesitan ser suficientes para garantizar que para su primer argumento num1 , segundo argumento num2 y el tercer argumento opcional num3 :
|
(hasta C++23) |
|
Si num1 , num2 y num3 tienen tipos aritméticos, entonces
donde /*common-floating-point-type*/ es el tipo de punto flotante con el mayor rango de conversión de punto flotante y mayor subrango de conversión de punto flotante entre los tipos de num1 , num2 y num3 , los argumentos de tipo entero se consideran con el mismo rango de conversión de punto flotante que double . Si no existe tal tipo de punto flotante con el mayor rango y subrango, entonces la resolución de sobrecarga no resulta en un candidato utilizable de las sobrecargas proporcionadas. |
(desde C++23) |
| Macro de prueba de características | Valor | Std | Característica |
|---|---|---|---|
__cpp_lib_hypot
|
201603L
|
(C++17) |
Sobrecarga de 3 argumentos de
std::hypot
(4,B)
|
Ejemplo
#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() { // uso típico std::cout << "(1,1) cartesiano es (" << std::hypot(1, 1) << ',' << std::atan2(1,1) << ") polar\n"; Point3D a{3.14, 2.71, 9.87}, b{1.14, 5.71, 3.87}; // C++17 tiene sobrecarga de hypot con 3 argumentos: std::cout << "distancia(a,b) = " << std::hypot(a.x - b.x, a.y - b.y, a.z - b.z) << '\n'; // valores especiales std::cout << "hypot(NAN,INFINITY) = " << std::hypot(NAN, INFINITY) << '\n'; // manejo de errores 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 generada\n"; }
Salida:
(1,1) cartesiano es (1.41421,0.785398) polar
distancia(a,b) = 7
hypot(NAN,INFINITY) = inf
hypot(DBL_MAX,DBL_MAX) = inf
errno = ERANGE Resultado numérico fuera de rango
FE_OVERFLOW generada
Véase también
|
(C++11)
(C++11)
|
eleva un número a la potencia dada (
x
y
)
(función) |
|
(C++11)
(C++11)
|
calcula la raíz cuadrada (
√
x
)
(función) |
|
(C++11)
(C++11)
(C++11)
|
calcula la raíz cúbica (
3
√
x
)
(función) |
|
devuelve la magnitud de un número complejo
(plantilla de función) |
|
|
Documentación C
para
hypot
|
|