# JavaScript Math.acos() Method [In-Depth Tutorial]

Written by - Olorunfemi Akinlua

In JavaScript, the `Math` object is used to perform mathematical operations. It provides a variety of methods and properties for performing common mathematical calculations. The `Math` object is built into the language and can be used without the need for any additional libraries or modules.

## Using the `Math.acos()` method in JavaScript

The `Math.acos()` is a built-in JavaScript function used to calculate the arccosine of a number. The arccosine is the inverse cosine function, which is the angle whose cosine is a given number. The input to `Math.acos()` must be a number between -1 and 1. If the input is outside this range, the function will return NaN (not a number).

The syntax for the `Math.acos()` can be seen below

``````Math.acos(ang);
``````

where the `ang` value is the angle in radians

The `Math.acos()` method can be useful in a variety of applications, including computer graphics, physics, and engineering. Here are some examples of how to use the `Math.acos()` method in JavaScript.

``````const angle = Math.acos(0.5);
console.log(angle);
``````

Output

``````1.0471975511965979
``````

In this example, we calculate the arccosine of 0.5 using the `Math.acos()` method. The method returns the angle whose cosine is 0.5, which is approximately 1.047 radians.

### Example 1: Finding angle

Here we find the angle between two positions using the inverse cosine.

``````const x = 0.5;
const y = Math.sqrt(1 - x * x);
const angle = Math.acos(x);
console.log(`x: \${x}, y: \${y}, angle: \${angle}`);
``````

Output

``````x: 0.5, y: 0.8660254037844386, angle: 1.0471975511965979
``````

In this example, we use the Pythagorean theorem to calculate the value of `y`, given `x = 0.5`. We then use the `Math.acos()` method to calculate the arccosine of `x`. The method returns the angle whose cosine is 0.5, which is approximately 1.047 radians.

### Example 2: Finding the angle between two vectors

Suppose we have two vectors, `v1` and `v2`, in two-dimensional space, and we want to find the angle between them in degrees. We can use the arccosine function to do this as follows:

``````const v1 = [2, 2];
const v2 = [7, 4];

const cosAngle =
(v1[0] * v2[0] + v1[1] * v2[1]) / (Math.hypot(...v1) * Math.hypot(...v2));

const angleDegrees = (Math.acos(cosAngle) * 180) / Math.PI;

console.log(angleDegrees);
``````

Output

``````15.255118703057764
``````

Here, we first calculate the dot product of the two vectors and divide it by the product of their magnitudes to get the cosine of the angle between them. We then use the `Math.acos()` function to find the arccosine of this cosine value, which gives us the angle in radians. Finally, we convert the angle to degrees by multiplying by 180 and dividing by Ï€.

### Example 3: Solving a triangle

Suppose we have a triangle with sides `a`, `b`, and `c`, and we know the lengths of `a` and `b` and the angle `C` opposite `c`. We can use the inverse cosine function to find the length of `c` as follows:

``````const a = 3;
const b = 4;
const C = (30 * Math.PI) / 180;

const c = Math.sqrt(a * a + b * b - 2 * a * b * Math.cos(C));

console.log(c);
``````

Output

``````2.0531415706603067
``````

Here, we use the law of cosines to find the length of the third side `c`, given the lengths of the other two sides and the angle opposite `c`. The law of cosines states that `c^2 = a^2 + b^2 - 2ab*cos(C)`, where `C` is the angle opposite `c`. We use the `Math.cos()` function to find the cosine of `C`, and then use the inverse cosine function to find the angle in radians. We then use the `Math.sqrt()` function to find the square root of the right-hand side of the equation, which gives us the length of `c`.

### Example 4: Generating random points on a circle

Suppose we want to generate `n` random points on the circumference of a circle with radius `r`. We can use the inverse cosine function to find the x and y coordinates of each point as follows:

``````const n = 10;
const r = 5;

for (let i = 0; i < n; i++) {
const theta = Math.random() * 2 * Math.PI;

const x = r * Math.cos(theta);
const y = r * Math.sin(theta);

console.log(`Point \${i}: (\${x}, \${y})`);
}
``````

Output

``````Point 0: (4.081395152354311, 2.888289045497131)
Point 1: (4.720956639499305, -1.646987676932474)
Point 2: (4.563814085003422, 2.0424497539779)
Point 3: (-3.2993302003682596, 3.7569163191290187)
Point 4: (0.19855841778121402, -4.996055899880247)
Point 5: (4.998591842862364, -0.11865744169598699)
Point 6: (4.732863031675021, -1.6124538825665466)
Point 7: (-4.731321838371784, 1.6169705197517492)
Point 8: (4.709397837440632, -1.6797535559448895)
Point 9: (-3.830151061490476, -3.2140228446859833)
``````

Here, we use the `Math.random()` function to generate a random angle between 0 and 2Ï€ radians. We then use the `Math.cos()` and `Math.sin()` functions to calculate the x and y coordinates of each point on the circle, given the radius `r` and the angle `theta`. We repeat this `n` times to generate `n` random points on the circle.

## Bonus Tips

Here are some additional important things to know about the `Math.acos()` function in JavaScript:

The output of `Math.acos()` is always in radians, not degrees. If you need to convert the result to degrees, you can use the `toDegrees()` function like this:

``````function toDegrees(angle) {
return angle * (180 / Math.PI);
}

let x = 0.5;
let angle = Math.acos(x); // Returns the angle whose cosine is 0.5
console.log(toDegrees(angle)); // Outputs 60 (degrees)``````

The `Math.acos()` function is the inverse of the `Math.cos()` function. That is, if you take the cosine of an angle and then take the arccosine of that result, you should get back the original angle. However, due to rounding errors, this may not always be the case.

``````let angle = 45; // degrees
let cosAngle = Math.cos(angle * Math.PI / 180); // Takes the cosine of 45 degrees
console.log(cosAngle); // Outputs 0.7071067811865476
let recoveredAngle = Math.acos(cosAngle) * 180 / Math.PI; // Takes the arccosine of the cosine of 45 degrees and converts the result to degrees
console.log(recoveredAngle); // Outputs 44.99999999999999 (degrees)``````

The `Math.acos()` function is a static function, which means that you can call it directly from the `Math` object without creating an instance of the `Math` object. For example:

``````let x = 0.5;
let angle = Math.acos(x); // Calls the Math.acos() function directly from the Math object

## Summary

In this article, we explored the `Math.acos()` function in JavaScript, which computes the arccosine (inverse cosine) of a given value. We looked at a few examples of using this function in practice, such as finding the angle between two vectors, solving a triangle, and generating random points on a circle. The `Math.acos()` function is a powerful tool in the JavaScript math toolkit, and can be used to solve a variety of problems involving trigonometry and geometry.

## References

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

Olorunfemi Akinlua

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. You can connect with him on LinkedIn.

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.

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