Angle difference between two bearings: Difference between revisions

 

=={{header|11l}}==

R wrap(b2 - b1, -180.0, 180.0)

 

print(get_difference(-165313.6666297357, 33693.9894517456))

print(get_difference(1174.8380510598456, -154146.66490124757))

 

{{out}}

=={{header|360 Assembly}}==

{{trans|Rexx}}

ANGLEDBB CSECT

USING ANGLEDBB,R13 base register

XDEC DS CL12 temp

YREGS

{{out}}

<pre>

-78.3251 -159.0360 -80.7109

</pre>

 

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

INT FUNC AngleI(INT a1,a2)

TestR("1174.8380510598456","-154146.66490124757")

TestR("60175.77306795546","42213.07192354373")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Angle_difference_between_two_bearings.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

Ada does not provide a built-in mod function for floating point types. This program supplies one.

-----------------------------------------------------------------------

-- Angle difference between two bearings

end Bearing_Angles;

{{out}}

<pre>

Difference between -154146.6649 and 1174.8381 is -161.5030

Difference between 42213.0719 and 60175.7731 is 37.2989

</pre>

 

=={{header|APL}}==

Returns an angle in (-180,180]; so two opposite bearings have a difference of 180 degrees, which is more natural than -180 degrees.

[1] D←180+¯360|180+B2-B1

{{out}}

<pre> 'B1' 'B2' 'DIFFERENCE'⍪(⊂'¯¯¯¯¯¯¯¯¯¯')⍪(⊃B),DIFF/¨B

</pre>

 

=={{header|Arturo}}==

{{trans|Ruby}}

r: (b2 - b1) % 360.0

 

print getDifference neg 165313.6666297357 33693.9894517456

print getDifference 1174.8380510598456 neg 154146.66490124757

 

{{out}}

 

=={{header|AutoHotkey}}==

,[-45, 45]

,[-85, 90]

Angle_difference_between_two_bearings(set){

return (diff := Mod(set.2, 360) - Mod(set.1, 360)) >180 ? diff-360 : diff

{{out}}

<pre>45 to 20 = 25

 

=={{header|AWK}}==

# syntax: GAWK -f ANGLE_DIFFERENCE_BETWEEN_TWO_BEARINGS.AWK

BEGIN {

return(r)

}

{{out}}

<pre>

 

=={{header|BASIC}}==

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

r! = (b2 - b1) MOD 360!

IF r >= 180! THEN r = r - 360!

CALL getDifference(-70099.74233810938#, 29840.67437876723#)

CALL getDifference(-165313.6666297357#, 33693.9894517456#)

 

==={{header|True BASIC}}===

LET r = REMAINDER(b2-b1, 360.0)

IF r >= 180.0 THEN LET r = r-360.0

CALL getdifference(-165313.6666297357, 33693.9894517456)

CALL getdifference(1174.8380510598456, -154146.66490124757)

 

=={{header|BASIC256}}==

{{trans|Python}}

# by Jjuanhdez, 06/2022

 

if r >= 180.0 then r -= 360.0

print ljust(b1,16); ljust(b2,16); ljust(r,12)

 

=={{header|Befunge}}==

>&:v >859**%:459**1-`#v_ >12g!:12p#v_\-:459**1-`#v_ >.>

>0`#^_8v >859**-^ >859**-^

^:+**95< > ^

The labelled points are:

1. Initialise write/not write and read input,

25 90 175 -175 170 -170 -117 -81 -141 -74 -160 38

</pre>

 

=={{header|C}}==

This implementation either reads two bearings from the console or a file containing a list of bearings. Usage printed on incorrect invocation.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Invocation and output for two bearings :

<pre>

 

=={{header|C sharp|C#}}==

 

namespace Angle_difference_between_two_bearings

}

}

{{out| Output}}

<pre>Hello World!

 

=={{header|C++}}==

#include <iostream>

using namespace std;

 

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(let [r (mod (- b a) 360)]

(if (>= r 180)

(angle-difference -95 90) ; -175

(angle-difference -70099.74 29840.67) ; -139.59

 

=={{header|COBOL}}==

******************************************************************

* COBOL solution to Angle difference challange

* 012 37.2989

******************************************************************

 

=={{header|Common Lisp}}==

(defun angle-difference (b1 b2)

(let ((diff (mod (- b2 b1) 360)))

(decf diff 360)

diff))))

{{out| Output}}

<pre>

 

</pre>

 

=={{header|D}}==

{{trans|Java}}

 

double getDifference(double b1, double b2) {

writeln(getDifference(1174.8380510598456, -154146.66490124757));

writeln(getDifference(60175.77306795546, 42213.07192354373));

 

{{out}}

=={{header|Delphi}}==

See [[#Pascal]].

=={{header|Erlang}}==

The real number calculations are done using integer arithmetic to better handle

The module is tested by running the test function, which in turn matches expected results

with the result of function call.

-module(bearings).

 

 

passed.

 

=={{header|Excel}}==

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(ab,

DEGREES(

) * ACOS((ax * bx) + (ay * by))

)

 

Using an Excel custom number format to display the degree symbol°

 

=={{header|F Sharp|F#}}==

let r = (b2 - b1) % 360.0;

if r > 180.0 then

printfn "%A" (deltaBearing 1174.8380510598456 -154146.66490124757)

printfn "%A" (deltaBearing 60175.77306795546 42213.07192354373)

{{out}}

<pre>25.0

{{trans|F#}}

{{works with|Factor|0.99 development release 2019-03-17}}

IN: rosetta-code.bearings

 

[ delta-bearing . ] 2 12 mnapply ;

 

{{out}}

<pre>

=={{header|Forth}}==

Developed with Gforth 0.7.9_20211014 using floating point math.

: Angle-Difference-stack ( b1 b2 - a +/-180)

\ Algorithm with stack manipulation without branches ( s. Frotran Groovy)

Angle-Difference-const f.

;

{{out}}

<pre>

As it happens, the test data did not provoke any objections from the ACOSD function, but even so, a conversion to using ''arctan'' instead of ''arccos'' to recover angles would be safer. By using the four-quadrant ''arctan(x,y)'' function, the sign of the angle difference is also delivered and although that result could be in 0°-360° it turns out to be in ±180° as desired. On the other hand, the library of available functions did not include an arctan for complex parameters, so the complex number Z had to be split into its real and imaginary parts, thus requiring two appearances and to avoid repeated calculation, a temporary variable Z is needed. Otherwise, the statement could have been just <code>T = ATAN2D(Z1*CONJG(Z2))</code> and the whole calculation could be effected in one statement, <code>T = ATAN2D(CIS(90 - B1)*CONJG(CIS(90 - B2)))</code> And, since ''cis(t) = exp(i.t)'', <code>T = ATAN2D(EXP(CMPLX(0,90 - B1))*CONJG(EXP(CMPLX(0,90 - B2))))</code> - although using the arithmetic statement function does seem less intimidating.

 

REAL*8 B1,B2 !Maximum precision, for large-angle folding.

COMPLEX*16 CIS,Z1,Z2,Z !Scratchpads.

END DO

 

The output shows the stages:

<pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> b1 b2 difference

1174.8380510598461 -154146.6649012475973 -161.5029523074336

60175.7730679554588 42213.0719235437282 37.2988555882694</pre>

 

=={{header|Go}}==

 

One feature of this solution is that if you can rely on the input bearings being in the range -180 to 180, you don't have to use math.Mod. Another feature is the bearing type and method syntax.

 

import "fmt"

return d

}

{{out}}

<pre>

 

A feature here is that the function body is a one-liner sufficient for the task test cases.

 

import (

func angleDifference(b2, b1 float64) float64 {

return math.Mod(math.Mod(b2-b1, 360)+360+180, 360) - 180

{{out}}

<pre>

'''Solution A:'''

{{trans|C++}}

r = (b2 - b1) % 360.0

(r > 180.0 ? r - 360.0

: r <= -180.0 ? r + 360.0

: r)

 

'''Solution B:'''<br>

In the spirit of the [[Angle_difference_between_two_bearings#Fortran|Fortran]] "Why branch when you can math?" solution, but without all the messy trigonometry.

((b2 - b1) % 360.0 - 540.0) % 360.0 + 180.0

NOTE: We could ADD 540 and SUBTRACT 180 instead (as did many others, notably [[Angle_difference_between_two_bearings#360_Assembly|360_Assembly]], [[Angle_difference_between_two_bearings#NewLISP|NewLISP]], [[Angle_difference_between_two_bearings#Racket|Racket]], and [[Angle_difference_between_two_bearings#REXX|REXX]]). The difference is that my choice normalizes "about face" to +180° while the other (At least in [https://rosettacode.org/wiki/Category:Groovy Groovy] and other [https://rosettacode.org/wiki/Category:C C]-derived languages) normalizes "about face" to -180°.

 

'''Test:'''

[

[b1: 20, b2: 45 ],

def (b1,b2) = bearings.values().collect{ it as double }

printf ("%22.13f %22.13f %22.13f %22.13f\n", b1, b2, angleDifferenceA(b1, b2), angleDifferenceB(b1, b2))

 

'''Output:'''

 

=={{header|Haskell}}==

import Data.Bifunctor (bimap)

import Text.Printf (printf)

 

---------- ANGLE DIFFERENCE BETWEEN TWO BEARINGS ---------

 

bearingDelta :: (Radians, Radians) -> Radians

| otherwise = -1

 

 

--------------------------- TEST -------------------------

 

radians :: Degrees -> Radians

{{Out}}

<pre> 20.00° - 45.00° -> 25.00°

 

=={{header|IS-BASIC}}==

110 INPUT PROMPT "2. angle: ":A2

120 LET B=MOD(A2-A1,360)

130 IF B>180 THEN LET B=B-360

140 IF B<-180 THEN LET B=B+360

 

=={{header|J}}==

 

20 45

-45 45

1174.8380510598456 -154146.66490124757

60175.77306795546 42213.07192354373

20 45 25

_45 45 90

_165314 33694 _72.3439

1174.84 _154147 _161.503

 

=={{header|Java}}==

{{trans|C++}}

 

public static double getDifference(double b1, double b2) {

System.out.println(getDifference(60175.77306795546, 42213.07192354373));

}

 

{{out}}

This approach should be reliable but it is also very inefficient.

 

{

b1y = Math.cos(b1Rad);

+relativeBearing(60175.77306795546*deg2rad, 42213.07192354373*deg2rad)*rad2deg+"\n";

 

 

{{out}}

===ES6===

 

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>

 

=={{header|Jsish}}==

function angleDifference(bearing1:number, bearing2:number):number {

var angle = (bearing2 - bearing1) % 360;

60175.7730679555° 42213.0719235437° 37.2988555882694°

=!EXPECTEND!=

 

{{out}}

 

Note that the `%` operator in jq produces integral results.

def subtract($b1; $b2):

10000 as $scale

| subtract($p0; $p1) as $diff

| (if $p0 < 0 then " " else " " end) as $offset

{{out}}

<pre>

{{trans|Python}}

 

 

function angdiff(a, b)

(1174.8380510598456, -154146.66490124757), (60175.77306795546, 42213.07192354373)]

@printf("% 9.1f - % 9.1f = % 6.1f\n", a, b, angdiff(a, b))

 

{{out}}

 

=={{header|K}}==

/ Angle difference between two angles

/ angledif.k

 

angdif: {[b1;b2]; :[(r:(b2-b1)!360.0)<-180.0;r+:360.0;r>180.0;r-:360.0];:r}

 

The output of a session is given below:

=={{header|Klingphix}}==

{{trans|NewLISP}}

 

:bearing sub 360 mod 540 add 360 mod 180 sub ;

pstack

 

{{out}}

<pre>(-25, -90, -175, 175, -170, 170, 118.118, 80.7109, 139.583, 72.3439, 161.503, -37.2989)</pre>

 

=={{header|Kotlin}}==

 

class Angle(d: Double) {

println(f.format(ap.first, ap.second, diff.value))

}

 

{{out}}

Each bearing will be stored in an object that inherits methods to accomplish all parts of the task: accept a new number of degrees, automatically adjusting to the range [-180, 180]; construct new bearing objects; subtract another bearing from itself and return the difference; construct a list of new bearing objects given a list of arbitrary degree sizes; and format the number of degrees into a modest human-readable format. Bearings will be zero-initialized by default if no degree size is provided.

 

 

function bearing:assign(angle)

end

 

 

{{out}}

=={{header|Maple}}==

{{trans|C++}}

local r:

r := frem(b2 - b1, 360):

getDiff(-165313.6666297357,33693.9894517456);

getDiff(1174.8380510598456,-154146.66490124757);

{{Out}}

<pre>25

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

AngleDifference[b1_, b2_] := Mod[b2 - b1, 360, -180]

AngleDifference[20, 45]

AngleDifference[-165313.6666297357, 33693.9894517456]

AngleDifference[1174.8380510598456, -154146.66490124757]

{{out}}

<pre>25

=={{header|Modula-2}}==

{{trans|Java}}

 

PROCEDURE WriteRealLn(value : REAL);

 

ReadChar;

 

=={{header|NewLISP}}==

Taken from Racket solution

 

#!/usr/bin/env newlisp

(define (bearing- bearing heading) (sub (mod (add (mod (sub bearing heading) 360.0) 540.0) 360.0) 180.0))

(bearing- 1174.8380510598456 -154146.66490124757)

(bearing- 60175.77306795546 42213.07192354373))

 

{{out}}

=={{header|Nim}}==

 

import strutils

 

vector.b2.formatFloat(ffDecimal, 2).align(13) &

delta(vector.b1, vector.b2).formatFloat(ffDecimal, 2).align(13)

 

{{out}}

1174.84 -154146.66 -161.50

60175.77 42213.07 37.30

</pre>

 

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

"Input in -180 to +180 range"->PrintLine();

return r;

}

 

{{output}}

=={{header|OCaml}}==

{{trans|D}}

let r = mod_float (b2 -. b1) 360.0 in

if r < -180.0

Printf.printf " %g\n" (get_diff 1174.8380510598456 (-154146.66490124757));

Printf.printf " %g\n" (get_diff 60175.77306795546 42213.07192354373);

 

{{out}}

 

=={{header|PARI/GP}}==

anglediff(x,y)=centerliftmod1((y-x)/360)*360;

vecFunc(f)=v->call(f,v);

{{out}}

<pre>%1 = [25, 90, 175, -175, 170, -170, -118.11840000000000000000000000000000000, -80.710900000000000000000000000000000000, -139.58328312339000000000000000000000023, -72.343918518700000000000000000000000733, -161.50295230741560000000000000000000000, 37.298855588269999999999999999999999909]</pre>

This program is meant to be saved in the same folder as a file <code>angles.txt</code> containing the input. Each pair of angles to subtract appears on its own line in the input file.

 

Program Bearings;

{ Reads pairs of angles from a file and subtracts them }

close(angleFile)

End.

 

{{in}}

=={{header|Perl}}==

Perl's built-in modulo is integer-only, so import a suitable one from the <code>POSIX</code> core module

 

sub angle {

printf "%10.2f %10.2f = %8.2f\n", $b1, $b2, angle($b1,$b2);

}

{{out}}

<pre> 20.00 45.00 = 25.00

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">tz</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">-- trim trailing zeroes and decimal point</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1174.8380510598456</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">154146.66490124757</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">60175.77306795546</span><span style="color: #0000FF;">,</span><span style="color: #000000;">42213.07192354373</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Phixmonti}}==

 

( "16" 1 "16" 1 "16" ) var al

-165313.6666297357 33693.9894517456 test

1174.8380510598456 -154146.66490124757 test

{{out}}

<pre> b1 b2 diff

examples with ''Get-Examples''. There is also a full help file accessed by typing

''Get-Help Get-AngleDiff -full''

<#

.Synopsis

 

 

 

'''Results of user inputs'''<br>

using -45 and 98 with ''Get-AngleDiff'':

 

'''Results of ''Get-Examples'''''

The difference between 60175.7730679555 and 42213.0719235437 is 37.2988555882694

</pre>

 

=={{header|Python}}==

{{trans|C++}}

def getDifference(b1, b2):

print (getDifference(-165313.6666297357, 33693.9894517456))

print (getDifference(1174.8380510598456, -154146.66490124757))

 

{{out}}

Or, generalising a little by deriving the degrees from a (Radians -> Radians) function, and formatting the output in columns:

{{Works with|Python|3.7}}

 

from math import (acos, cos, pi, sin)

 

if __name__ == '__main__':

{{Out}}

<pre>Difference between two bearings:

The table output use print formatting only available from python 3. Tested with 3.6.

{{Works with|Python|3.6}}

Difference between two bearings

"""

print('.{:-^19}.{:-^19}.{:-^9}.' .format(" b1 ", " b2 ", " Δ b " ))

for Δ in dataSet:

{{Out}}

<pre>.------- b1 --------.------- b2 --------.-- Δ b --.

Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.

 

 

[ v- -v

$->v drop

angledelta

 

{{out}}

''see my comments in discussion regards bearing-heading or vice versa''

 

(define (% a b) (- a (* b (truncate (/ a b)))))

 

(check-equal? (% 17.5 10) 7.5)

(check-equal? (% -7.5 10) -7.5)

 

{{out}}

{{works with|Rakudo|2016.11}}

 

(my $b = ($b2 - $b1 + 720) % 360) > 180 ?? $b - 360 !! $b;

}

60175.77306795546, 42213.07192354373

 

{{out}}

<pre> 20.00 45.00 = 25.00

=={{header|REXX}}==

Some extra coding was added for a better visual presentation; &nbsp; the angles were centered, &nbsp; the answers were aligned.

numeric digits 25 /*use enough dec. digits for angles*/

call show 20, 45 /*display angular difference (deg).*/

if pos(., x)\==0 then x=strip( strip(x, 'T', 0), "T", .) /*strip trailing chaff.*/

say center(a || $, d) '─' center(b || $, d) " ────► " x || $

{{out|output}}

<pre>

 

=={{header|Ring}}==

# Project : Angle difference between two bearings

 

end

return r

Output:

<pre>

-118.1184

-80.7109

</pre>

 

=={{header|Ruby}}==

{{trans|C++}}

r = (b2 - b1) % 360.0

# Ruby modulus has same sign as divisor, which is positive here,

puts getDifference(1174.8380510598456, -154146.66490124757)

puts getDifference(60175.77306795546, 42213.07192354373)

 

{{out}}

 

=={{header|Run BASIC}}==

r = (b2 - b1) mod 360

if r >= 180 then r = r - 360

call getDifference -70099.74233810938, 29840.67437876723

call getDifference -165313.6666297357, 33693.9894517456

 

=={{header|Rust}}==

/// Calculate difference between two bearings, in -180 to 180 degrees range

pub fn angle_difference(bearing1: f64, bearing2: f64) -> f64 {

}

}

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/lH5eUix/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/IgQSmzcjSpSMxvWWoZUc9w Scastie (remote JVM)].

private def getDifference(b1: Double, b2: Double) = {

val r = (b2 - b1) % 360.0

println(getDifference(60175.77306795546, 42213.07192354373))

 

 

=={{header|Scheme}}==

R6RS standard.

 

(import (rnrs base (6))

(display (apply bearing-difference argument-list))

(newline))

 

{{out}}

which can be used to solve this task easily.

 

include "float.s7i";

 

writeln(getDifference(1174.8380510598456, -154146.66490124757));

writeln(getDifference(60175.77306795546, 42213.07192354373));

 

{{out}}

 

=={{header|Sidef}}==

(var b = ((b2 - b1 + 720) % 360)) > 180 ? (b - 360) : b

}

) {

printf("%25s %25s %25s\n", b1, b2, bearingAngleDiff(b1, b2))

{{out}}

<pre> B1 B2 Difference

=={{header|Swift}}==

 

let diff = (a2 - a1).truncatingRemainder(dividingBy: 360)

 

]

 

 

{{out}}

 

=={{header|Tcl}}==

proc angleDiff {b1 b2} {

set angle [::tcl::mathfunc::fmod [expr ($b2 - $b1)] 360]

puts [angleDiff 1174.8380510598456 -154146.66490124757]

puts [angleDiff 60175.77306795546 42213.07192354373]

{{out}}

<pre>

 

=={{header|VBA}}==

Dim s As String

s = CStr(Format(a, "0.######"))

test 1174.83805105985, -154146.664901248

test 60175.7730679555, 42213.0719235437

<pre> b1 b2 diff

---------------- ---------------- ----------------

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function Delta_Bearing(b1 As Decimal, b2 As Decimal) As Decimal

End Sub

 

{{out}}

<pre>25

37.2988555882</pre>

 

{{trans|go}}

type Bearing = f64

fn angle_difference(b2 Bearing, b1 Bearing) Bearing {

return math.mod(math.mod(b2-b1, 360)+360+180, 360) - 180

 

{{out}}

 

=={{header|Wren}}==

var d = (b2 - b1) % 360

if (d < -180) d = d + 360

var offset = (p0 < 0) ? " " : " "

System.print("%(offset)%(p0) and %(p1) -> %(diff)")

 

{{out}}

 

=={{header|XBS}}==

class Bearing {

private method construct(Angle:number=0)

set b2:Bearing=new Bearing(v[1]);

log(b2::ToString()+" - "+b1::ToString()+" = "+(b2-b1)::ToString());

{{out}}

<pre>

Pairs of bearing angles are input from the console or from a file

(terminated with Ctrl+C) redirected on the command line.

[Text(0, " Bearing 1 Bearing 2 Difference");

loop [B1:= RlIn(1);

RlOut(0, Ang);

];

 

{{out}}

=={{header|Yabasic}}==

{{trans|Python}}

// by Jjuanhdez, 06/2022

 

if r >= 180.0 r = r - 360.0

print r

 

=={{header|zkl}}==

{{trans|Raku}}

( (b:=(0.0 + b2 - b1 + 720)%360) > 180 ) and b - 360 or b;

.pump(Console.println,Void.Read,

fcn(b1,b2){ "%.1f\UB0; + %.1f\UB0; = %.1f\UB0;"

{{out}}

<pre>