Calculating inverse trigonometric functions with formulas

The question is broad in scope, but here are some simple ideas (and code!) That can serve as a starting point for the calculation arctan

. First, the old Taylor series. For simplicity, we are using a fixed number of members; in practice, you may need to define the number of terms to use dynamically depending on size, x

or introduce some sort of convergence criterion. With a fixed number of terms, we can effectively evaluate using something similar to Horner's scheme.

def arctan_taylor(x, terms=9):
    """
    Compute arctan for small x via Taylor polynomials.

    Uses a fixed number of terms. The default of 9 should give good results for
    abs(x) < 0.1. Results will become poorer as abs(x) increases, becoming
    unusable as abs(x) approaches 1.0 (the radius of convergence of the
    series).
    """
    # Uses Horner method for evaluation.
    t = 0.0
    for n in range(2*terms-1, 0, -2):
        t = 1.0/n - x*x*t
    return x * t

      

        
        
        
      

    

The above code gives good results for small x

(for example, less than 0.1

absolute value), but the accuracy decreases as it increases x

, and for the abs(x) > 1.0

series it never converges, no matter how much term (or how much extra precision) we throw at it. Therefore, we need a better way to calculate for large ones x

. One solution is to use an ID abbreviation for arguments arctan(x) = 2 * arctan(x / (1 + sqrt(1 + x^2)))

. This gives the following code, which it builds on arctan_taylor

to give reasonable results over a wide range x

(but beware of possible overflow and overflow in computation x*x

).

import math

def arctan_taylor_with_reduction(x, terms=9, threshold=0.1):
    """
    Compute arctan via argument reduction and Taylor series.

    Applies reduction steps until x is below `threshold`,
    then uses Taylor series.
    """
    reductions = 0
    while abs(x) > threshold:
        x = x / (1 + math.sqrt(1 + x*x))
        reductions += 1

    return arctan_taylor(x, terms=terms) * 2**reductions

      

        
        
        
      

    

Alternatively, given the existing implementation for tan

, you can simply find a solution y

to the equation tan(y) = x

using traditional root finding techniques. Since arctan is already naturally bounded in range (-pi/2, pi/2)

, half-search works well:

def arctan_from_tan(x, tolerance=1e-15):
    """
    Compute arctan as the inverse of tan, via bisection search. This assumes
    that you already have a high quality tan function.
    """
    low, high = -0.5 * math.pi, 0.5 * math.pi
    while high - low > tolerance:
        mid = 0.5 * (low + high)
        if math.tan(mid) < x:
            low = mid
        else:
            high = mid
    return 0.5 * (low + high)

      

        
        
        
      

    

Finally, just for fun, here's a CORDIC-like implementation that's actually more suitable for low-level implementations than Python. The idea here is that you pre-compromise a table of arctan values ​​for 1

, 1/2,

1/4,

etc., and then use them to compute total arctan values, essentially by computing successive approximations to the true angle. The cool part is that after the pre-computation step, the computation of arctan only involves additions, subtractions, and multiplications by powers of 2. (Of course, these multiplications are not more efficient than any other multiplication at the Python level, but closer to hardware. this could potentially make a big difference.)

cordic_table_size = 60
cordic_table = [(2**-i, math.atan(2**-i))
                 for i in range(cordic_table_size)]

def arctan_cordic(y, x=1.0):
    """
    Compute arctan(y/x), assuming x positive, via CORDIC-like method.
    """
    r = 0.0
    for t, a in cordic_table:
        if y < 0:
            r, x, y = r - a, x - t*y, y + t*x
        else:
            r, x, y = r + a, x + t*y, y - t*x
    return r

      

        
        
        
      

    

Each of the above methods have their own strengths and weaknesses, and all of the above code can be improved in many ways. I recommend that you experiment and research.

To wrap it all up, here are the results of calling the above functions on a small number of not very carefully selected test values ​​compared to the output of the standard library math.atan

function:

test_values = [2.314, 0.0123, -0.56, 168.9]
for value in test_values:
    print("{:20.15g} {:20.15g} {:20.15g} {:20.15g}".format(
        math.atan(value),
        arctan_taylor_with_reduction(value),
        arctan_from_tan(value),
        arctan_cordic(value),
    ))

      

        
        
        
      

    

Output on my machine:

    1.16288340166519     1.16288340166519     1.16288340166519     1.16288340166519
     0.0122993797673      0.0122993797673   0.0122993797673002   0.0122993797672999
  -0.510488321916776   -0.510488321916776   -0.510488321916776   -0.510488321916776
    1.56487573286064     1.56487573286064     1.56487573286064     1.56487573286064