Namespaces
Variants

std:: sqrt, std:: sqrtf, std:: sqrtl

From cppreference.net
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definido en el encabezado <cmath>
(1)
float sqrt ( float num ) ;

double sqrt ( double num ) ;

long double sqrt ( long double num ) ;
(hasta C++23)
/*floating-point-type*/
sqrt ( /*floating-point-type*/ num ) ;
(desde C++23)
(constexpr desde C++26)
float sqrtf ( float num ) ;
(2) (desde C++11)
(constexpr desde C++26)
long double sqrtl ( long double num ) ;
(3) (desde C++11)
(constexpr desde C++26)
Sobrecarga SIMD (desde C++26)
Definido en el encabezado <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

sqrt ( const V & v_num ) ;
(S) (desde C++26)
Definido en el encabezado <cmath>
template < class Integer >
double sqrt ( Integer num ) ;
(A) (constexpr desde C++26)
1-3) Calcula la raíz cuadrada de num . La biblioteca proporciona sobrecargas de std::sqrt para todos los tipos de punto flotante sin calificación cv como el tipo del parámetro. (since C++23)
S) La sobrecarga SIMD realiza un std::sqrt elemento por elemento en v_num .
(Ver math-floating-point y deduced-simd-t para sus definiciones.)
(desde C++26)
A) Se proporcionan sobrecargas adicionales para todos los tipos enteros, los cuales son tratados como double .
(since C++11)

Contenidos

Parámetros

num - valor de punto flotante o entero

Valor de retorno

Si no ocurren errores, se devuelve la raíz cuadrada de num ( num ).

Si ocurre un error de dominio, se devuelve un valor definido por la implementación (NaN donde esté soportado).

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 .

Error de dominio ocurre si num es menor que cero.

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

  • Si el argumento es menor que -0, FE_INVALID se activa y se retorna NaN.
  • Si el argumento es +∞ o ±0, se retorna sin modificación.
  • Si el argumento es NaN, se retorna NaN.

Notas

std::sqrt es requerido por el estándar IEEE para ser redondeado correctamente a partir del resultado infinitamente preciso. En particular, se produce el resultado exacto si puede ser representado en el tipo de punto flotante. Las únicas otras operaciones que requieren esto son los operadores aritméticos y la función std::fma . Otras funciones, incluyendo std::pow , no están tan restringidas.

Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su argumento num de tipo entero, std :: sqrt ( num ) tenga el mismo efecto que std :: sqrt ( static_cast < double > ( num ) ) .

Ejemplo

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    // uso normal
    std::cout << "sqrt(100) = " << std::sqrt(100) << '\n'
              << "sqrt(2) = " << std::sqrt(2) << '\n'
              << "golden ratio = " << (1 + std::sqrt(5)) / 2 << '\n';
    // valores especiales
    std::cout << "sqrt(-0) = " << std::sqrt(-0.0) << '\n';
    // manejo de errores
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "sqrt(-1.0) = " << std::sqrt(-1) << '\n';
    if (errno == EDOM)
        std::cout << "    errno = EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
}

Salida posible:

sqrt(100) = 10
sqrt(2) = 1.41421
golden ratio = 1.61803
sqrt(-0) = -0
sqrt(-1.0) = -nan
    errno = EDOM Numerical argument out of domain
    FE_INVALID raised

Véase también

(C++11) (C++11)
eleva un número a la potencia dada ( x y )
(función)
(C++11) (C++11) (C++11)
calcula la raíz cúbica ( 3 x )
(función)
(C++11) (C++11) (C++11)
calcula la hipotenusa x 2
+y 2
y x 2
+y 2
+z 2
(desde C++17)

(función)
raíz cuadrada compleja en el rango del semiplano derecho
(plantilla de función)
aplica la función std::sqrt a cada elemento del valarray
(plantilla de función)