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
Определено в заголовочном файле <cmath>
(1)
float atan2 ( float y, float x ) ;

double atan2 ( double y, double x ) ;

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

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

/*floating-point-type*/ x ) ;
(начиная с C++23)
(constexpr начиная с C++26)
float atan2f ( float y, float x ) ;
(2) (начиная с C++11)
(constexpr начиная с C++26)
long double atan2l ( long double y, long double x ) ;
(3) (начиная с C++11)
(constexpr начиная с C++26)
SIMD перегрузка (начиная с C++26)
Определено в заголовочном файле <simd>
template < class V0, class V1 >

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

atan2 ( const V0 & v_y, const V1 & v_x ) ;
(S) (начиная с C++26)
Определено в заголовочном файле <cmath>
template < class Integer >
double atan2 ( Integer y, Integer x ) ;
(A) (constexpr начиная с C++26)
1-3) Вычисляет арктангенс от y / x используя знаки аргументов для определения правильного квадранта. Библиотека предоставляет перегрузки std::atan2 для всех cv-неквалифицированных типов с плавающей точкой в качестве типа параметров. (since C++23)
S) SIMD перегрузка выполняет поэлементное вычисление std::atan2 для v_y и v_x .
(См. math-common-simd-t для его определения.)
(since C++26)
A) Дополнительные перегрузки предоставляются для всех целочисленных типов, которые трактуются как double .
(since C++11)

Содержание

Параметры

y, x - значения с плавающей точкой или целочисленные значения

Возвращаемое значение

If no errors occur, the arc tangent of y / x ( arctan(
y
x
) ) in the range [-π, +π] radians, is returned.
y аргумент
Возвращаемое значение
math-atan2.png
x аргумент

Если происходит ошибка домена, возвращается значение, определяемое реализацией (NaN, если поддерживается).

Если происходит ошибка диапазона из-за потери значимости (underflow), возвращается корректный результат (после округления).

Обработка ошибок

Ошибки сообщаются, как указано в math_errhandling .

Ошибка области определения может возникнуть, если x и y оба равны нулю.

Если реализация поддерживает арифметику с плавающей запятой IEEE (IEC 60559),

  • Если x и y оба равны нулю, ошибка области определения не возникает .
  • Если x и y оба равны нулю, ошибка диапазона также не возникает.
  • Если y равен нулю, ошибка полюса не возникает.
  • Если y равен ±0 и x отрицателен или равен -0, возвращается ±π.
  • Если y равен ±0 и x положителен или равен +0, возвращается ±0.
  • Если y равен ±∞ и x конечен, возвращается ±π/2.
  • Если y равен ±∞ и x равен -∞, возвращается ±3π/4.
  • Если y равен ±∞ и x равен +∞, возвращается ±π/4.
  • Если x равен ±0 и y отрицателен, возвращается -π/2.
  • Если x равен ±0 и y положителен, возвращается +π/2.
  • Если x равен -∞ и y конечен и положителен, возвращается +π.
  • Если x равен -∞ и y конечен и отрицателен, возвращается -π.
  • Если x равен +∞ и y конечен и положителен, возвращается +0.
  • Если x равен +∞ и y конечен и отрицателен, возвращается -0.
  • Если либо x является NaN, либо y является NaN, возвращается NaN.

Примечания

std :: atan2 ( y, x ) эквивалентно std:: arg ( std:: complex < std:: common_type_t < decltype ( x ) , decltype ( y ) >> ( x, y ) ) .

POSIX определяет что в случае потери значимости возвращается значение y / x , и если это не поддерживается, возвращается определяемое реализацией значение, не превышающее DBL_MIN , FLT_MIN и LDBL_MIN .

Дополнительные перегрузки не обязаны быть предоставлены в точности как (A) . Они должны быть лишь достаточными для обеспечения того, чтобы для их первого аргумента num1 и второго аргумента num2 :

  • Если num1 или num2 имеет тип long double , то std :: atan2 ( num1, num2 ) имеет тот же эффект, что и std :: atan2 ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) )     .
  • В противном случае, если num1 и/или num2 имеет тип double или целочисленный тип, то std :: atan2 ( num1, num2 ) имеет тот же эффект, что и std :: atan2 ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) )     .
  • В противном случае, если num1 или num2 имеет тип float , то std :: atan2 ( num1, num2 ) имеет тот же эффект, что и std :: atan2 ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) )     .
(до C++23)

Если num1 и num2 имеют арифметические типы, то std :: atan2 ( num1, num2 ) имеет тот же эффект, что и std :: atan2 ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ) , где /*common-floating-point-type*/ - это тип с плавающей запятой с наибольшим рангом преобразования с плавающей запятой и наибольшим подрангом преобразования с плавающей запятой среди типов num1 и num2 , при этом аргументы целочисленного типа считаются имеющими тот же ранг преобразования с плавающей запятой, что и double .

Если такой тип с плавающей запятой с наибольшим рангом и подрангом не существует, то разрешение перегрузки не приводит к пригодному кандидату из предоставленных перегрузок.

(начиная с C++23)

Пример

Запустить этот код 
#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()
{
    // нормальное использование: знаки двух аргументов определяют квадрант
    print_coordinates(+1, +1); // atan2( 1,  1) =  +pi/4, I квадрант
    print_coordinates(-1, +1); // atan2( 1, -1) = +3pi/4, II квадрант
    print_coordinates(-1, -1); // atan2(-1, -1) = -3pi/4, III квадрант
    print_coordinates(+1, -1); // atan2(-1,  1) =  -pi/4, IV квадрант
    // специальные значения
    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';
}

Вывод: 

(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

Смотрите также

(C++11) (C++11)
вычисляет арксинус ( arcsin(x) )
(функция)
(C++11) (C++11)
вычисляет арккосинус ( arccos(x) )
(функция)
(C++11) (C++11)
вычисляет арктангенс ( arctan(x) )
(функция)
возвращает фазовый угол
(шаблон функции)
применяет функцию std::atan2 к valarray и значению
(шаблон функции)
Документация C для atan2