Find the angle between two points

Question

Given two points A and B, find the angle from line AO to line BO about point O where O is the origin ((0,0)). Additionally, the angle may be positive or negative depending on the positions of the points (see examples). Input will be points A and B, and may be given in any convenient form. Output will be the angle in degrees (but it is positive if AO is rotated counter-clockwise about the origin to get BO and negative if it is rotated clockwise). If the angle is 180 degrees you may return a negative or positive output. Similarly, the angle can be the positive or negative version of the same angle (90 deg is equal to -270 deg). Examples:

• Input: A(5,5) B(5,-5) Output: -90 (AO is rotated -90 degrees to get BO).

• Input: A(5,-5) B(5,5) Output: 90 (AO is rotated 90 degrees to get BO).

This is code-golf, so shortest code in bytes wins!

Answer 1

TI-BASIC, 13 bytes

For TI-83+/84+ series calculators.

Degree
Input Y
min(ΔList(R►Pθ(Ans,∟Y

To use this program, enter the list {x1,x2} through the Ans variable, and {y1,y2} at the prompt.

Answer 2

Pyth, 11 bytes

.t-FPM.jMQ6

Demonstration

Input is given in the format:

[[Bx, By], [Ax, Ay]]

If it is desired that A comes first, this can be changed for 1 byte.

Explanation:

.t-FPM.jMQ6
               Implicit: Q = eval(input())
      .jMQ     Convert input pairs to complex numbers.
    PM         Take their phases (angles in the complex plane).
  -F           Take the difference.
.t        6    Convert to degrees

Answer 3

CJam, 14 bytes

q~::ma:-P/180*

This is a full program that reads the input as [[Ax Ay] [Bx By]] from STDIN.

Try it online in the CJam interpreter.

How it works

q~             e# Read and evaluate all input.
  ::ma         e# Replace each point (x, y) with atan2(x, y).
               e# This returns its angle with the positive y axis, measured clockwise.
      :-       e# Compute the difference of the two resulting angles.
               e# This returns the angle between the points, measured counter-clockwise.
        P/180* e# Divide by Pi and multiply by 180 to convert to degrees.

Answer 4

Minkolang 0.9, 112 bytes

I really want to implement trig functions as built-ins now...but this was fun! (Caveat: this outputs the positive angle difference, not the signed angle difference. Given my limitations, I think that's justified.)

4[n]0c2c*1c3c*+r4[2;1R]r+1R+0g*12$:;$:8[0ci2*3+d1R;0g$:1i1+[i2*1+d1+$:*]*]$+'3.141592654'25*9;$:$:12$:r-66*5**N.

Try it here.

Explanation

I'll post a fuller explanation if anyone wants it, but the gist of it is:

4[n]                                    Take in 4 integers from input
0c2c*1c3c*+                             dot product
r4[2;1R]r+1R+0g*12$:;                   magnitudes of vectors
$:                                      dot product divided by magnitudes (z)
8[0ci2*3+d1R;0g$:1i1+             *]    Taylor series for arccos
                     [i2*1+d1+$:*]      In particular, the coefficient (1/2 * 3/4 * ...)
$+                                      Add them all up!
'3.141592654'25*9;$:$:                  Divide by pi for converting to degrees
12$:r-                                  Subtract from 1/2 - I now have arccos(z)
66*5**                                  Convert to degrees
N.                                      Output as number and stop.

Answer 5

Mathematica, 22 bytes

{-1,1.}.ArcTan@@@#/°&

Example:

In[1]:= {-1,1.}.ArcTan@@@#/°&[{{5,5},{5,-5}}]

Out[1]= -90.

In[2]:= {-1,1.}.ArcTan@@@#/°&[{{5,-5},{5,5}}]

Out[2]= 90.

Answer 6

Julia, 18 25 bytes

f(A,B)=angle(B/A)/pi*180

This assumes that "any convenient form" already allows for A and B to be given as complex numbers. Then, the complex number arithmetic does all the heavy lifting.

Edit: converted snippet to function. 18 byte version only works in the Julia REPL.

Answer 7

Python 2.7, 73 Bytes

from math import*
f=lambda A,B:degrees(atan2(B[1],B[0])-atan2(A[1],A[0]))

Test:

f((5,5),(5,-5)) #-90.0
f((5,-5),(5,5)) #90.0

Answer 8

Octave, 43 bytes

f=@(a,b)(cart2pol(b)-cart2pol(a))(1)*180/pi

Input/Output:

octave:40> f([5,5],[5,-5])
ans = -90

octave:41> f([1,0],[0,1])
ans = 90

Answer 9

Javascript, 66 bytes

let f=(a,b)=>(Math.atan2(b.y,b.x)-Math.atan2(a.y,a.x))*180/Math.PI;

demo

Answer 10

Ruby, 64, 58 bytes

a=->(b){b.map{|c|Math.atan2(*c)}.reduce(:-)*180/Math::PI}

Usage

a.call [[5, 5], [5, -5]] # => -90.0
a.call [[5, -5], [5, 5]] # => 90.0

Answer 11

JavaScript, 49 bytes

(a,b)=>((c=Math.atan2)(...b)-c(...a))/Math.PI*180

Input is taken in form: [aY, aX], [bY, bX] (notice the reversed x/y)

Answer 12

CJam, 15 bytes

l~ma@@ma-P/180*

Thought I'll get in the CJam game as well. Try it online. Input is in form of bx by ax ay. Unfortunately, this is the shortest method of doing this challenge without copying Dennis' answer.

Answer 13

TeaScript, 28 bytes

I really should of implemented trig functions...

$.atan2(_[3]-y,z-x)*180/$.PI

Try it online input is a.x a.y b.x b.y

Explanation

$.atan2(       // Arc Tangent of...
    _[3] - y,  // 4th input - 2nd input
       z - x,  // 3rd input - 1st input
) * 180 / $.PI // Converts rad -> deg

Answer 14

Simplex v.0.7, 13 bytes

I'm glad I added mathrelations :D Unfortunately, I cannot take pointwise input. So, I input each point as a separate number (Ax, Ay, Bx, By). (I used this as a resource.)

(iRi~^fR)2LSo
(       )2    ~~ repeat inner twice
 iRi          ~~ take two chars of input (x,y)
    ~         ~~ switch top 2 on stack
     ^f       ~~ apply atan2 on (y,x)
       R      ~~ go right
          L   ~~ go left
           S  ~~ subtract result
            o ~~ output as number

I can save a char if I can take input as (Ay, Ax, By, Bx):

(iRi^fR)2LSo

Answer 15

C, 88 bytes

#include<math.h>
typedef double d;d g(d x,d y,d a,d b){return atan2(b-y,a-x)*180/M_PI;}

Requires compiling with GCC to take advantage of M_PI being defined in math.h as a part of GCC's built-in math constants. Try it online - since ideone doesn't use GCC (apparently), an additional few bytes are needed for enough digits of π to be accurate.

Answer 16

Pascal, 68 Bytes

Pascal according to ISO standard 10206 “Extended Pascal” includes complex numbers as a built‑in data type.

function f(A,B:complex):real;begin f:=arg(B/A)*90/arg(cmplx(0,1))end

FreePascal, 71 Bytes

As of version 3.2.0 the FreePascal Compiler (FPC) does not (yet) support (all) Extended Pascal features, but the standard RTL (run‑time library) includes a custom ucomplex UCSD Pascal unit providing a record‑based complex number implementation.

uses uComplex;function f(A,B:complex):real;begin f:=180/pi*carg(B/A)end

Answer 17

Swift, 62 bytes

import Foundation
let f={(atan2($3,$2)-atan2($1,$0))*180/M_PI}

If you're on a Mac, you should be able to replace import Foundation with import Darwin to save 4 bytes.

Answer 18

R, 31 bytes

\(a,b,c,d)atan2(d-b,c-a)/pi*180

A built-in atan2 function.

Attempt This Online!

result:

> f(5,5,5,-5)
[1] -90
> f(5,-5,5,5)
[1] 90