std::hypot, std::hypotf, std::hypotl - cppreference.com

1-3) Calcula la raíz cuadrada de la suma de los cuadrados de x e y, sin desbordamiento ni subdesbordamiento indebidos en las etapas intermedias del cálculo.

4) Un conjunto de sobrecargas o una plantilla de función para todas las combinaciones de argumentos de tipo aritmético no cubiertas por (1-3). Si algún argumento tiene tipo entero, se convierte a double. Si cualquier otro argumento es long double, entonces el tipo de retorno es long double, de lo contrario es double.

5-7) Calcula la raíz cuadrada de la suma de los cuadrados de x, y, y z, sin desbordamiento ni subdesbordamiento indebidos en las etapas intermedias del cálculo.

8) Un conjunto de sobrecargas o una plantilla de función para todas las combinaciones de argumentos de tipo aritmético no cubiertas por (5-7). Si algún argumento tiene tipo entero, se convierte a double. Si cualquier otro argumento es long double, entonces el tipo de retorno es long double, de lo contrario es double.

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 e y, o la distancia del punto (x,y) desde el origen (0,0), o la magnitud de un número complejo x+iy.

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).

Parámetros

Valor de retorno

1-4) Si no se producen errores, se devuelve la hipotenusa de un triángulo rectángulo, √x2
+y2
.

5-8) Si no se producen errores, se devuelve la distancia del origen en un espacio en tridimensional, √x2
+y2
+z2
.

Si se produce un error de rango debido a desbordamiento, se devuelve HUGE_VAL, +HUGE_VALF, o +HUGE_VALL.

Si se produce un error de rango debido a desbordamiento, se devuelve el resultado correcto (después del redondeo).

Manejo de errores

Los errores se informan como se especifica en math_errhandling.

Si la implementación admite la aritmética de punto flotante IEEE (IEC 60559):

• hypot(x, y), hypot(y, x), y hypot(x, -y) son equivalentes.
• Si uno de los argumentos es +0 o -0, hypot(x,y) es equivalente a fabs llamada con el argumento distinto de cero.
• Si uno de los argumentos es +∞ o -∞, hypot(x,y) devuelve +∞ incluso si el otro argumento es NaN.
• De lo contrario, si cualquiera de los argumentos es NaN, se devuelve NaN.

Notas

Las implementaciones generalmente garantizan una precisión de menos de 1 ulp (unidades en el último lugar): GNU, BSD.

std::hypot(x, y) es equivalente a std::abs(std::complex<double>(x,y)).

POSIX especifica que el subdesbordamiento solo se puede producir cuando ambos argumentos son subnormales y el resultado correcto también es subnormal (esto prohíbe implementaciones ingenuas).

Ejemplo

#include <iostream>
#include <cmath>
#include <cerrno>
#include <cfenv>
#include <cfloat>
#include <cstring>

// #pragma STDC FENV_ACCESS ON
int main()
{
    // uso típico
    std::cout << "(1,1) cartesiano es (" << std::hypot(1,1)
              << ',' << std::atan2(1,1) << ") polar\n";
    struct Point3D { float x, y, z; } a{3.14,2.71,9.87}, b{1.14,5.71,3.87};
    // C++17 tiene la sobrecarga de hypot con tres 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 << "    Se generó FE_OVERFLOW\n";
}

(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
    Se generó FE_OVERFLOW

Véase también