Angle difference between two bearings: Difference between revisions

 

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

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

 

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

{{trans|Rexx}}

ANGLEDBB CSECT

USING ANGLEDBB,R13 base register

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program diffAngle64.s */

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

INT FUNC AngleI(INT a1,a2)

=={{header|Ada}}==

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

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

-- Angle difference between two bearings

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

</syntaxhighlight>

180

</pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI or android with termux */

/* program diffAngle.s */

=={{header|Arturo}}==

{{trans|Ruby}}

r: (b2 - b1) % 360.0

 

 

=={{header|AutoHotkey}}==

,[-45, 45]

,[-85, 90]

 

=={{header|AWK}}==

# syntax: GAWK -f ANGLE_DIFFERENCE_BETWEEN_TWO_BEARINGS.AWK

BEGIN {

 

=={{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!

 

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

LET r = REMAINDER(b2-b1, 360.0)

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

=={{header|BASIC256}}==

{{trans|Python}}

# by Jjuanhdez, 06/2022

 

 

=={{header|Befunge}}==

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

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

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>

 

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

 

namespace Angle_difference_between_two_bearings

 

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

#include <iostream>

using namespace std;

 

=={{header|Clojure}}==

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

(if (>= r 180)

 

=={{header|COBOL}}==

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

* COBOL solution to Angle difference challange

 

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

(defun angle-difference (b1 b2)

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

 

</pre>

 

=={{header|D}}==

{{trans|Java}}

 

double getDifference(double b1, double b2) {

=={{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).

 

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(ab,

DEGREES(

 

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

let r = (b2 - b1) % 360.0;

if r > 180.0 then

{{trans|F#}}

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

IN: rosetta-code.bearings

 

=={{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)

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.

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

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"

 

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

 

import (

'''Solution A:'''

{{trans|C++}}

r = (b2 - b1) % 360.0

(r > 180.0 ? r - 360.0

'''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

}</syntaxhighlight>

 

'''Test:'''

[

[b1: 20, b2: 45 ],

 

=={{header|Haskell}}==

import Data.Bifunctor (bimap)

import Text.Printf (printf)

 

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

110 INPUT PROMPT "2. angle: ":A2

120 LET B=MOD(A2-A1,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) {

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

 

{

b1y = Math.cos(b1Rad);

===ES6===

 

"use strict";

 

 

=={{header|Jsish}}==

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

var angle = (bearing2 - bearing1) % 360;

 

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

def subtract($b1; $b2):

10000 as $scale

{{trans|Python}}

 

 

function angdiff(a, b)

 

=={{header|K}}==

/ Angle difference between two angles

/ angledif.k

=={{header|Klingphix}}==

{{trans|NewLISP}}

 

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

 

=={{header|Kotlin}}==

 

class Angle(d: Double) {

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)

=={{header|Maple}}==

{{trans|C++}}

local r:

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

 

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

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

AngleDifference[20, 45]

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

{{trans|Java}}

 

PROCEDURE WriteRealLn(value : REAL);

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))

=={{header|Nim}}==

 

import strutils

 

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();

=={{header|OCaml}}==

{{trans|D}}

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

if r < -180.0

 

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

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

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

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 }

=={{header|Perl}}==

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

 

sub angle {

 

=={{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>

 

=={{header|Phixmonti}}==

 

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

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'':

The difference between -45 and 98 is 143</syntaxhighlight>

 

=={{header|PureBasic}}==

{{trans|Python}}

r.f = Mod((b2 - b1), 360)

If r >= 180: r - 360

=={{header|Python}}==

{{trans|C++}}

def getDifference(b1, b2):

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)

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

{{Works with|Python|3.6}}

Difference between two bearings

"""

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

 

 

[ v- -v

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

 

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

 

{{works with|Rakudo|2016.11}}

 

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

}

=={{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).*/

 

=={{header|Ring}}==

# Project : Angle difference between two bearings

 

-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,

 

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

r = (b2 - b1) mod 360

if r >= 180 then r = r - 360

 

=={{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

=={{header|Scheme}}==

R6RS standard.

 

(import (rnrs base (6))

which can be used to solve this task easily.

 

include "float.s7i";

 

 

=={{header|Sidef}}==

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

}

=={{header|Swift}}==

 

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

 

 

=={{header|Tcl}}==

proc angleDiff {b1 b2} {

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

 

=={{header|VBA}}==

Dim s As String

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

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

{{trans|C#}}

 

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

37.2988555882</pre>

 

{{trans|go}}

type Bearing = f64

 

=={{header|Wren}}==

var d = (b2 - b1) % 360

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

 

=={{header|XBS}}==

class Bearing {

private method construct(Angle:number=0)

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);

=={{header|Yabasic}}==

{{trans|Python}}

// by Jjuanhdez, 06/2022

 

=={{header|zkl}}==

{{trans|Raku}}

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

}</syntaxhighlight>

.pump(Console.println,Void.Read,

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