# Math.Atan(Double) Method

## Definition

Returns the angle whose tangent is the specified number.

``````public:
static double Atan(double d);``````
``public static double Atan (double d);``
``static member Atan : double -> double``
``Public Shared Function Atan (d As Double) As Double``

#### Parameters

d
Double

A number representing a tangent.

#### Returns

An angle, θ, measured in radians, such that -π/2 ≤ θ ≤ π/2.

-or-

NaN if `d` equals NaN, -π/2 rounded to double precision (-1.5707963267949) if `d` equals NegativeInfinity, or π/2 rounded to double precision (1.5707963267949) if `d` equals PositiveInfinity.

## Examples

The following example demonstrates how to calculate the arctangent of a value and display it to the console.

``````// This example demonstrates Math.Atan()
//                           Math.Atan2()
//                           Math.Tan()
using namespace System;
int main()
{
double x = 1.0;
double y = 2.0;
double angle;
double radians;
double result;

// Calculate the tangent of 30 degrees.
angle = 30;
radians = angle * (Math::PI / 180);
result = Math::Tan( radians );
Console::WriteLine( "The tangent of 30 degrees is {0}.", result );

// Calculate the arctangent of the previous tangent.
radians = Math::Atan( result );
angle = radians * (180 / Math::PI);
Console::WriteLine( "The previous tangent is equivalent to {0} degrees.", angle );

// Calculate the arctangent of an angle.
String^ line1 = "{0}The arctangent of the angle formed by the x-axis and ";
String^ line2 = "a vector to point ({0},{1}) is {2}, ";
String^ line3 = "which is equivalent to {0} degrees.";
radians = Math::Atan2( y, x );
angle = radians * (180 / Math::PI);
Console::WriteLine( line1, Environment::NewLine );
Console::WriteLine( line2, x, y, radians );
Console::WriteLine( line3, angle );
}

/*
This example produces the following results:

The tangent of 30 degrees is 0.577350269189626.
The previous tangent is equivalent to 30 degrees.

The arctangent of the angle formed by the x-axis and
a vector to point (1,2) is 1.10714871779409,
which is equivalent to 63.434948822922 degrees.
*/
``````
``````// This example demonstrates Math.Atan()
//                           Math.Atan2()
//                           Math.Tan()
using System;

class Sample
{
public static void Main()
{
double x = 1.0;
double y = 2.0;
double angle;
double radians;
double result;

// Calculate the tangent of 30 degrees.
angle = 30;
radians = angle * (Math.PI/180);
result = Math.Tan(radians);
Console.WriteLine("The tangent of 30 degrees is {0}.", result);

// Calculate the arctangent of the previous tangent.
radians = Math.Atan(result);
angle = radians * (180/Math.PI);
Console.WriteLine("The previous tangent is equivalent to {0} degrees.", angle);

// Calculate the arctangent of an angle.
String line1 = "{0}The arctangent of the angle formed by the x-axis and ";
String line2 = "a vector to point ({0},{1}) is {2}, ";
String line3 = "which is equivalent to {0} degrees.";

radians = Math.Atan2(y, x);
angle = radians * (180/Math.PI);

Console.WriteLine(line1, Environment.NewLine);
Console.WriteLine(line2, x, y, radians);
Console.WriteLine(line3, angle);
}
}
/*
This example produces the following results:

The tangent of 30 degrees is 0.577350269189626.
The previous tangent is equivalent to 30 degrees.

The arctangent of the angle formed by the x-axis and
a vector to point (1,2) is 1.10714871779409,
which is equivalent to 63.434948822922 degrees.
*/
``````
``````// This example demonstrates Math.Atan()
//                           Math.Atan2()
//                           Math.Tan()
// Functions 'atan', 'atan2', and 'tan' may be used instead.
open System

[<EntryPoint>]
let main _ =
let x = 1.
let y = 2.

// Calculate the tangent of 30 degrees.
let angle = 30.
let radians = angle * (Math.PI / 180.)
let result = Math.Tan radians
printfn \$"The tangent of 30 degrees is {result}."

// Calculate the arctangent of the previous tangent.
let radians = Math.Atan result
let angle = radians * (180. / Math.PI)
printfn \$"The previous tangent is equivalent to {angle} degrees."

// Calculate the arctangent of an angle.

let radians = Math.Atan2(y, x)
let angle = radians * (180. / Math.PI)

printfn
\$"""The arctangent of the angle formed by the x-axis and
a vector to point ({x},{y}) is {radians},
which is equivalent to {angle} degrees."""
0

//This example produces the following results:
//     The tangent of 30 degrees is 0.577350269189626.
//     The previous tangent is equivalent to 30 degrees.
//
//     The arctangent of the angle formed by the x-axis and
//     a vector to point (1,2) is 1.10714871779409,
//     which is equivalent to 63.434948822922 degrees.
``````
``````' This example demonstrates Math.Atan()
'                           Math.Atan2()
'                           Math.Tan()
Class Sample
Public Shared Sub Main()
Dim x As Double = 1.0
Dim y As Double = 2.0
Dim angle As Double
Dim radians As Double
Dim result As Double

' Calculate the tangent of 30 degrees.
angle = 30
radians = angle *(Math.PI / 180)
result = Math.Tan(radians)
Console.WriteLine("The tangent of 30 degrees is {0}.", result)

' Calculate the arctangent of the previous tangent.
radians = Math.Atan(result)
angle = radians *(180 / Math.PI)
Console.WriteLine("The previous tangent is equivalent to {0} degrees.", angle)

' Calculate the arctangent of an angle.
Dim line1 As [String] = "{0}The arctangent of the angle formed by the x-axis and "
Dim line2 As [String] = "a vector to point ({0},{1}) is {2}, "
Dim line3 As [String] = "which is equivalent to {0} degrees."

radians = Math.Atan2(y, x)
angle = radians *(180 / Math.PI)

Console.WriteLine(line1, Environment.NewLine)
Console.WriteLine(line2, x, y, radians)
Console.WriteLine(line3, angle)
End Sub
End Class
'
'This example produces the following results:
'
'The tangent of 30 degrees is 0.577350269189626.
'The previous tangent is equivalent to 30 degrees.
'
'The arctangent of the angle formed by the x-axis and
'a vector to point (1,2) is 1.10714871779409,
'which is equivalent to 63.434948822922 degrees.
'
``````

## Remarks

A positive return value represents a counterclockwise angle from the x-axis; a negative return value represents a clockwise angle.

Multiply the return value by 180/Math.PI to convert from radians to degrees.

This method calls into the underlying C runtime, and the exact result or valid input range may differ between different operating systems or architectures.