Namespaces
Variants

std:: atan2, std:: atan2f, std:: atan2l

From cppreference.net
C++
Numerics library
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 atan2 ( float y, float x ) ;

double atan2 ( double y, double x ) ;

long double atan2 ( long double y, long double x ) ;
(hasta C++23)
/*floating-point-type*/

atan2 ( /*floating-point-type*/ y,

/*floating-point-type*/ x ) ;
(desde C++23)
(constexpr desde C++26)
float atan2f ( float y, float x ) ;
(2) (desde C++11)
(constexpr desde C++26)
long double atan2l ( long double y, long double x ) ;
(3) (desde C++11)
(constexpr desde C++26)
Sobrecarga SIMD (desde C++26)
Definido en el encabezado <simd>
template < class V0, class V1 >

constexpr /*math-common-simd-t*/ < V0, V1 >

atan2 ( const V0 & v_y, const V1 & v_x ) ;
(S) (desde C++26)
Definido en el encabezado <cmath>
template < class Integer >
double atan2 ( Integer y, Integer x ) ;
(A) (constexpr desde C++26)
1-3) Calcula el arcotangente de y / x utilizando los signos de los argumentos para determinar el cuadrante correcto. La biblioteca proporciona sobrecargas de std::atan2 para todos los tipos de punto flotante sin calificación cv como tipo de los parámetros. (since C++23)
S) La sobrecarga SIMD realiza un std::atan2 elemento por elemento sobre v_y y v_x .
(Ver math-common-simd-t para su definición.)
(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

y, x - valores de punto flotante o enteros

Valor de retorno

If no errors occur, the arc tangent of y / x ( arctan(
y
x
) ) in the range [-π, +π] radians, is returned.
y argumento
Valor de retorno
math-atan2.png
x argumento

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 .

Puede ocurrir un error de dominio si x y y son ambos cero.

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

  • Si x e y son ambos cero, el error de dominio no ocurre.
  • Si x e y son ambos cero, el error de rango tampoco ocurre.
  • Si y es cero, el error de polo no ocurre.
  • Si y es ±0 y x es negativo o -0, se devuelve ±π.
  • Si y es ±0 y x es positivo o +0, se devuelve ±0.
  • Si y es ±∞ y x es finito, se devuelve ±π/2.
  • Si y es ±∞ y x es -∞, se devuelve ±3π/4.
  • Si y es ±∞ y x es +∞, se devuelve ±π/4.
  • Si x es ±0 y y es negativo, se devuelve -π/2.
  • Si x es ±0 y y es positivo, se devuelve +π/2.
  • Si x es -∞ y y es finito y positivo, se devuelve +π.
  • Si x es -∞ y y es finito y negativo, se devuelve -π.
  • Si x es +∞ y y es finito y positivo, se devuelve +0.
  • Si x es +∞ y y es finito y negativo, se devuelve -0.
  • Si x es NaN o y es NaN, se devuelve NaN.

Notas

std :: atan2 ( y, x ) es equivalente a std:: arg ( std:: complex < std:: common_type_t < decltype ( x ) , decltype ( y ) >> ( x, y ) ) .

POSIX especifica que en caso de underflow, se devuelve el valor y / x , y si eso no está soportado, se devuelve un valor definido por la implementación no mayor que DBL_MIN , FLT_MIN , y LDBL_MIN .

Las sobrecargas adicionales no requieren ser proporcionadas exactamente como (A) . Solo necesitan ser suficientes para garantizar que para su primer argumento num1 y segundo argumento num2 :

  • Si num1 o num2 tiene tipo long double , entonces std :: atan2 ( num1, num2 ) tiene el mismo efecto que std :: atan2 ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • En caso contrario, si num1 y/o num2 tiene tipo double o un tipo entero, entonces std :: atan2 ( num1, num2 ) tiene el mismo efecto que std :: atan2 ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • En caso contrario, si num1 o num2 tiene tipo float , entonces std :: atan2 ( num1, num2 ) tiene el mismo efecto que std :: atan2 ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(hasta C++23)

Si num1 y num2 tienen tipos aritméticos, entonces std :: atan2 ( num1, num2 ) tiene el mismo efecto que std :: atan2 ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , 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 y num2 , 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)

Ejemplo

Ejecutar este código 
#include <cmath>
#include <iostream>
void print_coordinates(int x, int y)
{
    std::cout << std::showpos
              << "(x:" << x << ", y:" << y << ") cartesian is "
              << "(r:" << std::hypot(x, y)
              << ", phi:" << std::atan2(y, x) << ") polar\n";
}
int main()
{
    // uso normal: los signos de los dos argumentos determinan el cuadrante
    print_coordinates(+1, +1); // atan2( 1,  1) =  +pi/4, Cuadrante I
    print_coordinates(-1, +1); // atan2( 1, -1) = +3pi/4, Cuadrante II
    print_coordinates(-1, -1); // atan2(-1, -1) = -3pi/4, Cuadrante III
    print_coordinates(+1, -1); // atan2(-1,  1) =  -pi/4, Cuadrante IV
    // valores especiales
    std::cout << std::noshowpos
              << "atan2(0, 0) = " << atan2(0, 0) << '\n'
              << "atan2(0,-0) = " << atan2(0, -0.0) << '\n'
              << "atan2(7, 0) = " << atan2(7, 0) << '\n'
              << "atan2(7,-0) = " << atan2(7, -0.0) << '\n';
}

Salida: 

(x:+1, y:+1) cartesian is (r:1.41421, phi:0.785398) polar
(x:-1, y:+1) cartesian is (r:1.41421, phi:2.35619) polar
(x:-1, y:-1) cartesian is (r:1.41421, phi:-2.35619) polar
(x:+1, y:-1) cartesian is (r:1.41421, phi:-0.785398) polar
atan2(0, 0) = 0
atan2(0,-0) = 3.14159
atan2(7, 0) = 1.5708
atan2(7,-0) = 1.5708

Véase también

(C++11) (C++11)
calcula el arco seno ( arcsin(x) )
(función)
(C++11) (C++11)
calcula el arco coseno ( arccos(x) )
(función)
(C++11) (C++11)
calcula el arco tangente ( arctan(x) )
(función)
devuelve el ángulo de fase
(plantilla de función)
aplica la función std::atan2 a un valarray y un valor
(plantilla de función)
Documentación C para atan2