**Topics we will cover**hide

The `math.atan()`

method is a function in the JavaScript programming language that allows you to calculate the arctangent of a number. The arctangent function is the inverse of the tangent function and is used to find the angle in radians between the x-axis and a line that passes through the origin and a given point on the graph.

In this article, we will explore how to use the `math.atan()`

method in JavaScript with some examples.

## Using the `math.atan()`

method in JavaScript

The syntax for the `math.atan()`

method is as follows:

```
Math.atan(x)
```

Where `x`

is the number whose arctangent we want to calculate. The method returns the arctangent value in radians. Let's say we want to find the arctangent of 1. In this case, `x`

would be 1, and we would use the `math.atan()`

method as follows:

```
const arctanValue = Math.atan(1);
console.log(arctanValue);
```

Output

```
0.7853981633974483
```

### Example 1: Finding the angle of a right triangle

To find the angle between the base and hypotenuse of a right triangle with a base of 3 and a height of 4, we can use the following code:

```
const opposite = 4;
const adjacent = 3;
const theta = Math.atan(opposite / adjacent);
console.log(theta);
```

Output

```
0.9272952180016122
```

The `Math.atan()`

function takes a ratio of two sides of the triangle as its argument and returns the angle in radians. In this example, the angle between the base and hypotenuse is approximately 0.93 radians.

### Example 2: Converting Cartesian coordinates to polar coordinates

To find the polar angle of a point with Cartesian coordinates (2, -2), we can use the following code:

```
const x = 2;
const y = -2;
const theta = Math.atan(y / x);
console.log(theta);
```

Output

```
-0.785398163397448
```

The `Math.atan()`

function takes the ratio of the y-coordinate to the x-coordinate as its argument and returns the polar angle in radians. In this example, the polar angle of the point (2, -2) is approximately -0.79 radians.

### Example 3: Solving trigonometric equations

To find the value of x in the equation tan(x) = 2, we can use the following code:

```
const tanValue = 2;
const x = Math.atan(tanValue);
console.log(x);
```

Output

```
1.1071487177940904
```

The `Math.atan()`

function takes the tangent value as its argument and returns the angle in radians. In this example, the solution to the equation tan(x) = 2 is approximately x = 1.11 radians.

Note that the `Math.atan()`

function returns the angle in radians, which may need to be converted to degrees for some applications. To convert from radians to degrees, you can use the `Math.degrees()`

function or multiply the angle by `180 / Math.PI`

.

### Example 4: Calculating the angle between two points

Suppose we have two points, `p1`

and `p2`

, with Cartesian coordinates. We can use the `Math.atan2()`

function to find the angle between them, which is a static method returns the angle in the plane (in radians) between the positive x-axis and the ray from (0, 0) to the point (x, y).

```
const p1 = { x: 2, y: 3 };
const p2 = { x: -1, y: 1 };
const dx = p2.x - p1.x;
const dy = p2.y - p1.y;
const theta = Math.atan2(dy, dx);
console.log(theta);
```

Output

```
-2.5535900500422257
```

The `Math.atan2()`

function takes the difference in y-coordinates and the difference in x-coordinates as its arguments and returns the angle in radians. In this example, the angle between the two points is approximately 2.54 radians.

### Example 5: Finding the intersection point of two lines

Suppose we have two lines (`y = 2x + 1`

and `y = -0.5x + 4`

) defined by their slopes and y-intercepts. We can use the `Math.atan()`

function to find the angle between the lines and then use trigonometry to find the intersection point:

```
const m1 = 2;
const b1 = 1;
const m2 = -0.5;
const b2 = 4;
const theta = Math.abs(Math.atan(m2) - Math.atan(m1));
const x = (b2 - b1) / (m1 - m2);
const y = m1 * x + b1;
console.log(`Intersection point: (${x}, ${y})`);
```

Output

```
Intersection point: (1.2, 3.4)
```

The `Math.atan()`

function is used to find the angle between the slopes of the two lines. In this example, the angle between the lines is approximately 1.57 radians or 90 degrees. We can then use trigonometry to find the intersection point of the two lines.

### Example 6: Rotate a point around a fixed point

The goal of this example is to rotate a point around a fixed point by a given angle. This can be achieved by applying a rotation matrix to the point, where the rotation matrix is defined by the angle of rotation and the coordinates of the fixed point.

| cosÎ¸ -sinÎ¸ | | x - pivotX | | rotatedX | | | * | | = | | | sinÎ¸ cosÎ¸ | | y - pivotY | | rotatedY |

where:

`Î¸`

is the angle of rotation`(pivotX, pivotY)`

are the coordinates of the fixed point`(x, y)`

are the coordinates of the point to be rotated`(rotatedX, rotatedY)`

are the coordinates of the rotated point

Using `Math.atan()`

, we can calculate the sine and cosine of the rotation angle. Then, we can plug these values into the rotation matrix to obtain the rotated point.

```
function rotatePoint(x, y, angle, pivotX, pivotY) {
let deltaX = x - pivotX;
let deltaY = y - pivotY;
let rotatedX = deltaX * Math.cos(angle) - deltaY * Math.sin(angle) + pivotX;
let rotatedY = deltaX * Math.sin(angle) + deltaY * Math.cos(angle) + pivotY;
return [rotatedX, rotatedY];
}
// Rotate the point (5, 5) by 45 degrees around the fixed point (0, 0)
let point = rotatePoint(5, 5, Math.PI / 4, 0, 0);
console.log(point); // Outputs [3.5355339059327378, 8.535533905932738]
```

In this example, we're rotating the point `(5, 5)`

by 45 degrees (or `Math.PI / 4`

radians) around the fixed point `(0, 0)`

. The `rotatePoint()`

function takes five arguments:

`x`

: the x-coordinate of the point to be rotated`y`

: the y-coordinate of the point to be rotated`angle`

: the angle of rotation in radians`pivotX`

: the x-coordinate of the fixed point`pivotY`

: the y-coordinate of the fixed point

Inside the function, we calculate the change in x and y coordinates between the point and the fixed point (`deltaX`

and `deltaY`

, respectively). Then, we use the rotation matrix to calculate the rotated coordinates (`rotatedX`

and `rotatedY`

).

Finally, we return the rotated coordinates as an array `[rotatedX, rotatedY]`

. In this example, the output is `[3.5355339059327378, 8.535533905932738]`

, which represents the rotated point `(3.54, 8.54)`

rounded to two decimal places.

### Example 7: Find the angle of a right triangle given two sides

The goal of this example is to calculate the angle between two points on a 2D plane. This can be achieved by calculating the arctangent of the slope of the line connecting the two points.

```
function calculateAngle(x1, y1, x2, y2) {
let deltaX = x2 - x1;
let deltaY = y2 - y1;
return Math.atan2(deltaY, deltaX);
}
// Calculate the angle between points (1, 2) and (5, 6)
let angle = calculateAngle(1, 2, 5, 6);
console.log(angle); // Outputs 0.7853981633974483 (or approximately 45 degrees)
```

In this example, we're calculating the angle between two points `(x1, y1)`

and `(x2, y2)`

. The `calculateAngle()`

function takes four arguments:

`x1`

: the x-coordinate of the first point`y1`

: the y-coordinate of the first point`x2`

: the x-coordinate of the second point`y2`

: the y-coordinate of the second point

Inside the function, we calculate the change in x and y coordinates between the two points (`deltaX`

and `deltaY`

, respectively). Then, we use `Math.atan2()`

to calculate the angle between the two points.

`Math.atan2()`

is similar to `Math.atan()`

, but it takes two arguments (`y`

and `x`

) instead of one. It returns the angle (in radians) between the positive x-axis and the point `(x, y)`

in the Cartesian plane.

By passing `deltaY`

as the first argument and `deltaX`

as the second argument to `Math.atan2()`

, we're calculating the angle of the line connecting the two points. We don't need to worry about the signs of `deltaX`

and `deltaY`

because `Math.atan2()`

takes care of that for us.

Finally, we return the calculated angle in radians. In this example, the output is `0.7853981633974483`

, which represents the angle between the points `(1, 2)`

and `(5, 6)`

in radians (or approximately 45 degrees rounded to two decimal places).

## Summary

In this article, we have explored the `math.atan()`

method in JavaScript. We have seen that the method is used to find the arctangent of a number and returns the value in radians. We have also looked at some examples of how to use the method to find the arctangent of different numbers. The `math.atan()`

method is a useful tool for any programmer who needs to calculate the arctangent of a number in their JavaScript code.

## References

Math.atan() - JavaScript | MDN (mozilla.org)

Math.atan2() - JavaScript | MDN (mozilla.org)

He is boasting over five years of experience in JavaScript, specializing in technical content writing and UX design. With a keen focus on programming languages, he crafts compelling content and designs user-friendly interfaces to enhance digital experiences across various domains