std::atan, std::atanf, std::atanl

Defined in header `<cmath>`
	(1)
float atan ( float arg );
float atanf( float arg );			(since C++11)
double atan ( double arg );		(2)
		(3)
long double atan ( long double arg );
long double atanl( long double arg );				(since C++11)
double atan ( IntegralType arg );			(4)	(since C++11)

1-3) Computes the principal value of the arc tangent of arg

4) A set of overloads or a function template accepting an argument of any integral type. Equivalent to 2) (the argument is cast to double).

Parameters

arg

-

value of a floating-point or Integral type

Return value

If no errors occur, the arc tangent of arg (

arctan(arg)

) in the range

[- π 2, + π 2]

radians, is returned.

If a range error occurs due to underflow, the correct result (after rounding) is returned.

Error handling

Errors are reported as specified in math_errhandling.

If the implementation supports IEEE floating-point arithmetic (IEC 60559),

If the argument is ±0, it is returned unmodified
If the argument is +∞, +π/2 is returned
If the argument is -∞, -π/2 is returned
if the argument is NaN, NaN is returned

Notes

POSIX specifies that in case of underflow, arg is returned unmodified, and if that is not supported, an implementation-defined value no greater than DBL_MIN, FLT_MIN, and LDBL_MIN is returned.

Examples

Run this code

#include <iostream>
#include <cmath>
 
int main()
{
    std::cout << "atan(1) = " << atan(1) << " 4*atan(1) = " << 4*atan(1) << '\n';
    // special values
    std::cout << "atan(Inf) = " << atan(INFINITY)
              << " 2*atan(Inf) = " << 2*atan(INFINITY) << '\n'
              << "atan(-0.0) = " << atan(-0.0) << '\n'
              << "atan(+0.0) = " << atan(0) << '\n';
}

Output:

atan(1) = 0.785398 4*atan(1) = 3.14159
atan(Inf) = 1.5708 2*atan(Inf) = 3.14159
atan(-0.0) = -0
atan(+0.0) = 0

asinasinfasinl (C++11)(C++11)	computes arc sine (${\small\arcsin{x} }$ $arcsin(x)$ ) (function)
acosacosfacosl (C++11)(C++11)	computes arc cosine (${\small\arccos{x} }$ $arccos(x)$ ) (function)
atan2atan2fatan2l (C++11)(C++11)	arc tangent, using signs to determine quadrants (function)
tantanftanl (C++11)(C++11)	computes tangent (${\small\tan{x} }$ $tan(x)$ ) (function)
atan(std::complex) (C++11)	computes arc tangent of a complex number (${\small\arctan{z} }$ $arctan(z)$ ) (function template)
atan(std::valarray)	applies the function std::atan to each element of valarray (function template)

Compiler support
Freestanding and hosted
Language
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Floating-point environment (C++11)
Complex numbers
Numeric arrays
Pseudo-random number generation
Factor operations
gcd (C++17)
lcm (C++17)
Interpolations
midpoint (C++20)
lerp (C++20)
Generic numeric operations
iota (C++11)
ranges::iota (C++23)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Bit operations
bit_cast (C++20)
byteswap (C++23)
has_single_bit (C++20)
bit_ceil (C++20)
bit_floor (C++20)
bit_width (C++20)
rotl (C++20)
rotr (C++20)
countl_zero (C++20)
countl_one (C++20)
countr_zero (C++20)
countr_one (C++20)
popcount (C++20)
endian (C++20)