JavaScript Math.atan() Examples [In-Depth Tutorial]


Written By - Olorunfemi Akinlua

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)

 

Can't find what you're searching for? Let us assist you.

Enter your query below, and we'll provide instant results tailored to your needs.

If my articles on GoLinuxCloud has helped you, kindly consider buying me a coffee as a token of appreciation.

Buy GoLinuxCloud a Coffee

For any other feedbacks or questions you can send mail to admin@golinuxcloud.com

Thank You for your support!!

Leave a Comment