Inverse trigonometric functions

Question

There are 3 (commonly used) trigonometric functions sin cos and tan each of these functions has an inverse function

You goal is to write 3 programs or functions (one for each inverse trigonometric function asin acos atan) that take a (real) number a input and return the result of the corresponding inverse trigonometric function

Examples/Test-cases (rounded to four decimal places)

 x         asin(x)        acos(x)   atan(x)
 
 0         0              1.5708       0
 1         1.5708         0            0.7854
-1        -1.5708         3.1416      -0.7854
 0.2       0.2014         1.3694       0.1974
 0.4       0.4115         1.1593       0.3805
 0.6       0.6435         0.9273       0.5404
-0.5      -0.5236         2.0944      -0.4636
-0.7      -0.7754         2.3462      -0.6107
// you do not need to support these inputs for asin&acos
2      1.5708-1.317i      -1.317i      1.1071
5      1.5708-2.292i      -2.292i      1.3734
10     1.5708-2.993i      -2.993i      1.4711
15     1.5708-3.400i      -3.400i      1.5042
20     1.5708-3.688i      -3.688i      1.5208
100    1.5708-5.298i      -5.298i      1.5608

Rules

• Please add built-in solutions to the community wiki
• You may declare multiple functions in the same program, if you provide a way to choose which of the trigonometric functions is applied to the argument (e.g function names, a second argument)
• It is allowed to return a tuple containing the results of multiple functions
• You may take a second parameter, to distinguish between different functions
• Your solutions for asin/acos only have to work for arguments between -1 and 1 (inclusive)
• Your solution only has to be accurate up to three decimal places
• Your score is the sum of the lengths of your program(s)/function(s)

Optional additional requirements

• Also support inputs that give a complex result
• Do not use the complex logarithm (see the Sandbox Post for how the complex logarithm might be useful)

Answer 1

JavaScript (ES7), 94 bytes

Probably not the golfiest way, especially for edge cases.

Returns [atan(x), acos(x), asin(x)].

x=>[(p=1.571,g=x=>1/x?x/(h=k=>k+++k+(k>>9?0:k*k*x*x/h(k)))``:p)(x),c=2*g((1-x*x)**.5/++x),p-c]

Try it online!

Formulas

The arctangent is approximated with the continued fractions:

$$\arctan(x)=\dfrac{x}{1+\dfrac{(1x)^2}{3+\dfrac{(2x)^2}{5+\dfrac{(3x)^2}{7+\ddots}}}}$$

We then use:

$$\arccos(-1)=\pi\\\arccos(x)=2\arctan\left(\frac{\sqrt{1-x^2}}{1+x}\right),\:-1<x\le1$$

and:

$$\arcsin(x)=\frac{\pi}{2}-\arccos(x)$$

(source: Wikipedia)

Answer 2

R, 45 bytes

\(x,f,y=0:4e8/1e8)y[match(T,(f(y)-x)^2<1e-7)]

Attempt This Online! with slightly reduced precision to enable it to run with ATO's reduced memory allowance.

Single function with arguments x=input number, f=trigonometric function to inverse (one of sin, cos or tan). Just within the 3rd-decimal place precision limit, but precision can be increased by increasing the e8 & e-7 in the code to e9 & e-8.

---

R, 67 bytes

\(x,f){while((f(F/T)-x)^2>1e-8)T=`if`(T-1,T+F-(F=F+1),F+(F=1));F/T}

Attempt This Online!

Generalized "inverse" function, which, with arguments x=input number and f=any function, will output a non-negative real number (if it exists) corresponding to the inverse of f applied to x, within a precision of 1e-4 (in other words, the difference between f(inv(x,f)) and x is less than 1e-4).

Answer 3

Built-in solutions

APL(Dyalog Unicode), 1 bytes ^SBCS

○

Try it on APLgolf!

Left argument chooses function:

¯1○⍵ ⍝ asin
¯2○⍵ ⍝ acos
¯3○⍵ ⍝ atan

C, 31 Bytes

#include<math.h>
asin
acos
atan

C++, 30 Bytes

#include<cmath>
asin
acos
atan

Go

28 bytes (reals only)

import."math"
Asin
Acos
Atan

Attempt This Online!

34 bytes (includes complex numbers)

import."math/cmplx"
Asin
Acos
Atan

Attempt This Online!

JavaScript, 29 bytes

Math.asin
Math.acos
Math.atan

Attempt This Online!

Pascal, 6 bytes (only arctan)

arctan

Unfortunately, there is no built-in function to inverse the operations of sin and cos. See the Pascal submission for a full implementation of the task.

Python, 32 bytes (reals only)

from math import*
asin
acos
atan

Attempt This Online!

Python, 33 bytes (includes complex numbers)

from cmath import*
asin
acos
atan

Attempt This Online!

Rust, 29 bytes

f64::asin
f64::acos
f64::atan

sclin, 14 bytes

sin_
cos_
tan_

Try it on scline!

Thunno 2, 2 bytes each

Æs # arcsin
Æc # arccos
Æt # arctan

Try it online!

Vyxal, 2 bytes each

∆S # Arcsine
∆C # Arccosine
∆T # Arctangent

Try it Online!

PHP, 14 bytes

asin
acos
atan

Try it online!

Zsh, 36 bytes

zmodload zsh/mathfunc
asin
acos
atan

Try it online!

Answer 4

Pascal, 162 194 bytes

“Extended Pascal” (ISO standard 10206) defines that complex numbers are part of the language. When calling one of these functions, a real argument is automatically promoted to a complex value (because the formal parameter list says the function requires a complex number).

const i=cmplx(0,1);type r=complex;function s(x:r):r;begin s:=−i*ln(sqrt(1−x*x)+i*x);end;function c(x:r):r;begin c:=−i*ln(sqrt(x*x−1)+x);end;function t(x:r):r;begin t:=i/2*ln((1−i*x)/(1+i*x));end

Ungolfed:

    const
        i = cmplx(0, 1);
    
    function arcsin(protected x: complex): complex;
        begin
            arcsin := −i * ln(sqrt(1 − sqr(x)) + i * x);
        end;
    
    function arccos(protected x: complex): complex;
        begin
            arccos := −i * ln(sqrt(sqr(x) − 1) + x);
        end;
    
    function arctan(protected x: complex): complex;
        begin
            arctan := i / 2 * ln((1 − i * x) / (1 + i * x));
        end;

Arc tangent is actually already part of the language. Both in ISO standard 7185 (“Standard Pascal”) and ISO standard 10206 (“Extended Pascal”) the built-in function arctan is available. Since complex numbers are defined by EP, only the latter accepts and can return complex values.

Answer 5

Perl 5, 172 bytes

sub asin{n(@_,\&CORE::sin)}
sub acos{n(@_,\&CORE::cos)}
sub atan{n(@_,sub{sin(@_)/cos(pop)})}
sub n{$f=pop;$x=1;$x+=(&$f($x)-$_[0])/((&$f($x-1e-6)-&$f($x))*1e6)for 1..9;$x}

Try it online!

Uses Perl's builtin trig functions sin and cos. Since asin, acos and atan aren't builtin, they're rather found in the core lib Math::Trig, but here they're instead written in a Newton's method-ish solver in sub n.

Or 259 bytes:

sub si{my$x=pop;abs$x<1e-8?$x:2*si($x/2)*co($x/2)}
sub co{my$x=pop;abs$x<1e-8?1:co($x/2)**2-si($x/2)**2}
sub ta{&si/&co}
sub asi{n(@_,'si')}
sub aco{n(@_,'co')}
sub ata{n(@_,'ta')}
sub n{$f=pop;$x=1;$x+=(&$f($x)-$_[0])/((&$f($x-1e-6)-&$f($x))*1e6)for 1..9;$x}

Try it online!

...which replaces Perl's sin and cos with si and co that uses the property that sin(x) = x and cos(x) = 1 for small x and the formulas for half angles.

Answer 6

Charcoal, 132 125 bytes

ＮθＮη⊞υ¹⊞υ∧›⁰ηθ≔⁰ζ≔²εＦ⁵⁰«≔₂⊕Ｘε²δ≔¹ιＦχ«≔⊘⁺ιδι≔₂×ιδδ»≔∨⎇⊕η⁼›⁰§υη⎇η›θ§υ⁰›§υ¹θ›⁰§υ¹±¹δＵＭυ⁺κ×××δε§υ¬λ∨λ±¹≧⁺×∨η¹×δ∕ειζ≧×₂⊕×εεθ≦⊘ε»Ｉζ

Try it online! Link is to verbose version of code. Takes the function as the second argument where -1=atan, 0=asin and 1=acos. Explanation: Uses CORDIC to calculate the inverse functions. Edit: Switched to single-angle CORDIC for asin and acos to save 7 bytes.

Ｎθ

Input the real value.

Ｎη

Input the function code.

⊞υ¹

Start with z[0]=1.

⊞υ∧›⁰ηθ

Start with z[1]=0, except for atan, where the input is used.

≔⁰ζ

Start with a resulting angle of 0.

≔²ε

Start with 2 as the first power of 0.5. This is needed for acos to work with negative inputs, but doesn't affect asin or atan.

Ｆ⁵⁰«

Loop 50 times, as unfortunately 10 isn't accurate enough.

≔₂⊕Ｘε²δ≔¹ιＦχ«≔⊘⁺ιδι≔₂×ιδδ»

Start calculating the atan of the power of 0.5. (Yes, I could do the atan separately, but that would duplicate code, increasing my byte count.)

≔∨⎇⊕η⁼›⁰§υη⎇η›θ§υ⁰›§υ¹θ›⁰§υ¹±¹δ

Determine whether we are increasing or decreasing the angle.

ＵＭυ⁺κ×××δε§υ¬λ∨λ±¹

Rotate z by the atan of the power of 0.5.

≧⁺×∨η¹×δ∕ειζ

Update the angle.

≧×₂⊕×εεθ

Compensate for rotation's scaling factor (no effect for atan). Note that in a real FPGA you would approximate the square root but that doesn't help me here.

≦⊘ε

Get the next power of 0.5.

»Ｉζ

Output the final angle.