AppDividend
Latest Code Tutorials

# JavaScript Math atan2() Function: Complete Guide

Math.atan2(y,x) function returns the angle between a point (x,y) and the positive x-axis, measured in an anticlockwise direction (in radians). The atan2() method comes in handy in programming contexts dealing with trigonometric expressions.

## JavaScript Math atan2()

Javascript Math atan2() is a built-in function that returns an arctangent of the quotient of its arguments. JavaScript Math atan2() method returns a numeric value between -Π and Π representing the angle theta of the (x, y) point and the positive x-axis.

To find the arctangent quotient of two passed arguments in JavaScript, use the Math.atan2() method.

See the following figure.

Since atan2() is a static method of Math, it can be used without creating an object.

### Syntax

```Math.atan2(y,x)
```

### Parameter(s)

The variables y and x, whose arctangent quotient is to be determined.

### Return Value

The arctangent quotient is in the range from -pi to pi radians.

See the following figure.

#### Note:

• If the passed value is empty, the method returns NaN.
• If the second parameter is passed as negative zero, and the first argument is ±0, the method returns pi with the same sign as the first argument.
• If the second parameter is passed as positive zero, and the first argument is ±0, the method returns 0 with the same sign as the first argument.
• If the first parameter is passed as ±0, and the second argument is negative, the method returns pi with the same sign as the first argument.
• If the first parameter is passed as ±0, and the second argument is positive, the method returns 0 with a same sign as the first argument.
• If the second parameter is passed as ±0, and the first argument is negative, the method returns -pi/2.
• If the second parameter is passed as ±0, and the first argument is positive, the method returns pi/2.
• If the second parameter is passed as negative infinity, the method returns pi with the same sign as the first argument.
• If the second parameter is passed as positive infinity, the method returns 0 with the same sign as the first argument.
• If the first parameter is passed as infinite, then for the second argument is negative infinity, the method returns 3*pi/4 with the same sign as the first argument, and for the second argument is positive infinity, the method returns pi/4 with the same sign as the first argument.

### Compatibility

• Internet Explorer
• Firefox
• Opera
• Safari
• Android webview
• Chrome for Android
• Firefox for Android
• Opera for Android
• Safari on iOS
• Samsung Internet
• Node.js

JavaScript version: ECMAScript 1

Consider the following examples.

### example1.js

The following example demonstrates the use of the Javascript atan2() method.

```//example1.js

var x = 5;
var y = 4;

console.log(Math.atan2(y, x));

var x = 90;
var y = 15;

console.log(Math.atan2(y, x));

var x = 15;
var y = 90;

console.log(Math.atan2(y, x));```

#### Output

```node example1
0.6747409422235527
0.16514867741462683
1.4056476493802699
```

### example2.js

The following example demonstrates the case where an empty value is passed.

```//example2.js

var x;
var y;

console.log(Math.atan2(x, y));
console.log(Math.atan2());
```

#### Output

```node example2
NaN
NaN
```

### example3.js

The following example demonstrates the following case:

If the second parameter is passed as negative zero, and the first argument is ±0, the method returns pi with the same sign as the first argument.

```//example3.js

var x = -0;
var a = 0;
var b = -0;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));

```

#### Output

```node example3
3.141592653589793
-3.141592653589793
```

### example4.js

The following example demonstrates the case:

If the second parameter is passed as positive zero, and the first argument is ±0, the method returns 0 with the same sign as the first argument.

See the following code.

```// example4.js

var x = 0;
var a = 0;
var b = -0;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));
```

#### Output

```node example4
0
-0
```

### example5.js

The following example demonstrates the case:

If the first parameter is passed as ±0, and the second argument is negative, the method returns pi with the same sign as the first argument.

```//example5.js

var x = -5;
var a = 0;
var b = -0;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));

```

#### Output

```node example5
3.141592653589793
-3.141592653589793```

### example6.js

The following example demonstrates the case:

If the first parameter is passed as ±0, and the second argument is positive, the method returns 0 with the same sign as the first argument.

```//example6.js

var x = 5;
var a = 0;
var b =- 0;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));```

#### Output

```node example6
0
-0```

### example7.js

The following example demonstrates the case.

If the second parameter is passed as ±0, and the first argument is negative, the method returns -pi/2.

```//example7.js

var y =- 5;
var a = 0;
var b =- 0;

console.log(Math.atan2(y,a));
console.log(Math.atan2(y,b));

```

#### Output

```node example7
-1.5707963267948966
-1.5707963267948966```

### example8.js

The following example demonstrates the case:

If the second parameter is passed as ±0, and the first argument is positive, the method returns pi/2.

```// example8.js

var y = 5;
var a = 0;
var b =- 0;

console.log(Math.atan2(y, a));
console.log(Math.atan2(y, b));
```

#### Output

```node example8
1.5707963267948966
1.5707963267948966
```

### example9.js

The following example demonstrates the case:

If the second parameter is passed as negative infinity, the method returns pi with the same sign as the first argument.

```//example9.js

var x = Number.NEGATIVE_INFINITY;
var a = 2;
var b =- 2;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));
```

#### Output

```node example9
3.141592653589793
-3.141592653589793```

### example10.js

The following example demonstrates the case:

If the second parameter is passed as negative infinity, the method returns pi with the same sign as the first argument.

```//example10.js

var x = Number.POSITIVE_INFINITY;
var a = 2;
var b = -2;

console.log(Math.atan2(a, x));
console.log(Math.atan2(b, x));```

#### Output

```node example10
0
-0
```

### example11.js

The following example demonstrates the case:

If the first parameter is passed as infinite, then for the second argument is negative infinity, the method returns 3*pi/4 with the same sign as the first argument, and for the second argument is positive infinity, the method returns pi/4 with the same sign as the first argument.

```// example11.js

var x = Number.POSITIVE_INFINITY;
var y = Number.NEGATIVE_INFINITY;

console.log(Math.atan2(x, y));
console.log(Math.atan2(y, y));

console.log(Math.atan2(x, x));
console.log(Math.atan2(y, x));```

#### Output

```node example11
2.356194490192345
-2.356194490192345
0.7853981633974483
-0.7853981633974483
```

### example12.js

The following example demonstrates the application of this method in a simple programming context.

Given the x-coordinate and y-coordinate of a point (x,y), find the angle it makes with the positive x-axis.

```// example12.js

// Given the x-coordinate and y-coordinate of a point (x,y),
// find the angle it makes with the positive x-axis.

var x;
var y;

const rl = r.createInterface({
input: process.stdin,
output: process.stdout
});

const prompt1 = () => {
return new Promise((resolve, reject) => {
resolve();
});
});
};

const prompt2 = () => {
return new Promise((resolve, reject) => {
resolve();
});
});
};

const main = async () => {
await prompt1();
await prompt2();
rl.close();

console.log("The angle (in radians) made by point (x,y) with the positive x-axis is:");
console.log(Math.atan2(y, x));
}

main();```

#### Output

```Test Case 1:
->node example12
x-coordinate: 5
y-coordinate: 4
The angle (in radians) made by point (x,y) with the positive x-axis is:
0.6747409422235527

Test Case2:
->node example12
x-coordinate: 0
y-coordinate: 0
The angle (in radians) made by point (x,y) with the positive x-axis is:
0```