# 5 Best Ways to get the Trigonometric Inverse Cosine in Python

Rate this post

π‘ Problem Formulation: Given a cosine value, perhaps one you’ve calculated from a physics problem or graphics programming, how can you determine the corresponding angle in radians? For instance, if the input is `0.5`, the desired output would be approximately `1.047` radians, which is equivalent to 60 degreesβthe angle whose cosine is 0.5.

## Method 1: Using math.acos()

The simplest method to find the inverse cosine of a number is to use the `math.acos()` function from Python’s standard `math` module. This function returns the arc cosine of a number in radians. The input value must be within the range -1 to 1.

Here’s an example:

```import math

Output:

`1.0471975511965979`

This code imports the `math` module and uses the `acos()` function to calculate the inverse cosine of 0.5, which is the angle in radians whose cosine is 0.5. The resulting angle in radians is approximately 1.047, which is close to the expected 60 degrees.

## Method 2: Using numpy.arccos()

For those working with numerical arrays, the `numpy` library’s `arccos()` function is a great choice. It’s vectorized, meaning it can compute the arc cosine of each element in an array-like structure efficiently.

Here’s an example:

```import numpy as np

Output:

`[1.04719755 2.0943951 ]`

After importing `numpy` as `np`, we pass a list with cosine values `[0.5, -0.5]` to `np.arccos()`. The output is an array of angles in radians corresponding to each cosine value.

## Method 3: Using scipy.arccos()

If you’re already using `SciPy` for scientific computing, it includes a similar `arccos()` function within its `scipy.special` module, also useful for vectorized operations over arrays.

Here’s an example:

```from scipy.special import arccos

Output:

`[1.04719755]`

This snippet imports the `arccos` function from the `scipy.special` module and calculates the arc cosine for a list containing `0.5`, yielding the angle in radians.

## Method 4: Using SymPy for Symbolic Mathematics

If you need symbolic mathematics capabilities, `SymPy` is your go-to library. It can provide exact results in symbolic form, including the inverse cosine.

Here’s an example:

```from sympy import acos, Rational
angle = acos(Rational(1, 2))```

Output:

`pi/3`

Here, we use `SymPy`‘s `acos()` function to find the symbolic form of the arc cosine for `1/2`, resulting in `pi/3`, an exact representation of 60 degrees in radians.

## Bonus One-Liner Method 5: Lambda Function

If you want a quick, one-off inverse cosine calculation without importing entire modules, a lambda function might suffice. Be aware this uses the math module implicitly, so it’s not truly import-free.

Here’s an example:

```acos = lambda x: __import__('math').acos(x)

Output:

`1.0471975511965979`

This one-liner defines a lambda function named `acos` that uses Python’s built-in `__import__()` function to access the `acos()` function from within the `math` module and calculate the arc cosine of 0.5.

## Summary/Discussion

Method 1: math.acos(). Simple, standard library solution. Limited to single values, not arrays.
Method 2: numpy.arccos(). Suited for array operations. Requires NumPy, which is standard in scientific computing but extra overhead for basic use.
Method 3: scipy.arccos(). Similar to NumPy’s version but part of SciPy, which includes more advanced features, possibly unnecessary for simple calculations.
Method 4: SymPy’s acos(). Beneficial for symbolic math and exact results. Overkill for numerical computations.
Bonus Method 5: Lambda with import. Quick one-liner; convenient for lightweight scripts. Less readable, and efficiency is lower compared to importing normally.