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

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

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

{{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**-^

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

=={{header|D}}==

{{trans|Java}}

 

double getDifference(double b1, double b2) {

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

 

 

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

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

 

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

 

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

=={{header|Vlang}}==

{{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;"