Angle difference between two bearings: Difference between revisions
Content deleted Content added
Added Wren |
|||
(71 intermediate revisions by 34 users not shown) | |||
Line 8:
<br>Input bearings are expressed in the range '''-180''' to '''+180''' degrees.
<br>The result is also expressed in the range '''-180''' to '''+180''' degrees.
Line 34:
=={{header|11l}}==
<
R wrap(b2 - b1, -180.0, 180.0)
Line 51:
print(get_difference(-165313.6666297357, 33693.9894517456))
print(get_difference(1174.8380510598456, -154146.66490124757))
print(get_difference(60175.77306795546, 42213.07192354373))</
{{out}}
Line 74:
=={{header|360 Assembly}}==
{{trans|Rexx}}
<
ANGLEDBB CSECT
USING ANGLEDBB,R13 base register
Line 120:
XDEC DS CL12 temp
YREGS
END ANGLEDBB</
{{out}}
<pre>
Line 131:
29.4803 -88.6361 -118.1164
-78.3251 -159.0360 -80.7109
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program diffAngle64.s */
/************************************/
/* Constantes */
/************************************/
.include "../includeConstantesARM64.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szCarriageReturn: .asciz "\n"
szMessResult: .asciz "Difference between @ and @ = @ \n"
.align 8
fB1: .double 0F20.0
fB2: .double 0F45.0
fB3: .double 0F-45.0
fB4: .double 0F-85.0
fB5: .double 90.0
fB6: .double -95.0
fB7: .double 125.0
fB8: .double 145.0
fB9: .double 0F29.4803
fB10: .double 0F-88.6381
fB11: .double 0F-78.3251
fB12: .double 0F-159.036
fB13: .double 0F-70099.74233810938
fB14: .double 0F29840.67437876723
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main:
ldr x0,qAdrfB1
ldr x1,qAdrfB2
bl testComputeAngle
//b 100f
ldr x0,qAdrfB3
ldr x1,qAdrfB2
bl testComputeAngle
ldr x0,qAdrfB4
ldr x1,qAdrfB5
bl testComputeAngle
ldr x0,qAdrfB6
ldr x1,qAdrfB5
bl testComputeAngle
ldr x0,qAdrfB3
ldr x1,qAdrfB7
bl testComputeAngle
ldr x0,qAdrfB3
ldr x1,qAdrfB8
bl testComputeAngle
ldr x0,qAdrfB9
ldr x1,qAdrfB10
bl testComputeAngle
ldr x0,qAdrfB11
ldr x1,qAdrfB12
bl testComputeAngle
ldr x0,qAdrfB13
ldr x1,qAdrfB14
bl testComputeAngle
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsZoneConv: .quad sZoneConv
qAdrfB1: .quad fB1
qAdrfB2: .quad fB2
qAdrfB3: .quad fB3
qAdrfB4: .quad fB4
qAdrfB5: .quad fB5
qAdrfB6: .quad fB6
qAdrfB7: .quad fB7
qAdrfB8: .quad fB8
qAdrfB9: .quad fB9
qAdrfB10: .quad fB10
qAdrfB11: .quad fB11
qAdrfB12: .quad fB12
qAdrfB13: .quad fB13
qAdrfB14: .quad fB14
/******************************************************************/
/* compute difference and display result */
/******************************************************************/
/* s0 contains bearing 1 */
/* s1 contains bearing 2 */
testComputeAngle:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
ldr d0,[x0]
fmov d2,d0
ldr d1,[x1]
bl computeDiffAngle
fmov d3,d0
fmov d0,d2
ldr x0,qAdrsZoneConv
bl convertirFloat
ldr x0,qAdrszMessResult
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc
mov x3,x0
fmov d0,d1
ldr x0,qAdrsZoneConv
bl convertirFloat
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc
mov x3,x0
fmov d0,d3
ldr x0,qAdrsZoneConv
bl convertirFloat
mov x0,x3
ldr x1,qAdrsZoneConv
bl strInsertAtCharInc
bl affichageMess
100:
ldp x2,x3,[sp],16 // restaur registers
ldp x1,lr,[sp],16 // restaur registers
ret
qAdrszMessResult: .quad szMessResult
/******************************************************************/
/* compute difference of two bearing */
/******************************************************************/
/* d0 contains bearing 1 */
/* d1 contains bearing 2 */
computeDiffAngle:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
stp x4,x5,[sp,-16]! // save registers
stp d1,d2,[sp,-16]! // save registres
stp d3,d4,[sp,-16]! // save registres
mov x1,#360
mov x4,#0 // top positive/negative
fcvtzs d4,d0 // conversion.integer
scvtf d2,d4 // conversion float
fsub d2,d0,d2 // partie décimale
fmov x0,d4 // partie entière
cmp x0,#0 // negative ?
bge 1f
neg x0,x0 // yes -> inversion
mov x4,#1
1:
udiv x2,x0,x1 // divide by 360
msub x3,x2,x1,x0
cmp x4,#0 // value negative ?
neg x5,x3
csel x3,x5,x3,ne // inversion remainder
fmov d3,x3
scvtf d3,d3 // and conversion float
fadd d0,d3,d2 // add decimal part
mov x4,#0 // bearing 2
fcvtzs d4,d1 // conversion integer
scvtf d2,d4 // conversion float
fsub d2,d1,d2 // partie décimale
fmov x0,d4
cmp x0,#0
bge 2f
neg x0,x0
mov x4,#1
2:
udiv x2,x0,x1 // divide by 360
msub x3,x2,x1,x0
cmp x4,#0
neg x5,x3
csel x3,x5,x3,ne // inversion remainder
fmov d3,x3
scvtf d3,d3 // conversion float
fadd d1,d3,d2
fsub d0,d1,d0 // calculate the difference between the 2 values
mov x0,180
fmov d3,x0
scvtf d3,d3 // conversion float 180
fmov d4,x1 // 360
scvtf d4,d4 // conversion float 360
fcmp d0,#0.0 // difference is negative ?
blt 2f
// difference is positive
fcmp d0,d4 // difference > 360
ble 3f
fsub d0,d0,d4 // yes -> difference - 360
3:
fcmp d0,d3 // compare difference and 180
ble 100f
fsub d0,d4,d0 // > 180 calculate 360 - difference
fneg d0,d0 // and negate
b 100f
2: // différence is négative
fneg d2,d4 // -360
fcmp d0,d2 // compare différence et - 360
ble 3f
fsub d0,d0,d4 // sub 360 to différence
3:
fneg d3,d3 // -180
fcmp d0,d3 // compare difference and -180
bge 100f
fadd d0,d4,d0 // calculate 360 + différence
100:
ldp d3,d4,[sp],16 // restaur registers
ldp d1,d2,[sp],16 // restaur registers
ldp x4,x5,[sp],16 // restaur registers
ldp x2,x3,[sp],16 // restaur registers
ldp x1,lr,[sp],16 // restaur registers
ret
/******************************************************************/
/* Conversion Float */
/******************************************************************/
/* d0 contains Float */
/* x0 contains address conversion area mini 20 charactèrs */
/* x0 return result length */
/* see https://blog.benoitblanchon.fr/lightweight-float-to-string/ */
convertirFloat:
stp x1,lr,[sp,-16]! // save registres
stp x2,x3,[sp,-16]! // save registres
stp x4,x5,[sp,-16]! // save registres
stp x6,x7,[sp,-16]! // save registres
stp x8,x9,[sp,-16]! // save registres
stp d1,d2,[sp,-16]! // save registres
mov x6,x0 // save area address
fmov x0,d0
mov x8,#0 // result length
mov x3,#'+'
strb w3,[x6] // signe + forcing
mov x2,x0
tbz x2,63,1f
mov x2,1
lsl x2,x2,63
bic x0,x0,x2
mov x3,#'-' // sign -
strb w3,[x6]
1:
adds x8,x8,#1 // next position
cmp x0,#0 // case 0 positive or negative
bne 2f
mov x3,#'0'
strb w3,[x6,x8] // store character 0
adds x8,x8,#1
strb wzr,[x6,x8] // store 0 final
mov x0,x8 // return length
b 100f
2:
ldr x2,iMaskExposant
mov x1,x0
and x1,x1,x2 // exposant
cmp x1,x2
bne 4f
tbz x0,51,3f // test bit 51 to zéro
mov x2,#'N' // case Nan. store byte no possible store integer
strb w2,[x6] // area no aligned
mov x2,#'a'
strb w2,[x6,#1]
mov x2,#'n'
strb w2,[x6,#2]
mov x2,#0 // 0 final
strb w2,[x6,#3]
mov x0,#3
b 100f
3: // case infini positive or négative
mov x2,#'I'
strb w2,[x6,x8]
adds x8,x8,#1
mov x2,#'n'
strb w2,[x6,x8]
adds x8,x8,#1
mov x2,#'f'
strb w2,[x6,x8]
adds x8,x8,#1
mov x2,#0
strb w2,[x6,x8]
mov x0,x8
b 100f
4:
bl normaliserFloat
mov x5,x0 // save exposant
fcvtzu d2,d0
fmov x0,d2 // part integer
scvtf d1,d2 // conversion float
fsub d1,d0,d1 // extraction part fractional
ldr d2,dConst1
fmul d1,d2,d1 // to crop it in full
fcvtzu d1,d1 // convertion integer
fmov x4,d1 // fract value
// conversion part integer to x0
mov x2,x6 // save address begin area
adds x6,x6,x8
mov x1,x6
bl conversion10
add x6,x6,x0
mov x3,#','
strb w3,[x6]
adds x6,x6,#1
mov x0,x4 // conversion part fractionnaire
mov x1,x6
bl conversion10SP
add x6,x6,x0
sub x6,x6,#1
// remove trailing zeros
5:
ldrb w0,[x6]
cmp w0,#'0'
bne 6f
sub x6,x6,#1
b 5b
6:
cmp w0,#','
bne 7f
sub x6,x6,#1
7:
cmp x5,#0 // if exposant = 0 no display
bne 8f
add x6,x6,#1
b 10f
8:
add x6,x6,#1
mov x3,#'E'
strb w3,[x6]
add x6,x6,#1
mov x0,x5 // conversion exposant
mov x3,x0
tbz x3,63,9f // exposant negative ?
neg x0,x0
mov x3,#'-'
strb w3,[x6]
adds x6,x6,#1
9:
mov x1,x6
bl conversion10
add x6,x6,x0
10:
strb wzr,[x6] // store 0 final
adds x6,x6,#1
mov x0,x6
subs x0,x0,x2 // retour de la longueur de la zone
subs x0,x0,#1 // sans le 0 final
100:
ldp d1,d2,[sp],16 // restaur registres
ldp x8,x9,[sp],16 // restaur registres
ldp x6,x7,[sp],16 // restaur registres
ldp x4,x5,[sp],16 // restaur registres
ldp x2,x3,[sp],16 // restaur registres
ldp x1,lr,[sp],16 // restaur registres
ret
iMaskExposant: .quad 0x7FF<<52
dConst1: .double 0f1E17
/***************************************************/
/* normaliser float */
/***************************************************/
/* x0 contain float value (always positive value and <> Nan) */
/* d0 return new value */
/* x0 return exposant */
normaliserFloat:
stp x1,lr,[sp,-16]! // save registers
fmov d0,x0 // value float
mov x0,#0 // exposant
ldr d1,dConstE7 // no normalisation for value < 1E7
fcmp d0,d1
blo 10f // if d0 < dConstE7
ldr d1,dConstE256
fcmp d0,d1
blo 1f
fdiv d0,d0,d1
adds x0,x0,#256
1:
ldr d1,dConstE128
fcmp d0,d1
blo 1f
fdiv d0,d0,d1
adds x0,x0,#128
1:
ldr d1,dConstE64
fcmp d0,d1
blo 1f
fdiv d0,d0,d1
adds x0,x0,#64
1:
ldr d1,dConstE32
fcmp d0,d1
blo 1f
fdiv d0,d0,d1
adds x0,x0,#32
1:
ldr d1,dConstE16
fcmp d0,d1
blo 2f
fdiv d0,d0,d1
adds x0,x0,#16
2:
ldr d1,dConstE8
fcmp d0,d1
blo 3f
fdiv d0,d0,d1
adds x0,x0,#8
3:
ldr d1,dConstE4
fcmp d0,d1
blo 4f
fdiv d0,d0,d1
adds x0,x0,#4
4:
ldr d1,dConstE2
fcmp d0,d1
blo 5f
fdiv d0,d0,d1
adds x0,x0,#2
5:
ldr d1,dConstE1
fcmp d0,d1
blo 10f
fdiv d0,d0,d1
adds x0,x0,#1
10:
ldr d1,dConstME5 // pas de normalisation pour les valeurs > 1E-5
fcmp d0,d1
bhi 100f // fin
ldr d1,dConstME255
fcmp d0,d1
bhi 11f
ldr d1,dConstE256
fmul d0,d0,d1
subs x0,x0,#256
11:
ldr d1,dConstME127
fcmp d0,d1
bhi 11f
ldr d1,dConstE128
fmul d0,d0,d1
subs x0,x0,#128
11:
ldr d1,dConstME63
fcmp d0,d1
bhi 11f
ldr d1,dConstE64
fmul d0,d0,d1
subs x0,x0,#64
11:
ldr d1,dConstME31
fcmp d0,d1
bhi 11f
ldr d1,dConstE32
fmul d0,d0,d1
subs x0,x0,#32
11:
ldr d1,dConstME15
fcmp d0,d1
bhi 12f
ldr d1,dConstE16
fmul d0,d0,d1
subs x0,x0,#16
12:
ldr d1,dConstME7
fcmp d0,d1
bhi 13f
ldr d1,dConstE8
fmul d0,d0,d1
subs x0,x0,#8
13:
ldr d1,dConstME3
fcmp d0,d1
bhi 14f
ldr d1,dConstE4
fmul d0,d0,d1
subs x0,x0,#4
14:
ldr d1,dConstME1
fcmp d0,d1
bhi 15f
ldr d1,dConstE2
fmul d0,d0,d1
subs x0,x0,#2
15:
ldr d1,dConstE0
fcmp d0,d1
bhi 100f
ldr d1,dConstE1
fmul d0,d0,d1
subs x0,x0,#1
100: // fin standard de la fonction
ldp x1,lr,[sp],16 // restaur registres
ret
.align 2
dConstE7: .double 0f1E7
dConstE256: .double 0f1E256
dConstE128: .double 0f1E128
dConstE64: .double 0f1E64
dConstE32: .double 0f1E32
dConstE16: .double 0f1E16
dConstE8: .double 0f1E8
dConstE4: .double 0f1E4
dConstE2: .double 0f1E2
dConstE1: .double 0f1E1
dConstME5: .double 0f1E-5
dConstME255: .double 0f1E-255
dConstME127: .double 0f1E-127
dConstME63: .double 0f1E-63
dConstME31: .double 0f1E-31
dConstME15: .double 0f1E-15
dConstME7: .double 0f1E-7
dConstME3: .double 0f1E-3
dConstME1: .double 0f1E-1
dConstE0: .double 0f1E0
/******************************************************************/
/* Décimal Conversion */
/******************************************************************/
/* x0 contain value et x1 address conversion area */
conversion10SP:
stp x1,lr,[sp,-16]! // save registers
stp x2,x3,[sp,-16]! // save registers
stp x4,x5,[sp,-16]! // save registers
mov x5,x1
mov x4,#16
mov x2,x0
mov x1,#10 // décimal conversion
1: // conversion loop
mov x0,x2 // copy begin number or quotient
udiv x2,x0,x1 // division by 10
msub x3,x1,x2,x0 // compute remainder
add x3,x3,#48 // compute digit
strb w3,[x5,x4] // store byte address area (x5) + offset (x4)
subs x4,x4,#1 // position precedente
bge 1b
strb wzr,[x5,16] // 0 final
100:
ldp x4,x5,[sp],16 // restaur registers
ldp x2,x3,[sp],16 // restaur registers
ldp x1,lr,[sp],16 // restaur registers
ret
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../includeARM64.inc"
</syntaxhighlight>
<pre>
Difference between +20 and +45 = +25
Difference between -45 and +45 = +90
Difference between -85 and +90 = +175
Difference between -95 and +90 = -175
Difference between -45 and +125 = +170
Difference between -45 and +145 = -170
Difference between +29,4802 and -88,638099 = -118,1
Difference between -78,325 and -159 = -80,7108999
Difference between -70099,7423381 and +29840,674378 = -139,58328
</pre>
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<syntaxhighlight lang="action!">INCLUDE "H6:REALMATH.ACT"
INT FUNC AngleI(INT a1,a2)
INT r
r=a2-a1
WHILE r>180 DO r==-360 OD
WHILE r<-180 DO r==+360 OD
RETURN (r)
PROC TestI(INT a1,a2)
INT r
r=AngleI(a1,a2)
PrintF("%I .. %I = %I%E",a1,a2,r)
RETURN
PROC AngleR(REAL POINTER r1,r2,r)
REAL tmp,r180,rm180,r360
ValR("180",r180)
ValR("-180",rm180)
ValR("360",r360)
RealSub(r2,r1,r)
WHILE RealGreaterOrEqual(r,r180)
DO
RealSub(r,r360,tmp) RealAssign(tmp,r)
OD
WHILE RealGreaterOrEqual(rm180,r)
DO
RealAdd(r,r360,tmp) RealAssign(tmp,r)
OD
RETURN
PROC TestR(CHAR ARRAY s1,s2)
REAL r1,r2,r
ValR(s1,r1) ValR(s2,r2)
AngleR(r1,r2,r)
PrintR(r1) Print(" .. ") PrintR(r2)
Print(" = ") PrintRE(r)
RETURN
PROC Main()
Put(125) PutE() ;clear screen
TestI(20,45)
TestI(-45,45)
TestI(-85,90)
TestI(-95,90)
TestI(-45,125)
TestI(-45,145)
TestR("29.4803","-88.6381")
TestR("-78.3251","-159.036")
TestR("-70099.74233810938","29840.67437876723")
TestR("-165313.6666297357","33693.9894517456")
TestR("1174.8380510598456","-154146.66490124757")
TestR("60175.77306795546","42213.07192354373")
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Angle_difference_between_two_bearings.png Screenshot from Atari 8-bit computer]
<pre>
20 .. 45 = 25
-45 .. 45 = 90
-85 .. 90 = 175
-95 .. 90 = -175
-45 .. 125 = 170
-45 .. 145 = -170
29.4803 .. -88.6381 = -118.1184
-78.3251 .. -159.036 = -80.7109
-70099.7423 .. 29840.6743 = -139.5834
-165313.666 .. 33693.9894 = -72.3446
1174.83805 .. -154146.664 = -161.502
60175.773 .. 42213.0719 = 37.2989
</pre>
=={{header|Ada}}==
Ada does not provide a built-in mod function for floating point types. This program supplies one.
<syntaxhighlight lang="ada">
-----------------------------------------------------------------------
-- Angle difference between two bearings
Line 187 ⟶ 850:
end Bearing_Angles;
</syntaxhighlight>
{{out}}
<pre>
Line 201 ⟶ 864:
Difference between -154146.6649 and 1174.8381 is -161.5030
Difference between 42213.0719 and 60175.7731 is 37.2989
</pre>
=={{header|ALGOL 68}}==
{{Trans|11l}}
<syntaxhighlight lang="algol68">
BEGIN # angle difference between 2 bearings - translated from the 11l sample #
PROC wrap = (REAL v, l1, l2 )REAL:
BEGIN
REAL result := v;
WHILE result < l1 DO result +:= 2 * l2 OD;
WHILE result > l2 DO result +:= 2 * l1 OD;
result
END # wrap # ;
PROC get_difference = ( REAL b1, b2 )REAL: wrap( b2 - b1, -180.0, 180.0 );
OP FMT = ( REAL v )STRING:
BEGIN
STRING result := fixed( ABS v, 0, 3 );
IF result[ LWB result ] = "." THEN "0" +=: result FI;
WHILE result[ UPB result ] = "0" DO result := result[ : UPB result - 1 ] OD;
IF result[ UPB result ] = "." THEN result := result[ : UPB result - 1 ] FI;
IF v < 0 THEN "-" ELSE " " FI + result
END # FMT # ;
print( ( FMT get_difference( 20.0, 45.0 ), newline ) );
print( ( FMT get_difference( -45.0, 45.0 ), newline ) );
print( ( FMT get_difference( -85.0, 90.0 ), newline ) );
print( ( FMT get_difference( -95.0, 90.0 ), newline ) );
print( ( FMT get_difference( -45.0, 125.0 ), newline ) );
print( ( FMT get_difference( -45.0, 145.0 ), newline ) );
print( ( FMT get_difference( -45.0, 125.0 ), newline ) );
print( ( FMT get_difference( -45.0, 145.0 ), newline ) );
print( ( FMT get_difference( 29.4803, -88.6381 ), newline ) );
print( ( FMT get_difference( -78.3251, -159.036 ), newline ) );
print( ( newline ) );
print( ( FMT get_difference( -70099.74233810938, 29840.67437876723 ), newline ) );
print( ( FMT get_difference( -165313.6666297357, 33693.9894517456 ), newline ) );
print( ( FMT get_difference( 1174.8380510598456, -154146.66490124757 ), newline ) );
print( ( FMT get_difference( 60175.77306795546, 42213.07192354373 ), newline ) )
END
</syntaxhighlight>
{{out}}
<pre>
25
90
175
-175
170
-170
170
-170
-118.118
-80.711
-139.583
-72.344
-161.503
37.299
</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>
{{out}}
<pre> 'B1' 'B2' 'DIFFERENCE'⍪(⊂'¯¯¯¯¯¯¯¯¯¯')⍪(⊃B),DIFF/¨B
Line 230 ⟶ 954:
180
</pre>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI or android with termux */
/* program diffAngle.s */
/* REMARK 1 : this program use routines in a include file
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
/*********************************/
/* Initialized data */
/*********************************/
.data
szCarriageReturn: .asciz "\n"
szMessResult: .asciz "Difference between @ and @ = @ \n"
.align 4
fB1: .float 20.0
fB2: .float 45.0
fB3: .float -45.0
fB4: .float -85.0
fB5: .float 90.0
fB6: .float -95.0
fB7: .float 125.0
fB8: .float 145.0
fB9: .float 29.4803
fB10: .float -88.6381
fB11: .float -78.3251
fB12: .float -159.036
fB13: .float -70099.74233810938
fB14: .float 29840.67437876723
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main:
ldr r0,iAdrfB1
ldr r1,iAdrfB2
bl testComputeAngle
ldr r0,iAdrfB3
ldr r1,iAdrfB2
bl testComputeAngle
ldr r0,iAdrfB4
ldr r1,iAdrfB5
bl testComputeAngle
ldr r0,iAdrfB6
ldr r1,iAdrfB5
bl testComputeAngle
ldr r0,iAdrfB3
ldr r1,iAdrfB7
bl testComputeAngle
ldr r0,iAdrfB3
ldr r1,iAdrfB8
bl testComputeAngle
ldr r0,iAdrfB9
ldr r1,iAdrfB10
bl testComputeAngle
ldr r0,iAdrfB11
ldr r1,iAdrfB12
bl testComputeAngle
ldr r0,iAdrfB13
ldr r1,iAdrfB14
bl testComputeAngle
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsZoneConv: .int sZoneConv
iAdrfB1: .int fB1
iAdrfB2: .int fB2
iAdrfB3: .int fB3
iAdrfB4: .int fB4
iAdrfB5: .int fB5
iAdrfB6: .int fB6
iAdrfB7: .int fB7
iAdrfB8: .int fB8
iAdrfB9: .int fB9
iAdrfB10: .int fB10
iAdrfB11: .int fB11
iAdrfB12: .int fB12
iAdrfB13: .int fB13
iAdrfB14: .int fB14
/******************************************************************/
/* compute difference and display result */
/******************************************************************/
/* s0 contains bearing 1 */
/* s1 contains bearing 2 */
testComputeAngle:
push {r1-r3,lr} @ save registers
vldr.f32 s0,[r0]
vmov s2,s0
vldr.f32 s1,[r1]
bl computeDiffAngle
vmov s3,s0
vmov s0,s2
ldr r0,iAdrsZoneConv
bl convertirFloat
ldr r0,iAdrszMessResult
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc
mov r3,r0
vmov s0,s1
ldr r0,iAdrsZoneConv
bl convertirFloat
mov r0,r3
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc
mov r3,r0
vmov s0,s3
ldr r0,iAdrsZoneConv
bl convertirFloat
mov r0,r3
ldr r1,iAdrsZoneConv
bl strInsertAtCharInc
bl affichageMess
100:
pop {r1-r3,pc} @ restaur registers
iAdrszMessResult: .int szMessResult
/******************************************************************/
/* compute difference of two bearing */
/******************************************************************/
/* s0 contains bearing 1 */
/* s1 contains bearing 2 */
computeDiffAngle:
push {r1-r4,lr} @ save registers
vpush {s1-s4}
mov r1,#360
mov r4,#0 @ top positive/negative
vcvt.s32.f32 s4,s0 @ conversion integer
vcvt.f32.s32 s2,s4 @ conversion float
vsub.f32 s2,s0,s2 @ partie décimale
vmov r0,s4 @ partie entière
cmp r0,#0 @ negative ?
neglt r0,r0 @ yes -> inversion
movlt r4,#1
bl division @ divide by 360 (r0 dividende r1 divisor r2 quotient r3 remainder)
cmp r4,#0 @ value negative ?
negne r3,r3 @ inversion remainder
vmov s3,r3
vcvt.f32.s32 s3,s3 @ and conversion float
vadd.f32 s0,s3,s2 @ add decimal part
mov r4,#0 @ bearing 2
vcvt.s32.f32 s4,s1 @ conversion integer
vcvt.f32.s32 s2,s4 @ conversion float
vsub.f32 s2,s1,s2 @ partie décimale
vmov r0,s4
cmp r0,#0
neglt r0,r0
movlt r4,#1
bl division @ divide by 360
cmp r4,#0
negne r3,r3 @ negate remainder
vmov s3,r3
vcvt.f32.s32 s3,s3 @ conversion float
vadd.f32 s1,s3,s2
vsub.f32 s0,s1,s0 @ calculate the difference between the 2 values
mov r0,#180
vmov s3,r0
vcvt.f32.s32 s3,s3 @ conversion float 180
vmov s4,r1 @ 360
vcvt.f32.s32 s4,s4 @ conversion float 360
vcmp.f32 s0,#0.0 @ difference is negative ?
vmrs APSR_nzcv, FPSCR @ flags transfert (do not forget this instruction !!!)
blt 2f
@ difference is positive
vcmp.f32 s0,s4 @ difference > 360
vmrs APSR_nzcv, FPSCR @ flags transfert (do not forget this instruction !!!)
vsubgt.f32 s0,s4 @ yes -> difference - 360
vcmp.f32 s0,s3 @ compare difference and 180
vmrs APSR_nzcv, FPSCR @ flags transfert (do not forget this instruction !!!)
vsubgt.f32 s0,s4,s0 @ > 180 calculate 360 - difference
vneggt.f32 s0,s0 @ and negate
b 100f
2: @ différence is négative
vneg.f32 s2,s4 @ -360
vcmp.f32 s0,s2 @ compare différence et - 360
vmrs APSR_nzcv, FPSCR @ flags transfert (do not forget this instruction !!!)
vsubgt.f32 s0,s4 @ sub 360 to différence
vneg.f32 s3,s3 @ -180
vcmp.f32 s0,s3 @ compare difference and -180
vmrs APSR_nzcv, FPSCR @ flags transfert (do not forget this instruction !!!)
vaddlt.f32 s0,s4,s0 @ calculate 360 + différence
100:
vpop {s1-s4}
pop {r1-r4,pc} @ restaur registers
/******************************************************************/
/* Conversion Float */
/******************************************************************/
/* s0 contains Float */
/* r0 contains address conversion area mini 20 charactèrs*/
/* r0 return result length */
convertirFloat:
push {r1-r7,lr}
vpush {s0-s2}
mov r6,r0 @ save area address
vmov r0,s0
movs r7,#0 @ result length
movs r3,#'+'
strb r3,[r6] @ sign + forcing
mov r2,r0
lsls r2,#1 @ extraction bit 31
bcc 1f @ positive ?
lsrs r0,r2,#1 @ raz sign if negative
movs r3,#'-' @ sign -
strb r3,[r6]
1:
adds r7,#1 @ next position
cmp r0,#0 @ case of positive or negative 0
bne 2f
movs r3,#'0'
strb r3,[r6,r7] @ store character 0
adds r7,#1 @ next position
movs r3,#0
strb r3,[r6,r7] @ store 0 final
mov r0,r7 @ return length
b 100f @ and end
2:
ldr r2,iMaskExposant
mov r1,r0
ands r1,r2 @ exposant = 255 ?
cmp r1,r2
bne 4f
lsls r0,#10 @ bit 22 à 0 ?
bcc 3f @ yes
movs r2,#'N' @ case of Nan. store byte, if not possible store int
strb r2,[r6] @ area no aligned
movs r2,#'a'
strb r2,[r6,#1]
movs r2,#'n'
strb r2,[r6,#2]
movs r2,#0 @ 0 final
strb r2,[r6,#3]
movs r0,#3 @ return length 3
b 100f
3: @ case infini positive or négative
movs r2,#'I'
strb r2,[r6,r7]
adds r7,#1
movs r2,#'n'
strb r2,[r6,r7]
adds r7,#1
movs r2,#'f'
strb r2,[r6,r7]
adds r7,#1
movs r2,#0
strb r2,[r6,r7]
mov r0,r7
b 100f
4:
bl normaliserFloat
mov r5,r0 @ save exposant
VCVT.U32.f32 s2,s0 @ integer value of integer part
vmov r0,s2 @ integer part
VCVT.F32.U32 s1,s2 @ conversion float
vsub.f32 s1,s0,s1 @ extraction fract part
vldr s2,iConst1
vmul.f32 s1,s2,s1 @ to crop it in full
VCVT.U32.f32 s1,s1 @ integer conversion
vmov r4,s1 @ fract value
@ integer conversion in r0
mov r2,r6 @ save address area begin
adds r6,r7
mov r1,r6
bl conversion10
add r6,r0
movs r3,#','
strb r3,[r6]
adds r6,#1
mov r0,r4 @ conversion fractional part
mov r1,r6
bl conversion10SP @ spécial routine with conservation begin 0
add r6,r0
subs r6,#1
@ remove trailing zeros
5:
ldrb r0,[r6]
cmp r0,#'0'
bne 6f
subs r6,#1
b 5b
6:
cmp r0,#','
bne 7f
subs r6,#1
7:
adds r6,#1
movs r3,#'E'
strb r3,[r6]
adds r6,#1
mov r0,r5 @ conversion exposant
mov r3,r0
lsls r3,#1
bcc 4f
rsbs r0,r0,#0
movs r3,#'-'
strb r3,[r6]
adds r6,#1
4:
mov r1,r6
bl conversion10
add r6,r0
movs r3,#0
strb r3,[r6]
adds r6,#1
mov r0,r6
subs r0,r2 @ return length result
subs r0,#1 @ - 0 final
100:
vpop {s0-s2}
pop {r1-r7,pc}
iMaskExposant: .int 0xFF<<23
iConst1: .float 0f1E9
/***************************************************/
/* normaliser float */
/***************************************************/
/* r0 contain float value (always positive value and <> Nan) */
/* s0 return new value */
/* r0 return exposant */
normaliserFloat:
push {lr} @ save registre
vmov s0,r0 @ value float
movs r0,#0 @ exposant
vldr s1,iConstE7 @ no normalisation for value < 1E7
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 10f @ if s0 < iConstE7
vldr s1,iConstE32
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 1f
vldr s1,iConstE32
vdiv.f32 s0,s0,s1
adds r0,#32
1:
vldr s1,iConstE16
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 2f
vldr s1,iConstE16
vdiv.f32 s0,s0,s1
adds r0,#16
2:
vldr s1,iConstE8
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 3f
vldr s1,iConstE8
vdiv.f32 s0,s0,s1
adds r0,#8
3:
vldr s1,iConstE4
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 4f
vldr s1,iConstE4
vdiv.f32 s0,s0,s1
adds r0,#4
4:
vldr s1,iConstE2
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 5f
vldr s1,iConstE2
vdiv.f32 s0,s0,s1
adds r0,#2
5:
vldr s1,iConstE1
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
blo 10f
vldr s1,iConstE1
vdiv.f32 s0,s0,s1
adds r0,#1
10:
vldr s1,iConstME5 @ pas de normalisation pour les valeurs > 1E-5
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 100f
vldr s1,iConstME31
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 11f
vldr s1,iConstE32
vmul.f32 s0,s0,s1
subs r0,#32
11:
vldr s1,iConstME15
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 12f
vldr s1,iConstE16
vmul.f32 s0,s0,s1
subs r0,#16
12:
vldr s1,iConstME7
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 13f
vldr s1,iConstE8
vmul.f32 s0,s0,s1
subs r0,#8
13:
vldr s1,iConstME3
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 14f
vldr s1,iConstE4
vmul.f32 s0,s0,s1
subs r0,#4
14:
vldr s1,iConstME1
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 15f
vldr s1,iConstE2
vmul.f32 s0,s0,s1
subs r0,#2
15:
vldr s1,iConstE0
vcmp.f32 s0,s1
vmrs APSR_nzcv,FPSCR
bhi 100f
vldr s1,iConstE1
vmul.f32 s0,s0,s1
subs r0,#1
100: @ fin standard de la fonction
pop {pc} @ restaur des registres
.align 2
iConstE7: .float 0f1E7
iConstE32: .float 0f1E32
iConstE16: .float 0f1E16
iConstE8: .float 0f1E8
iConstE4: .float 0f1E4
iConstE2: .float 0f1E2
iConstE1: .float 0f1E1
iConstME5: .float 0f1E-5
iConstME31: .float 0f1E-31
iConstME15: .float 0f1E-15
iConstME7: .float 0f1E-7
iConstME3: .float 0f1E-3
iConstME1: .float 0f1E-1
iConstE0: .float 0f1E0
/******************************************************************/
/* Décimal Conversion */
/******************************************************************/
/* r0 contain value et r1 address conversion area */
conversion10SP:
push {r1-r6,lr} @ save registers
mov r5,r1
mov r4,#8
mov r2,r0
mov r1,#10 @ conversion decimale
1: @ begin loop
mov r0,r2 @ copy number or quotients
bl division @ r0 dividende r1 divisor r2 quotient r3 remainder
add r3,#48 @ compute digit
strb r3,[r5,r4] @ store byte area address (r5) + offset (r4)
subs r4,r4,#1 @ position précedente
bge 1b @ and loop if not < zero
mov r0,#8
mov r3,#0
strb r3,[r5,r0] @ store 0 final
100:
pop {r1-r6,pc} @ restaur registers
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
<pre>
Difference between +20E0 and +45E0 = +25E0
Difference between -45E0 and +45E0 = +90E0
Difference between -85E0 and +90E0 = +175E0
Difference between -95E0 and +90E0 = -175E0
Difference between -45E0 and +125E0 = +170E0
Difference between -45E0 and +145E0 = -170E0
Difference between +29,48030089E0 and -88,63809964E0 = -118,1184082E0
Difference between -78,32510374E0 and -159,03599548E0 = -80,71087648E0
Difference between -70099,74218752E0 and +29840,67382809E0 = -139,58398438E0
</pre>
=={{header|Arturo}}==
{{trans|Ruby}}
<syntaxhighlight lang="rebol">getDifference: function [b1, b2][
r: (b2 - b1) % 360.0
if r >= 180.0 ->
r: r - 360.0
return r
]
print "Input in -180 to +180 range"
print getDifference 20.0 45.0
print getDifference neg 45.0 45.0
print getDifference neg 85.0 90.0
print getDifference neg 95.0 90.0
print getDifference neg 45.0 125.0
print getDifference neg 45.0 145.0
print getDifference neg 45.0 125.0
print getDifference neg 45.0 145.0
print getDifference 29.4803 neg 88.6381
print getDifference neg 78.3251 neg 159.036
print ""
print "Input in wider range"
print getDifference neg 70099.74233810938 29840.67437876723
print getDifference neg 165313.6666297357 33693.9894517456
print getDifference 1174.8380510598456 neg 154146.66490124757
print getDifference 60175.77306795546 42213.07192354373</syntaxhighlight>
{{out}}
<pre>Input in -180 to +180 range
25.0
90.0
175.0
-175.0
170.0
-170.0
170.0
-170.0
-118.1184
-80.7109
Input in wider range
-139.5832831233856
-72.34391851868713
-161.5029523074045
-322.7011444117306</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">Angles:= [[20, 45]
,[-45, 45]
,[-85, 90]
,[-95, 90]
,[-45, 125]
,[-45, 145]
,[29.4803, -88.6381]
,[-78.3251, -159.036]
,[-70099.74233810938, 29840.67437876723]
,[-165313.6666297357, 33693.9894517456]
,[1174.8380510598456, -154146.66490124757]
,[60175.77306795546, 42213.07192354373]]
for i, set in angles
result .= set.2 " to " set.1 " = " Angle_difference_between_two_bearings(set) "`n"
MsgBox, 262144, , % result
return
Angle_difference_between_two_bearings(set){
return (diff := Mod(set.2, 360) - Mod(set.1, 360)) >180 ? diff-360 : diff
}</syntaxhighlight>
{{out}}
<pre>45 to 20 = 25
45 to -45 = 90
90 to -85 = 175
90 to -95 = -175
125 to -45 = 170
145 to -45 = -170
-88.6381 to 29.4803 = -118.118400
-159.036 to -78.3251 = -80.710900
29840.67437876723 to -70099.74233810938 = 220.416717
33693.9894517456 to -165313.6666297357 = -72.343919
-154146.66490124757 to 1174.8380510598456 = -161.502952
42213.07192354373 to 60175.77306795546 = 37.298856</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f ANGLE_DIFFERENCE_BETWEEN_TWO_BEARINGS.AWK
BEGIN {
Line 266 ⟶ 1,599:
return(r)
}
</syntaxhighlight>
{{out}}
<pre>
Line 284 ⟶ 1,617:
60175.77 42213.07 37.30
</pre>
=={{header|BASIC}}==
==={{header|Chipmunk Basic}}===
{{trans|Phyton}}
{{works with|Chipmunk Basic|3.6.4}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">100 cls
110 sub getdifference(b1,b2)
120 r = (b2-b1) mod 360
130 if r >= 180 then r = r-360
140 print using "#######.######";b1;
150 print using " #######.######";b2;
160 print using " #######.######";r
170 end sub
180 print "Input in -180 to +180 range:"
190 print " b1 b2 difference"
200 print " -------------------------------------------------"
210 getdifference(20,45)
220 getdifference(-45,45)
230 getdifference(-85,90)
240 getdifference(-95,90)
250 getdifference(-45,125)
260 getdifference(-45,145)
270 getdifference(-45,125)
280 getdifference(-45,145)
290 getdifference(29.4803,-88.6381)
300 getdifference(-78.3251,-159.036)
310 getdifference(-70099.742338,29840.674379)
320 getdifference(-165313.66663,33693.989452)
330 getdifference(1174.838051,-154146.664901)
340 print
350 print "Input in wider range:"
360 print " b1 b2 difference"
370 print " -------------------------------------------------"
380 getdifference(-70099.742338,29840.674379)
390 getdifference(-165313.66663,33693.989452)
400 getdifference(1174.838051,-154146.664901)
410 getdifference(60175.773068,42213.071924)</syntaxhighlight>
{{out}}
<pre>Input in -180 to +180 range:
b1 b2 difference
-------------------------------------------------
20.000000 45.000000 25.000000
-45.000000 45.000000 90.000000
-85.000000 90.000000 175.000000
-95.000000 90.000000 -175.000000
-45.000000 125.000000 170.000000
-45.000000 145.000000 -170.000000
-45.000000 125.000000 170.000000
-45.000000 145.000000 -170.000000
29.480300 -88.638100 -118.000000
-78.325100 -159.036000 -80.000000
-70099.742338 29840.674379 -140.000000
-165313.666630 33693.989452 -73.000000
1174.838051 -154146.664901 -161.000000
Input in wider range:
b1 b2 difference
-------------------------------------------------
-70099.742338 29840.674379 -140.000000
-165313.666630 33693.989452 -73.000000
1174.838051 -154146.664901 -161.000000
60175.773068 42213.071924 -322.000000</pre>
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">SUB getDifference (b1!, b2!)
r! = (b2 - b1) MOD 360!
IF r >= 180! THEN r = r - 360!
PRINT USING "#######.###### #######.###### #######.######"; b1; b2; r
END SUB
PRINT " Bearing 1 Bearing 2 Difference"
CALL getDifference(20!, 45!)
CALL getDifference(-45!, 45!)
CALL getDifference(-85!, 90!)
CALL getDifference(-95!, 90!)
CALL getDifference(-45!, 125!)
CALL getDifference(-45!, 145!)
CALL getDifference(-45!, 125!)
CALL getDifference(-45!, 145!)
CALL getDifference(29.4803, -88.6381)
CALL getDifference(-78.3251, -159.036)
CALL getDifference(-70099.74233810938#, 29840.67437876723#)
CALL getDifference(-165313.6666297357#, 33693.9894517456#)
CALL getDifference(1174.838051059846#, -154146.6649012476#)</syntaxhighlight>
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">SUB getdifference (b1,b2)
LET r = REMAINDER(b2-b1, 360.0)
IF r >= 180.0 THEN LET r = r-360.0
PRINT USING "#######.###### #######.###### #######.######": b1, b2, r
END SUB
PRINT " Bearing 1 Bearing 2 Difference"
CALL getdifference(20.0, 45.0)
CALL getdifference(-45.0, 45.0)
CALL getdifference(-85.0, 90.0)
CALL getdifference(-95.0, 90.0)
CALL getdifference(-45.0, 125.0)
CALL getdifference(-45.0, 145.0)
CALL getdifference(-45.0, 125.0)
CALL getdifference(-45.0, 145.0)
CALL getdifference(29.4803, -88.6381)
CALL getdifference(-78.3251, -159.036)
CALL getdifference(-70099.74233810938, 29840.67437876723)
CALL getdifference(-165313.6666297357, 33693.9894517456)
CALL getdifference(1174.8380510598456, -154146.66490124757)
END</syntaxhighlight>
=={{header|BASIC256}}==
{{trans|Python}}
<syntaxhighlight lang="basic256"># Rosetta Code problem: http://rosettacode.org/wiki/Angle_difference_between_two_bearings
# by Jjuanhdez, 06/2022
print "Input in -180 to +180 range:"
call getDifference(20.0, 45.0)
call getDifference(-45.0, 45.0)
call getDifference(-85.0, 90.0)
call getDifference(-95.0, 90.0)
call getDifference(-45.0, 125.0)
call getDifference(-45.0, 145.0)
call getDifference(-45.0, 125.0)
call getDifference(-45.0, 145.0)
call getDifference(29.4803, -88.6381)
call getDifference(-78.3251, -159.036)
print
print "Input in wider range:"
call getDifference(-70099.74233810938, 29840.67437876723)
call getDifference(-165313.6666297357, 33693.9894517456)
call getDifference(1174.8380510598456, -154146.66490124757)
end
subroutine getDifference(b1, b2)
r = (b2 - b1) mod 360
if r >= 180.0 then r -= 360.0
print ljust(b1,16); ljust(b2,16); ljust(r,12)
end subroutine</syntaxhighlight>
=={{header|Befunge}}==
<
>&:v >859**%:459**1-`#v_ >12g!:12p#v_\-:459**1-`#v_ >.>
>0`#^_8v >859**-^ >859**-^
^:+**95< > ^
</syntaxhighlight>
The labelled points are:
1. Initialise write/not write and read input,
Line 323 ⟶ 1,795:
25 90 175 -175 170 -170 -117 -81 -141 -74 -160 38
</pre>
=={{header|BQN}}==
<syntaxhighlight lang="bqn">Adiff ← 180 - 360 | 180 + -
tests ← [20‿45, ¯45‿45, ¯85‿90, ¯95‿90, ¯45‿125, ¯45‿145
99‿279, 29.4803‿¯88.6381, ¯78.3251‿¯159.036
¯70099.74233810938‿29840.67437876723
¯165313.6666297357‿33693.9894517456
1174.8380510598456‿¯154146.66490124757
60175.77306795546‿42213.07192354373]
Round ← ⌊∘+⟜0.5⌾(1e3⊸×)
Round∘∾⟜(Adiff´)˘ tests</syntaxhighlight>
{{out}}
<pre>┌─
╵ 20 45 25
¯45 45 90
¯85 90 175
¯95 90 ¯175
¯45 125 170
¯45 145 ¯170
99 279 180
29.48 ¯88.638 ¯118.118
¯78.325 ¯159.036 ¯80.711
¯70099.742 29840.674 ¯139.583
¯165313.667 33693.989 ¯72.344
1174.838 ¯154146.665 ¯161.503
60175.773 42213.072 37.299
┘</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.
<syntaxhighlight lang="c">
#include<stdlib.h>
#include<stdio.h>
Line 364 ⟶ 1,866:
return 0;
}
</syntaxhighlight>
Invocation and output for two bearings :
<pre>
Line 410 ⟶ 1,912:
=={{header|C sharp|C#}}==
<
namespace Angle_difference_between_two_bearings
Line 491 ⟶ 1,993:
}
}
}</
{{out| Output}}
<pre>Hello World!
Line 511 ⟶ 2,013:
=={{header|C++}}==
<
#include <iostream>
using namespace std;
Line 545 ⟶ 2,047:
return 0;
}</
{{out}}
Line 566 ⟶ 2,068:
=={{header|Clojure}}==
<
(let [r (mod (- b a) 360)]
(if (>= r 180)
Line 577 ⟶ 2,079:
(angle-difference -95 90) ; -175
(angle-difference -70099.74 29840.67) ; -139.59
</syntaxhighlight>
=={{header|COBOL}}==
<syntaxhighlight lang="cobol">
******************************************************************
* COBOL solution to Angle difference challange
* The program was run on OpenCobolIDE
* I chose to read the input data from a .txt file that I
* created on my PC rather than to hard code it into the
* program or enter it as the program was executing.
******************************************************************
IDENTIFICATION DIVISION.
PROGRAM-ID. ANGLE-DIFFERENCE.
ENVIRONMENT DIVISION.
INPUT-OUTPUT SECTION.
FILE-CONTROL.
SELECT IN-FILE ASSIGN TO 'C:\Both\Rosetta\Angle_diff.txt'
ORGANIZATION IS LINE SEQUENTIAL.
DATA DIVISION.
FILE SECTION.
FD IN-FILE.
01 IN-RECORD.
05 ALPHA-BEARING-1 PIC X(20).
05 FILLER PIC X.
05 ALPHA-BEARING-2 PIC X(20).
WORKING-STORAGE SECTION.
01 SWITCHES.
05 EOF-SWITCH PIC X VALUE 'N'.
01 COUNTERS.
05 REC-CTR PIC 9(3) VALUE 0.
01 WS-ALPHA-BEARING.
05 WS-AB-SIGN PIC X.
88 WS-AB-NEGATIVE VALUE "-".
05 WS-AB-INTEGER-PART PIC X(6).
05 WS-AB-DEC-POINT PIC X.
05 WS-AB-DECIMAL-PART PIC X(12).
01 WS-BEARING-1 PIC S9(6)V9(12).
01 WS-BEARING-2 PIC S9(6)V9(12).
01 WS-BEARING PIC S9(6)V9(12).
01 FILLER REDEFINES WS-BEARING.
05 WSB-INTEGER-PART PIC X(6).
05 WSB-DECIMAL-PART PIC X9(12).
77 WS-RESULT PIC S9(6)V9(12).
77 WS-RESULT-POS PIC 9(6)V9(12).
77 WS-INTEGER-PART PIC 9(6).
77 WS-DECIMAL-PART PIC V9(12).
77 WS-RESULT-OUT PIC ------9.9999.
PROCEDURE DIVISION.
000-MAIN.
PERFORM 100-INITIALIZE.
PERFORM 200-PROCESS-RECORD
UNTIL EOF-SWITCH = 'Y'.
PERFORM 300-TERMINATE.
STOP RUN.
100-INITIALIZE.
OPEN INPUT IN-FILE.
PERFORM 150-READ-RECORD.
150-READ-RECORD.
READ IN-FILE
AT END
MOVE 'Y' TO EOF-SWITCH
NOT AT END
COMPUTE REC-CTR = REC-CTR + 1
END-READ.
200-PROCESS-RECORD.
MOVE ALPHA-BEARING-1 TO WS-ALPHA-BEARING.
PERFORM 250-CONVERT-DATA.
MOVE WS-BEARING TO WS-BEARING-1.
MOVE ALPHA-BEARING-2 TO WS-ALPHA-BEARING.
PERFORM 250-CONVERT-DATA.
MOVE WS-BEARING TO WS-BEARING-2.
COMPUTE WS-RESULT = WS-BEARING-2 - WS-BEARING-1.
MOVE WS-RESULT TO WS-RESULT-POS.
MOVE WS-RESULT-POS TO WS-INTEGER-PART.
COMPUTE WS-DECIMAL-PART = WS-RESULT-POS - WS-INTEGER-PART.
COMPUTE WS-INTEGER-PART = FUNCTION MOD(WS-INTEGER-PART 360).
IF WS-RESULT > 0
COMPUTE WS-RESULT = WS-INTEGER-PART + WS-DECIMAL-PART
ELSE
COMPUTE WS-RESULT =
(WS-INTEGER-PART + WS-DECIMAL-PART) * -1
END-IF.
IF WS-RESULT < -180
COMPUTE WS-RESULT = WS-RESULT + 360.
IF WS-RESULT > 180
COMPUTE WS-RESULT = WS-RESULT - 360.
COMPUTE WS-RESULT-OUT ROUNDED = WS-RESULT.
DISPLAY REC-CTR ' ' WS-RESULT-OUT.
PERFORM 150-READ-RECORD.
250-CONVERT-DATA.
MOVE WS-AB-INTEGER-PART TO WSB-INTEGER-PART.
MOVE WS-AB-DECIMAL-PART TO WSB-DECIMAL-PART.
IF WS-AB-NEGATIVE
SUBTRACT WS-BEARING FROM ZERO
GIVING WS-BEARING
END-IF.
300-TERMINATE.
DISPLAY 'RECORDS PROCESSED: ' REC-CTR.
CLOSE IN-FILE.
******************************************************************
* INPUT FILE ('Angle_diff.txt' stored on my PC at:
* 'C:\Both\Rosetta\Angle_diff.txt'
******************************************************************
* +000020.000000000000 +000045.000000000000
* -000045.000000000000 +000045.000000000000
* -000085.000000000000 +000090.000000000000
* -000095.000000000000 +000090.000000000000
* -000045.000000000000 +000125.000000000000
* -000045.000000000000 +000145.000000000000
* +000029.480300000000 -000088.638100000000
* -000078.325100000000 -000159.036000000000
* -070099.742338109380 +029840.674378767230
* -165313.666629735700 +033693.989451745600
* +001174.838051059846 -154146.664901247570
* +060175.773067955460 +042213.071923543730
******************************************************************
* OUTPUT:
******************************************************************
* 001 25.0000
* 002 90.0000
* 003 175.0000
* 004 -175.0000
* 005 170.0000
* 006 -170.0000
* 007 -118.1184
* 008 -80.7109
* 009 -139.5833
* 010 -72.3439
* 011 -161.5030
* 012 37.2989
******************************************************************
</syntaxhighlight>
=={{header|Common Lisp}}==
<
(defun angle-difference (b1 b2)
(let ((diff (mod (- b2 b1) 360)))
Line 588 ⟶ 2,243:
(decf diff 360)
diff))))
</syntaxhighlight>
{{out| Output}}
<pre>
Line 604 ⟶ 2,259:
</pre>
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">precision 4
define s1 = 0, s2 = 0
dim b1[20, -45, -85, -95, -45, -45, 29.4803, -78.3251]
dim b2[45, 45, 90, 90, 125, 145, -88.6381, -159.036]
arraysize s1, b1
arraysize s2, b2
if s1 = s2 then
for i = 0 to s1 - 1
let r = (b2[i] - b1[i]) % 360
if r >= 180 then
let r = r - 360
endif
print "bearing 1: ", b1[i], " bearing 2: ", b2[i], " difference: ", r
next i
endif</syntaxhighlight>
{{out| Output}}
<pre>bearing 1: 20 bearing 2: 45 difference: 25
bearing 1: -45 bearing 2: 45 difference: 90
bearing 1: -85 bearing 2: 90 difference: 175
bearing 1: -95 bearing 2: 90 difference: -175
bearing 1: -45 bearing 2: 125 difference: 170
bearing 1: -45 bearing 2: 145 difference: -170
bearing 1: 29.4803 bearing 2: -88.6381 difference: -118
bearing 1: -78.3251 bearing 2: -159.0360 difference: -80</pre>
=={{header|D}}==
{{trans|Java}}
<
double getDifference(double b1, double b2) {
Line 638 ⟶ 2,331:
writeln(getDifference(1174.8380510598456, -154146.66490124757));
writeln(getDifference(60175.77306795546, 42213.07192354373));
}</
{{out}}
Line 657 ⟶ 2,350:
-161.503
37.2989</pre>
=={{header|Delphi}}==
See [[#Pascal]].
=={{header|EasyLang}}==
{{trans|AWK}}
<syntaxhighlight lang=easylang>
func angdiff a b .
r = (b - a) mod 360
if r < -180
r += 360
elif r >= 180
r -= 360
.
return r
.
proc pd a b . .
print b & " " & a & " -> " & angdiff a b
.
pd 20 45
pd -45 45
pd -85 90
pd -95 90
pd -45 125
pd -45 145
pd 29.4803 -88.6381
pd -78.3251 -159.036
pd -70099.74233810938 29840.67437876723
pd -165313.6666297357 33693.9894517456
pd 1174.8380510598456 -154146.66490124757
pd 60175.77306795546 42213.07192354373
</syntaxhighlight>
=={{header|Erlang}}==
The real number calculations are done using integer arithmetic to better handle
rounding errors. Erlang uses extended precision integers so there will be no overflow.
The module is tested by running the test function, which in turn matches expected results
with the result of function call.
<syntaxhighlight lang="erlang">
-module(bearings).
%% API
-export([angle_sub_degrees/2,test/0]).
-define(RealAngleMultiplier,16#10000000000).
-define(DegreesPerTurn,360).
-define(Precision,9).
%%%===================================================================
%%% API
%%%===================================================================
%%--------------------------------------------------------------------
%% @doc
%% @spec
%% @end
%%--------------------------------------------------------------------
%%
angle_sub_degrees(B1,B2) when is_integer(B1), is_integer(B2) ->
angle_sub(B2-B1,?DegreesPerTurn);
angle_sub_degrees(B1,B2) ->
NewB1 = trunc(B1*?RealAngleMultiplier),
NewB2 = trunc(B2*?RealAngleMultiplier),
round(angle_sub(NewB2 - NewB1,
?DegreesPerTurn*?RealAngleMultiplier)
/?RealAngleMultiplier,?Precision).
%%%===================================================================
%%% Internal functions
%%%===================================================================
%% delta normalises the angle difference. Consider a turn from 350 degrees
%% to 20 degrees. Subtraction results in 330 degress. This is equivalent of
%% a turn in the other direction of 30 degrees, thus 330 degrees is equal
%% to -30 degrees.
angle_sub(Value,TurnSize) ->
NormalisedValue = Value rem TurnSize,
minimise_angle(NormalisedValue,TurnSize).
% X rem Turn result in 0..Turn for X > 0 and -Turn..0 for X < 0
% specification requires -Turn/2 < X < Turn/2. This is achieved
% by adding or removing a turn as required.
% bsr 1 divides an integer by 2
minimise_angle(Angle,Turn) when Angle + (Turn bsr 1) < 0 ->
Angle+Turn;
minimise_angle(Angle,Turn) when Angle - (Turn bsr 1) > 0 ->
Angle-Turn;
minimise_angle(Angle,_) ->
Angle.
round(Number,Precision) ->
P = math:pow(10,Precision),
round(Number*P)/P.
test() ->
25 = angle_sub_degrees(20,45),
90 = angle_sub_degrees(-45,45),
175 = angle_sub_degrees(-85,90),
-175 = angle_sub_degrees(-95,90),
170 = angle_sub_degrees(-45,125),
-170 = angle_sub_degrees(-45,145),
-118.1184 = angle_sub_degrees( 29.4803,-88.6381),
-139.583283124=angle_sub_degrees(-70099.742338109,29840.674378767),
-72.343918514=angle_sub_degrees( -165313.66662974,33693.989451746),
-161.50295231=angle_sub_degrees( 1174.8380510598,-154146.66490125),
37.298855589=angle_sub_degrees( 60175.773067955,42213.071923544),
passed.
</syntaxhighlight>
=={{header|Excel}}==
===LAMBDA===
Binding the names ANGLEBETWEENBEARINGS and BEARINGDELTA to the following lambda expressions in the Name Manager of the Excel WorkBook:
(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])
{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">ANGLEBETWEENBEARINGS
=LAMBDA(ab,
DEGREES(
BEARINGDELTA(
RADIANS(ab)
)
)
)
BEARINGDELTA
=LAMBDA(ab,
LET(
sinab, SIN(ab),
cosab, COS(ab),
ax, INDEX(sinab, 1),
bx, INDEX(sinab, 2),
ay, INDEX(cosab, 1),
by, INDEX(cosab, 2),
rem, "Sign * dot product",
IF(0 < ((ay * bx) - (by * ax)),
1,
-1
) * ACOS((ax * bx) + (ay * by))
)
)</syntaxhighlight>
Using an Excel custom number format to display the degree symbol°
{{Out}}
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="5" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=ANGLEBETWEENBEARINGS(D2#)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
| E
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|
| style="font-weight:bold" | Difference
|
| style="font-weight:bold" | b1
| style="font-weight:bold" | b2
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
|
| style="text-align:right; background-color:#cbcefb" | 25.00°
|
| style="text-align:right" | 20
| style="text-align:right" | 45
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
|
| style="text-align:right" | 90.00°
|
| style="text-align:right" | -45
| style="text-align:right" | 45
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
|
| style="text-align:right" | 175.00°
|
| style="text-align:right" | -85
| style="text-align:right" | 90
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
|
| style="text-align:right" | -175.00°
|
| style="text-align:right" | -95
| style="text-align:right" | 90
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
|
| style="text-align:right" | 170.00°
|
| style="text-align:right" | -45
| style="text-align:right" | 125
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
|
| style="text-align:right" | -170.00°
|
| style="text-align:right" | -45
| style="text-align:right" | 145
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
|
| style="text-align:right" | -118.12°
|
| style="text-align:right" | 29.4803
| style="text-align:right" | -88.6381
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
|
| style="text-align:right" | -80.71°
|
| style="text-align:right" | -78.3251
| style="text-align:right" | -159.0360
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 10
|
|
|
|
|
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 11
|
| style="text-align:right" | -139.58°
|
| style="text-align:right" | -70099.7423381093
| style="text-align:right" | 29840.6743787672
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 12
|
| style="text-align:right" | -72.34°
|
| style="text-align:right" | -165313.6666297350
| style="text-align:right" | 33693.9894517456
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 13
|
| style="text-align:right" | -161.50°
|
| style="text-align:right" | 1174.8380510598
| style="text-align:right" | -154146.6649012470
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 14
|
| style="text-align:right" | 37.30°
|
| style="text-align:right" | 60175.7730679554
| style="text-align:right" | 42213.0719235437
|}
=={{header|F
<
let r = (b2 - b1) % 360.0;
if r > 180.0 then
Line 682 ⟶ 2,633:
printfn "%A" (deltaBearing 1174.8380510598456 -154146.66490124757)
printfn "%A" (deltaBearing 60175.77306795546 42213.07192354373)
0 // return an integer exit code</
{{out}}
<pre>25.0
Line 700 ⟶ 2,651:
{{trans|F#}}
{{works with|Factor|0.99 development release 2019-03-17}}
<
IN: rosetta-code.bearings
Line 725 ⟶ 2,676:
[ delta-bearing . ] 2 12 mnapply ;
MAIN: bearings-demo</
{{out}}
<pre>
Line 740 ⟶ 2,691:
-161.5029523074045
37.29885558826936
</pre>
=={{header|Forth}}==
Developed with Gforth 0.7.9_20211014 using floating point math.
<syntaxhighlight lang="forth">
: Angle-Difference-stack ( b1 b2 - a +/-180)
\ Algorithm with stack manipulation without branches ( s. Frotran Groovy)
fswap f- \ Delta angle
360e fswap fover fmod \ mod 360
fover 1.5e f* f+ \ + 540
fover fmod \ mod 360
fswap f2/ f- \ - 180
;
: Angle-Difference-const ( b1 b2 - a +/-180)
\ Algorithm without Branches ( s. Fotran Groovy)
fswap f-
360e fmod
540e f+
360e fmod
180e f-
;
\ Test Word for requested tests
: test-ad ( b1 b2 -- )
fover fover
Angle-Difference-stack f.
Angle-Difference-const f.
;
</syntaxhighlight>
{{out}}
<pre>
20e 45e test-ad 25. 25.
-45e 45e test-ad 90. 90.
-85e 90e test-ad 175. 175.
-95e 90e test-ad -175. -175.
-45e 125e test-ad 170. 170.
-45e 145e test-ad -170. -170.
29.4803e -88.6381e test-ad -118.1184 -118.1184
-78.3251e -159.036e test-ad -80.7109 -80.7109
-70099.74233810938e 29840.67437876723e test-ad -139.583283123386 -139.583283123386
-165313.6666297357e 33693.9894517456e test-ad -72.3439185186871 -72.3439185186871
1174.8380510598456e -154146.66490124757e test-ad -161.502952307404 -161.502952307404
60175.77306795546e 42213.07192354373e test-ad 37.2988555882694 37.2988555882694
</pre>
Line 749 ⟶ 2,745:
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.
The source style is F77 (even using the old-style arithmetic statement function) except for the convenience of generic functions taking the type of their parameters to save on the bother of DCMPLX instead of just CMPLX, etc. Floating-point constants in the test data are specified with ~D0, the exponential form that signifies double precision otherwise they would be taken as single precision values. Some compilers offer an option stating that all floating-point constants are to be taken as double precision. REAL*8 precision amounts to about sixteen decimal digits, so some of the supplied values will not be accurately represented, unless something beyond REAL*8 is available. <
REAL*8 B1,B2 !Maximum precision, for large-angle folding.
COMPLEX*16 CIS,Z1,Z2,Z !Scratchpads.
Line 779 ⟶ 2,775:
END DO
END</
The output shows the stages:
<pre>
Line 800 ⟶ 2,796:
=={{header|FreeBASIC}}==
<
' compile with: fbc -s console
Line 848 ⟶ 2,844:
Print : Print "hit any key to end program"
Sleep
End</
{{out}}
<pre> b1 b2 difference
Line 864 ⟶ 2,860:
1174.8380510598461 -154146.6649012475973 -161.5029523074336
60175.7730679554588 42213.0719235437282 37.2988555882694</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
void local fn GetDifference( b1 as float, b2 as float )
float r = ( b2 - b1 ) mod 360.0
if r >= 180.0 then r = r - 360.0
printf @"%9.1f\u00B0 %10.1f\u00B0 = %7.1f\u00B0", b1, b2, r
end fn
printf @"Input in -180 to +180 range:"
printf @"-----------------------------------"
printf @"%9s %12s %15s", "b1", "b2", "distance"
printf @"-----------------------------------"
fn GetDifference( 20.0, 45.0 )
fn GetDifference( -45.0, 45.0 )
fn GetDifference( -85.0, 90.0 )
fn GetDifference( -95.0, 90.0 )
fn GetDifference( -45.0, 125.0 )
fn GetDifference( -45.0, 145.0 )
fn GetDifference( -45.0, 125.0 )
fn GetDifference( -45.0, 145.0 )
fn GetDifference( 29.4803, -88.6381 )
fn GetDifference( -78.3251, -159.036 )
fn GetDifference( -70099.74233810938, 29840.67437876723 )
fn GetDifference( -165313.6666297357, 33693.9894517456 )
fn GetDifference( 1174.8380510598456, -154146.66490124757 )
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
-----------------------------------
b1 b2 distance
-----------------------------------
20.0° 45.0° = 25.0°
-45.0° 45.0° = 90.0°
-85.0° 90.0° = 175.0°
-95.0° 90.0° = -175.0°
-45.0° 125.0° = 170.0°
-45.0° 145.0° = -170.0°
-45.0° 125.0° = 170.0°
-45.0° 145.0° = -170.0°
29.5° -88.6° = -118.1°
-78.3° -159.0° = -80.7°
-70099.7° 29840.7° = -139.6°
-165313.7° 33694.0° = -72.3°
1174.8° -154146.7° = -161.5°
</pre>
=={{header|Go}}==
Line 869 ⟶ 2,913:
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"
Line 901 ⟶ 2,945:
return d
}
}</
{{out}}
<pre>
Line 916 ⟶ 2,960:
A feature here is that the function body is a one-liner sufficient for the task test cases.
<
import (
Line 946 ⟶ 2,990:
func angleDifference(b2, b1 float64) float64 {
return math.Mod(math.Mod(b2-b1, 360)+360+180, 360) - 180
}</
{{out}}
<pre>
Line 966 ⟶ 3,010:
'''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 ],
Line 998 ⟶ 3,042:
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:'''
Line 1,016 ⟶ 3,060:
=={{header|Haskell}}==
<
import Data.Bifunctor (bimap)
import Text.Printf (printf)
type Radians = Float
Line 1,022 ⟶ 3,068:
type Degrees = Float
---------- ANGLE DIFFERENCE BETWEEN TWO BEARINGS ---------
bearingDelta :: (Radians
bearingDelta (a, b) -- sign * dot-product
=
sign * acos ((ax * bx) + (ay * by))
where
(ax, ay) = (sin a, cos a)
Line 1,035 ⟶ 3,081:
| otherwise = -1
angleBetweenDegrees =
degrees
. bearingDelta
. join bimap radians
main :: IO ()
main =
putStrLn . unlines $
(
<*> angleBetweenDegrees
(-45.0, 125.0),
(-45.0, 145.0)
]
------------------------- GENERIC ------------------------
degrees :: Radians -> Degrees
degrees = (/ pi) . (180 *)
radians :: Degrees -> Radians
radians = (/ 180) . (pi *)</syntaxhighlight>
{{Out}}
<pre> 20.00°
-45.00°
-85.00°
-95.00°
-45.00°
-45.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
150 PRINT "Difference: ";B</
=={{header|J}}==
<syntaxhighlight lang="j">relativeBearing=: 180 - 360 | 180 + -
tests=: _99&".;._2 noun define
20 45
-45 45
Line 1,086 ⟶ 3,142:
1174.8380510598456 -154146.66490124757
60175.77306795546 42213.07192354373
)</syntaxhighlight>
<pre> tests ,. relativeBearing/"1 tests
20 45 25
_45 45 90
Line 1,099 ⟶ 3,156:
_165314 33694 _72.3439
1174.84 _154147 _161.503
60175.8 42213.1 37.2989</
=={{header|Java}}==
{{trans|C++}}
<
public static double getDifference(double b1, double b2) {
Line 1,133 ⟶ 3,190:
System.out.println(getDifference(60175.77306795546, 42213.07192354373));
}
}</
{{out}}
Line 1,157 ⟶ 3,214:
This approach should be reliable but it is also very inefficient.
<
{
b1y = Math.cos(b1Rad);
Line 1,191 ⟶ 3,248:
+relativeBearing(60175.77306795546*deg2rad, 42213.07192354373*deg2rad)*rad2deg+"\n";
}</
{{out}}
Line 1,211 ⟶ 3,268:
===ES6===
<
"use strict";
// ------ ANGLE DIFFERENCE BETWEEN TWO BEARINGS ------
// bearingDelta :: Radians -> Radians -> Radians
const bearingDelta =
// The difference between two bearings: a and b.
b => {
const [ax, ay] = [sin(a), cos(a)];
const [bx, by] = [sin(b), cos(b)];
// Cross-product
const sign = ((ay * bx) - (by * ax)) > 0 ?
+1
) : -1;
// Sign * dot-product.
return sign * acos((ax * bx) + (ay * by));
};
// ---------------------- TEST -----------------------
// main :: IO ()
const main = () => [
[20, 45],
[-45, 45],
Line 1,255 ⟶ 3,300:
[-45, 145]
].map(xy => showMap(...xy))
.join(
// ------------------- FORMATTING --------------------
// showMap :: Degrees -> Degrees -> String
const showMap = (da, db) => {
const
delta = degreesFromRadians(
bearingDelta(
radiansFromDegrees(da)
)(
radiansFromDegrees(db)
)
)
.toPrecision(4),
theta = `${da}° +`.padStart(6, " "),
theta1 = ` ${db}° -> `.padStart(11, " "),
diff = `${delta}°`.padStart(7, " ");
return `${theta}${theta1}${diff}`;
};
// --------------------- GENERIC ---------------------
// radiansFromDegrees :: Float -> Float
const radiansFromDegrees = n =>
Pi * n / 180.0;
// degreesFromRadians :: Float -> Float
const degreesFromRadians = x =>
180.0 * x / Pi;
// Abbreviations for trigonometric methods and
// properties of the standard Math library.
const [
Pi, sin, cos, acos
] = ["PI", "sin", "cos", "acos"]
.map(k => Math[k]);
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<pre>
Line 1,267 ⟶ 3,353:
=={{header|Jsish}}==
<
function angleDifference(bearing1:number, bearing2:number):number {
var angle = (bearing2 - bearing1) % 360;
Line 1,306 ⟶ 3,392:
60175.7730679555° 42213.0719235437° 37.2988555882694°
=!EXPECTEND!=
*/</
{{out}}
<pre>prompt$ jsish -u angleDifference.jsi
[PASS] angleDifference.jsi</pre>
=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
Note that the `%` operator in jq produces integral results.
<syntaxhighlight lang="jq"># Angles are in degrees; the result is rounded to 4 decimal places:
def subtract($b1; $b2):
10000 as $scale
| (($scale * ($b2 - $b1)) % (360 * $scale)) | round / $scale
| if . < -180 then . + 360
elif . >= 180 then . - 360
else .
end;
def pairs:
[ 20, 45],
[-45, 45],
[-85, 90],
[-95, 90],
[-45, 125],
[-45, 145],
[ 29.4803, -88.6381],
[-78.3251, -159.036],
[-70099.74233810938, 29840.67437876723],
[-165313.6666297357, 33693.9894517456],
[1174.8380510598456, -154146.66490124757],
[60175.77306795546, 42213.07192354373] ;
"Differences (to 4dp) between these bearings:",
( pairs as [$p0, $p1]
| subtract($p0; $p1) as $diff
| (if $p0 < 0 then " " else " " end) as $offset
| "\($offset)\($p0) and \($p1) -> \($diff)" )</syntaxhighlight>
{{out}}
<pre>
Differences (to 4dp) between these bearings:
20 and 45 -> 25
-45 and 45 -> 90
-85 and 90 -> 175
-95 and 90 -> -175
-45 and 125 -> 170
-45 and 145 -> -170
29.4803 and -88.6381 -> -118.1184
-78.3251 and -159.036 -> -80.7109
-70099.74233810938 and 29840.67437876723 -> -139.5833
-165313.6666297357 and 33693.9894517456 -> -72.344
1174.8380510598456 and -154146.66490124757 -> -161.5029
60175.77306795546 and 42213.07192354373 -> 37.2989
</pre>
Differences (to 4dp) between these bearings:
20 and 45 -> 25
-45 and 45 -> 90
-85 and 90 -> 175
-95 and 90 -> -175
-45 and 125 -> 170
-45 and 145 -> -170
29.4803 and -88.6381 -> -118.1184
-78.3251 and -159.036 -> -80.7109
-70099.74233810938 and 29840.67437876723 -> -139.5833
-165313.6666297357 and 33693.9894517456 -> -72.344
1174.8380510598456 and -154146.66490124757 -> -161.5029
60175.77306795546 and 42213.07192354373 -> 37.2989
=={{header|Julia}}==
{{trans|Python}}
<
function angdiff(a, b)
Line 1,336 ⟶ 3,489:
(1174.8380510598456, -154146.66490124757), (60175.77306795546, 42213.07192354373)]
@printf("% 9.1f - % 9.1f = % 6.1f\n", a, b, angdiff(a, b))
end</
{{out}}
Line 1,358 ⟶ 3,511:
=={{header|K}}==
<syntaxhighlight lang="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}
</syntaxhighlight>
The output of a session is given below:
Line 1,390 ⟶ 3,543:
</pre>
=={{header|Klingphix}}==
{{trans|NewLISP}}
<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy
:bearing sub 360 mod 540 add 360 mod 180 sub ;
20 45 bearing
-45 45 bearing
-85 90 bearing
-95 90 bearing
-45 125 bearing
-45 145 bearing
29.4803 -88.6381 bearing
-78.3251 -159.036 bearing
-70099.74233810938 29840.67437876723 bearing
-165313.6666297357 33693.9894517456 bearing
1174.8380510598456 -154146.66490124757 bearing
60175.77306795546 42213.07192354373 bearing
pstack
" " input</syntaxhighlight>
{{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) {
Line 1,425 ⟶ 3,603:
println(f.format(ap.first, ap.second, diff.value))
}
}</
{{out}}
Line 1,448 ⟶ 3,626:
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)
Line 1,507 ⟶ 3,685:
end
main()</
{{out}}
Line 1,525 ⟶ 3,703:
=={{header|Maple}}==
{{trans|C++}}
<
local r:
r := frem(b2 - b1, 360):
Line 1,542 ⟶ 3,720:
getDiff(-165313.6666297357,33693.9894517456);
getDiff(1174.8380510598456,-154146.66490124757);
getDiff(60175.77306795546,42213.07192354373)</
{{Out}}
<pre>25
Line 1,556 ⟶ 3,734:
-161.5030
37.29885</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">ClearAll[AngleDifference]
AngleDifference[b1_, b2_] := Mod[b2 - b1, 360, -180]
AngleDifference[20, 45]
AngleDifference[-45, 45]
AngleDifference[-85, 90]
AngleDifference[-95, 90]
AngleDifference[-45, 125]
AngleDifference[-45, 145]
AngleDifference[29.4803, -88.6381]
AngleDifference[-78.3251, -159.036]
AngleDifference[-70099.74233810938, 29840.67437876723]
AngleDifference[-165313.6666297357, 33693.9894517456]
AngleDifference[1174.8380510598456, -154146.66490124757]
AngleDifference[60175.77306795546, 42213.07192354373]</syntaxhighlight>
{{out}}
<pre>25
90
175
-175
170
-170
-118.118
-80.7109
-139.583
-72.3439
-161.503
37.2989</pre>
=={{header|Modula-2}}==
{{trans|Java}}
<
PROCEDURE WriteRealLn(value : REAL);
Line 1,602 ⟶ 3,811:
ReadChar;
END Bearings.</
=={{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))
Line 1,623 ⟶ 3,832:
(bearing- 1174.8380510598456 -154146.66490124757)
(bearing- 60175.77306795546 42213.07192354373))
</syntaxhighlight>
{{out}}
Line 1,642 ⟶ 3,851:
=={{header|Nim}}==
<
import strutils
Line 1,673 ⟶ 3,882:
vector.b2.formatFloat(ffDecimal, 2).align(13) &
delta(vector.b1, vector.b2).formatFloat(ffDecimal, 2).align(13)
</syntaxhighlight>
{{out}}
Line 1,689 ⟶ 3,898:
1174.84 -154146.66 -161.50
60175.77 42213.07 37.30
</pre>
=={{header|Nutt}}==
{{trans|Java}}
<syntaxhighlight lang="Nutt">
module main
imports native.io.output.say
funct get_difference(b1:Float,b2:Float):Float=
var r:Float=(b2-b1)%360.0
doif r< -180.0 r=r+360.0
doif r>=180.0 r=r-360.0
yield r
return
say("Input in -180 to +180 range")
say(get_difference(20.0,45.0))
say(get_difference(-45.0,45.0))
say(get_difference(-85.0,90.0))
say(get_difference(-95.0,90.0))
say(get_difference(-45.0,125.0))
say(get_difference(-45.0,145.0))
say(get_difference(-45.0,125.0))
say(get_difference(-45.0,145.0))
say(get_difference(29.4803,-88.6381))
say(get_difference(-78.3251,-159.036))
say("Input in wider range")
say(get_difference(-70099.74233810938,29840.67437876723))
say(get_difference(-165313.6666297357,33693.9894517456))
say(get_difference(1174.8380510598456,-154146.66490124757))
say(get_difference(60175.77306795546,42213.07192354373))
end
</syntaxhighlight>
{{output}}
<pre>
Input in -180 to +180 range
25.0
90.0
175.0
-175.0
170.0
-170.0
170.0
-170.0
-118.1184
-80.7109
Input in wider range
-139.58328312339
-72.3439185187
-161.5029523074156
37.29885558827
</pre>
=={{header|Objeck}}==
{{trans|Java}}
<syntaxhighlight lang="objeck">class AngleBearings {
function : Main(args : String[]) ~ Nil {
"Input in -180 to +180 range"->PrintLine();
GetDifference(20.0, 45.0)->PrintLine();
GetDifference(-45.0, 45.0)->PrintLine();
GetDifference(-85.0, 90.0)->PrintLine();
GetDifference(-95.0, 90.0)->PrintLine();
GetDifference(-45.0, 125.0)->PrintLine();
GetDifference(-45.0, 145.0)->PrintLine();
GetDifference(-45.0, 125.0)->PrintLine();
GetDifference(-45.0, 145.0)->PrintLine();
GetDifference(29.4803, -88.6381)->PrintLine();
GetDifference(-78.3251, -159.036)->PrintLine();
"Input in wider range"->PrintLine();
GetDifference(-70099.74233810938, 29840.67437876723)->PrintLine();
GetDifference(-165313.6666297357, 33693.9894517456)->PrintLine();
GetDifference(1174.8380510598456, -154146.66490124757)->PrintLine();
GetDifference(60175.77306795546, 42213.07192354373)->PrintLine();
}
function : native : GetDifference(b1 : Float, b2 : Float) ~ Float {
r := Float->Mod(b2 - b1, 360.0);
if (r < -180.0) {
r += 360.0;
};
if (r >= 180.0) {
r -= 360.0;
};
return r;
}
}</syntaxhighlight>
{{output}}
<pre>
Input in -180 to +180 range
25
90
175
-175
170
-170
170
-170
-118.118
-80.7109
Input in wider range
-139.583
-72.3439
-161.503
37.2989
</pre>
=={{header|OCaml}}==
{{trans|D}}
<
let r = mod_float (b2 -. b1) 360.0 in
if r < -180.0
Line 1,719 ⟶ 4,040:
Printf.printf " %g\n" (get_diff 1174.8380510598456 (-154146.66490124757));
Printf.printf " %g\n" (get_diff 60175.77306795546 42213.07192354373);
;;</
{{out}}
Line 1,740 ⟶ 4,061:
=={{header|PARI/GP}}==
<
anglediff(x,y)=centerliftmod1((y-x)/360)*360;
vecFunc(f)=v->call(f,v);
apply(vecFunc(anglediff), [[20,45], [-45,45], [-85,90], [-95,90], [-45,125], [-45,145], [29.4803,-88.6381], [-78.3251,-159.036], [-70099.74233810938,29840.67437876723], [-165313.6666297357,33693.9894517456], [1174.8380510598456,-154146.66490124757], [60175.77306795546,42213.07192354373]])</
{{out}}
<pre>%1 = [25, 90, 175, -175, 170, -170, -118.11840000000000000000000000000000000, -80.710900000000000000000000000000000000, -139.58328312339000000000000000000000023, -72.343918518700000000000000000000000733, -161.50295230741560000000000000000000000, 37.298855588269999999999999999999999909]</pre>
Line 1,751 ⟶ 4,072:
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.
<syntaxhighlight lang="pascal">
Program Bearings;
{ Reads pairs of angles from a file and subtracts them }
Line 1,800 ⟶ 4,121:
close(angleFile)
End.
</syntaxhighlight>
{{in}}
Line 1,830 ⟶ 4,151:
-154146.66490124760 - 1174.83805105985 = -161.50295230740
42213.07192354373 - 60175.77306795546 = 37.29885558827
=={{header|PascalABC.NET}}==
<syntaxhighlight lang="delphi">
function delta(b1, b2: real): real;
begin
result := (b2 - b1) - Trunc((b2 - b1) / 360.0) * 360.0;
if result < -180.0 then result += 360.0
else if result >= 180.0 then result -= 360.0
end;
begin
var testVectors :=
|(20.00, 45.00), (-45.00, 45.00), (-85.00, 90.00),
(-95.00, 90.00), (-45.00, 125.00), (-45.00, 145.00),
(29.48, -88.64), (-78.33, -159.04), (-70099.74, 29840.67),
(-165313.67, 33693.99), (1174.84, -154146.66), (60175.77, 42213.07)|;
foreach var vector in testVectors do
writeln(vector[0]:10:2, vector[1]:12:2, delta(vector[0], vector[1]):10:2);
end.
</syntaxhighlight>
=={{header|Perl}}==
Perl's built-in modulo is integer-only, so import a suitable one from the <code>POSIX</code> core module
<
sub angle {
Line 1,861 ⟶ 4,202:
printf "%10.2f %10.2f = %8.2f\n", $b1, $b2, angle($b1,$b2);
}
</syntaxhighlight>
{{out}}
<pre> 20.00 45.00 = 25.00
Line 1,877 ⟶ 4,218:
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<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: #004080;">string</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%16f"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">a</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">to</span> <span style="color: #000000;">1</span> <span style="color: #008080;">by</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'0'</span> <span style="color: #008080;">or</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #008000;">'.'</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">' '</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">!=</span><span style="color: #008000;">'0'</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">b1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b2</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">atom</span> <span style="color: #000000;">diff</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mod</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b2</span><span style="color: #0000FF;">-</span><span style="color: #000000;">b1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">360</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">diff</span> <span style="color: #0000FF;">-=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #000000;">diff</span><span style="color: #0000FF;">></span><span style="color: #000000;">180</span><span style="color: #0000FF;">?</span><span style="color: #000000;">360</span><span style="color: #0000FF;">:</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s %s %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">tz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b1</span><span style="color: #0000FF;">),</span><span style="color: #000000;">tz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">b2</span><span style="color: #0000FF;">),</span><span style="color: #000000;">tz</span><span style="color: #0000FF;">(</span><span style="color: #000000;">diff</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" b1 b2 diff\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"---------------- ---------------- ----------------\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">45</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">85</span><span style="color: #0000FF;">,</span><span style="color: #000000;">90</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">95</span><span style="color: #0000FF;">,</span><span style="color: #000000;">90</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">125</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">45</span><span style="color: #0000FF;">,</span><span style="color: #000000;">145</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">29.4803</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">88.6381</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">78.3251</span><span style="color: #0000FF;">,-</span><span style="color: #000000;">159.036</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">70099.74233810938</span><span style="color: #0000FF;">,</span><span style="color: #000000;">29840.67437876723</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">test</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">165313.6666297357</span><span style="color: #0000FF;">,</span><span style="color: #000000;">33693.9894517456</span><span style="color: #0000FF;">)</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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 1,927 ⟶ 4,270:
60175.773068 42213.071924 37.298856
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
( "16" 1 "16" 1 "16" ) var al
def difAngle /# b1 b2 -- diff #/
swap - 360 mod
dup 180 > if 360 - endif
enddef
def test /# b1 b2 -- #/
over over difAngle >ps swap " " rot " " ps> 5 tolist
al lalign ?
enddef
( "b1" " " "b2" " " "diff" ) al lalign ?
"---------------- ---------------- ----------------" ?
20 45 test
-45 45 test
-85 90 test
-95 90 test
-45 125 test
-45 145 test
29.4803 -88.6381 test
-78.3251 -159.036 test
-70099.74233810938 29840.67437876723 test
-165313.6666297357 33693.9894517456 test
1174.8380510598456 -154146.66490124757 test
60175.77306795546 42213.07192354373 test</syntaxhighlight>
{{out}}
<pre> b1 b2 diff
---------------- ---------------- ----------------
20 45 25
-45 45 90
-85 90 175
-95 90 -175
-45 125 170
-45 145 -170
29.4803 -88.638099999999 -118.11840000000
-78.325100000000 -159.03600000000 -80.710899999999
-70099.742338109 29840.6743787672 -139.58328312338
-165313.66662973 33693.9894517455 -72.343918518687
1174.83805105984 -154146.66490124 -161.50295230740
60175.7730679554 42213.0719235437 37.2988555882693
=== Press any key to exit ===</pre>
=={{header|PowerShell}}==
This implementation takes two user inputs with ''Get-AngleDiff'' or prints the
examples with ''Get-Examples''. There is also a full help file accessed by typing
''Get-Help Get-AngleDiff -full''
<syntaxhighlight lang="powershell">
<#
.Synopsis
Gets the difference between two angles between the values of -180 and 180.
To see examples use "Get-Examples"
.DESCRIPTION
This code uses the modulo operator, this is represented with the "%".
The modulo operator returns the remainder after division, as displayed below
3 % 2 = 1
20 % 15 = 5
200 % 146 = 54
.EXAMPLE
PS C:\WINDOWS\system32> Get-AngleDiff
cmdlet Get-AngleDiff at command pipeline position 1
Supply values for the following parameters:
angle1: 45
angle2: -85
The difference between 45 and -85 is -130
PS C:\WINDOWS\system32>
.EXAMPLE
PS C:\WINDOWS\system32> Get-AngleDiff -angle1 50 -angle2 -65
The difference between 50 and -65 is -115
PS C:\WINDOWS\system32>
.EXAMPLE
PS C:\WINDOWS\system32> Get-AngleDiff -89 50
The difference between -89 and 50 is 139
PS C:\WINDOWS\system32>
#>
function Get-AngleDiff
{
[CmdletBinding()]
Param
(
# Angle one input, must be a number
[Parameter(Mandatory=$true,
ValueFromPipelineByPropertyName=$true)][double]$angle1,
# Angle two input, must be a number
[Parameter(Mandatory=$true,
ValueFromPipelineByPropertyName=$true)][double]$angle2
)
Begin
{
#This is the equation to calculate the difference
[double]$Difference = ($angle2 - $angle1) % 360.0
}
Process
{
#If/IfElse/Else block to return results within the requested range
if ($Difference -lt -180.0)
{$Difference += 360.0
}
elseif ($Difference -gt 360.0)
{$Difference -= 360.0
}
#Writes the values given by the user and the result
Write-Host "The difference between $angle1 and $angle2 is $Difference"
}
End
{
}
}
<#
.Synopsis
This is simply the outputs of the Get-AngleDiff Function in a function
.EXAMPLE
PS C:\WINDOWS\system32> Get-Examples
Inputs from the -180 to 180 range
The difference between 20 and 45 is 25
The difference between -45 and 45 is 90
The difference between -85 and 90 is 175
The difference between -95 and 90 is 185
The difference between -45 and 125 is 170
The difference between -45 and 145 is 190
The difference between -45 and 125 is 170
The difference between -45 and 145 is 190
The difference between 29.4803 and -88.6381 is -118.1184
The difference between -78.3251 and -159.036 is -80.7109
Inputs from a wider range
The difference between -70099.7423381094 and 29840.6743787672 is 220.416716876614
The difference between -165313.666629736 and 33693.9894517456 is 287.656081481313
The difference between 1174.83805105985 and -154146.664901248 is -161.502952307404
The difference between 60175.7730679555 and 42213.0719235437 is 37.2988555882694
PS C:\WINDOWS\system32>
#>
function Get-Examples
{
#blank write-host is used for a blank line to make the output look a lil cleaner
Write-Host
Write-Host "Inputs from the -180 to 180 range"
Get-AngleDiff 20.0 45.0
Get-AngleDiff -45.0 45.0
Get-AngleDiff -85.0 90.0
Get-AngleDiff -95.0 90.0
Get-AngleDiff -45.0 125.0
Get-AngleDiff -45.0 145.0
Get-AngleDiff -45.0 125.0
Get-AngleDiff -45.0 145.0
Get-AngleDiff 29.4803 -88.6381
Get-AngleDiff -78.3251 -159.036
Write-Host
Write-Host "Inputs from a wider range"
Get-AngleDiff -70099.74233810938 29840.67437876723
Get-AngleDiff -165313.6666297357 33693.9894517456
Get-AngleDiff 1174.8380510598456 -154146.66490124757
Get-AngleDiff 60175.77306795546 42213.07192354373
}</syntaxhighlight>
'''Results of user inputs'''<br>
using -45 and 98 with ''Get-AngleDiff'':
<syntaxhighlight lang="powershell">PS C:\WINDOWS\system32> Get-AngleDiff -45 98
The difference between -45 and 98 is 143</syntaxhighlight>
'''Results of ''Get-Examples'''''
<pre>PS C:\WINDOWS\system32> Get-Examples
Inputs from the -180 to 180 range
The difference between 20 and 45 is 25
The difference between -45 and 45 is 90
The difference between -85 and 90 is 175
The difference between -95 and 90 is 185
The difference between -45 and 125 is 170
The difference between -45 and 145 is 190
The difference between -45 and 125 is 170
The difference between -45 and 145 is 190
The difference between 29.4803 and -88.6381 is -118.1184
The difference between -78.3251 and -159.036 is -80.7109
Inputs from a wider range
The difference between -70099.7423381094 and 29840.6743787672 is 220.416716876614
The difference between -165313.666629736 and 33693.9894517456 is 287.656081481313
The difference between 1174.83805105985 and -154146.664901248 is -161.502952307404
The difference between 60175.7730679555 and 42213.0719235437 is 37.2988555882694
</pre>
=={{header|PureBasic}}==
{{trans|Python}}
<syntaxhighlight lang="purebasic">Procedure.f getDifference (b1.f, b2.f)
r.f = Mod((b2 - b1), 360)
If r >= 180: r - 360
EndIf
PrintN(StrF(b1) + #TAB$ + StrF(b2) + #TAB$ + StrF(r));
EndProcedure
If OpenConsole()
PrintN("Input in -180 to +180 range:")
getDifference(20.0, 45.0)
getDifference(-45.0, 45.0)
getDifference(-85.0, 90.0)
getDifference(-95.0, 90.0)
getDifference(-45.0, 125.0)
getDifference(-45.0, 145.0)
getDifference(-45.0, 125.0)
getDifference(-45.0, 145.0)
getDifference(29.4803, -88.6381)
getDifference(-78.3251, -159.036)
PrintN(#CRLF$ + "Input in wider range:")
getDifference(-70099.74233810938, 29840.67437876723)
getDifference(-165313.6666297357, 33693.9894517456)
getDifference(1174.8380510598456, -154146.66490124757)
getDifference(60175.77306795546, 42213.07192354373)
Repeat: Until Inkey() <> ""
EndIf</syntaxhighlight>
=={{header|Python}}==
{{trans|C++}}
<
def getDifference(b1, b2):
Line 1,957 ⟶ 4,542:
print (getDifference(-165313.6666297357, 33693.9894517456))
print (getDifference(1174.8380510598456, -154146.66490124757))
print (getDifference(60175.77306795546, 42213.07192354373))</
{{out}}
Line 1,980 ⟶ 4,565:
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)
Line 2,068 ⟶ 4,653:
if __name__ == '__main__':
main()</
{{Out}}
<pre>Difference between two bearings:
Line 2,081 ⟶ 4,666:
1174.8380510598456 + -154146.66490124757 -> -161.5
60175.77306795546 + 42213.07192354373 -> 37.3</pre>
Hopefully a lot simpler, elegant and efficient by avoiding conditional statement and trigonometric functions
The table output use print formatting only available from python 3. Tested with 3.6.
{{Works with|Python|3.6}}
<syntaxhighlight lang="python">"""
Difference between two bearings
"""
def delta_bearing(b1 , b2):
return ((b2-b1+540)%360)-180
dataSet = [[20, 45], [-45, 45], [-85, 90], [-95, 90], [-45, 125], [-45, 145], \
[29.4803, -88.6381], [-78.3251, -159.036], \
[-70099.74233810938, 29840.67437876723], \
[-165313.6666297357, 33693.9894517456], \
[1174.8380510598456, -154146.66490124757], \
[60175.77306795546, 42213.07192354373]]
print('.{:-^19}.{:-^19}.{:-^9}.' .format(" b1 ", " b2 ", " Δ b " ))
for Δ in dataSet:
print('|{: > 19}|{: > 19}|{: > 9.4f}|' .format(Δ[0], Δ[1],delta_bearing(Δ[0],Δ[1])))</syntaxhighlight>
{{Out}}
<pre>.------- b1 --------.------- b2 --------.-- Δ b --.
| 20| 45| 25.0000|
| -45| 45| 90.0000|
| -85| 90| 175.0000|
| -95| 90|-175.0000|
| -45| 125| 170.0000|
| -45| 145|-170.0000|
| 29.4803| -88.6381|-118.1184|
| -78.3251| -159.036| -80.7109|
| -70099.74233810938| 29840.67437876723|-139.5833|
| -165313.6666297357| 33693.9894517456| -72.3439|
| 1174.8380510598456|-154146.66490124757|-161.5030|
| 60175.77306795546| 42213.07192354373| 37.2989|</pre>
=={{header|Quackery}}==
Using the Quackery big number rational arithmetic library <code>bigrat.qky</code>.
<syntaxhighlight lang="quackery"> [ $ "bigrat.qky" loadfile ] now!
[ v- -v
proper rot
360 mod
unrot improper
180 1 2over v< iff
[ 360 1 v- ] done
2dup -180 1 v< if
[ 360 1 v+ ] ] is angledelta ( n/d n/d --> n/d )
' [ [ $ "20" $ "45" ]
[ $ "-45" $ "45" ]
[ $ "85" $ "90" ]
[ $ "-95" $ "90" ]
[ $ "-45" $ "125" ]
[ $ "45" $ "145" ]
[ $ "29.4803" $ "-88.6361" ]
[ $ "-78.3251" $ "-159.0360" ]
[ $ "-70099.74233810938" $ "29840.67437876723" ]
[ $ "-165313.6666297357" $ "33693.9894517456" ]
[ $ "1174.8380510598456" $ "-154146.66490124757" ]
[ $ "60175.773067955546" $ "42213.07192354373" ] ]
witheach
[ do
dip [ $->v drop ]
$->v drop
angledelta
20 point$ echo$ cr ]</syntaxhighlight>
{{out}}
<pre>25
90
5
-175
170
100
-118.1164
-80.7109
-139.58328312339
-72.3439185187
-161.5029523074156
37.298855588184</pre>
=={{header|Racket}}==
Line 2,086 ⟶ 4,757:
''see my comments in discussion regards bearing-heading or vice versa''
<
(define (% a b) (- a (* b (truncate (/ a b)))))
Line 2,113 ⟶ 4,784:
(check-equal? (% 17.5 10) 7.5)
(check-equal? (% -7.5 10) -7.5)
(check-equal? (% -17.5 10) -7.5))</
{{out}}
Line 2,133 ⟶ 4,804:
{{works with|Rakudo|2016.11}}
<syntaxhighlight lang="raku"
(my $b = ($b2 - $b1 + 720) % 360) > 180 ?? $b - 360 !! $b;
}
Line 2,150 ⟶ 4,821:
60175.77306795546, 42213.07192354373
-> $b1, $b2 { printf "%10.2f %10.2f = %8.2f\n", $b1, $b2, $b1 ∠ $b2 }</
{{out}}
<pre> 20.00 45.00 = 25.00
Line 2,167 ⟶ 4,838:
=={{header|REXX}}==
Some extra coding was added for a better visual presentation; the angles were centered, the answers were aligned.
<
numeric digits 25 /*use enough dec. digits for angles*/
call show 20, 45 /*display angular difference (deg).*/
Line 2,187 ⟶ 4,858:
if pos(., x)\==0 then x=strip( strip(x, 'T', 0), "T", .) /*strip trailing chaff.*/
say center(a || $, d) '─' center(b || $, d) " ────► " x || $
return /* [↑] display the angular difference.*/</
{{out|output}}
<pre>
Line 2,205 ⟶ 4,876:
=={{header|Ring}}==
<
# Project : Angle difference between two bearings
Line 2,227 ⟶ 4,898:
end
return r
</syntaxhighlight>
Output:
<pre>
Line 2,241 ⟶ 4,912:
-118.1184
-80.7109
</pre>
=={{header|RPL}}==
≪ SWAP - 360 MOD
'''IF''' DUP 180 > '''THEN''' 360 - '''END''' ≫ 'BDIFF' STO
{{in}}
<pre>
20 45 BDIFF
-45 45 BDIFF
-85 90 BDIFF
-95 90 BDIFF
-45 125 BDIFF
-45 145 BDIFF
29.4803 -88.6381 BDIFF
-78.3251 -159.036 BDIFF
</pre>
{{out}}
<pre>
8: 25
7: 90
6 175
5: -175
4: 170
3: -170
2: -118.1184
1: -80.7109
</pre>
=={{header|Ruby}}==
{{trans|C++}}
<
r = (b2 - b1) % 360.0
# Ruby modulus has same sign as divisor, which is positive here,
Line 2,273 ⟶ 4,970:
puts getDifference(1174.8380510598456, -154146.66490124757)
puts getDifference(60175.77306795546, 42213.07192354373)
end</
{{out}}
Line 2,292 ⟶ 4,989:
-161.50295230740448
37.29885558826936</pre>
=={{header|Run BASIC}}==
<syntaxhighlight lang="runbasic">sub getDifference b1, b2
r = (b2 - b1) mod 360
if r >= 180 then r = r - 360
print r
end sub
print "Input in -180 to +180 range:"
call getDifference 20, 45
call getDifference -45, 45
call getDifference -85, 90
call getDifference -95, 90
call getDifference -45, 125
call getDifference -45, 145
call getDifference -45, 125
call getDifference -45, 145
call getDifference 29.4803, -88.6381
call getDifference -78.3251, -159.036
print "Input in wider range:"
call getDifference -70099.74233810938, 29840.67437876723
call getDifference -165313.6666297357, 33693.9894517456
call getDifference 1174.8380510598456, -154146.66490124757</syntaxhighlight>
=={{header|Rust}}==
<
/// Calculate difference between two bearings, in -180 to 180 degrees range
pub fn angle_difference(bearing1: f64, bearing2: f64) -> f64 {
Line 2,334 ⟶ 5,054:
}
}
</syntaxhighlight>
=={{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
Line 2,362 ⟶ 5,082:
println(getDifference(60175.77306795546, 42213.07192354373))
}</
=={{header|Scheme}}==
R6RS standard.
<syntaxhighlight lang="scheme">#!r6rs
(import (rnrs base (6))
(rnrs io simple (6)))
(define (bearing-difference bearing-2 bearing-1)
(- (mod (+ (mod (- bearing-2 bearing-1)
360)
540)
360)
180))
(define (bearing-difference-test)
(define test-cases
'((20 45)
(-45 45)
(-85 90)
(-95 90)
(-45 125)
(-45 145)
(29.4803 -88.6381)
(-78.3251 -159.036)
(-70099.74233810938 29840.67437876723)
(-165313.6666297357 33693.9894517456)
(1174.8380510598456 -154146.66490124757)
(60175.77306795546 42213.07192354373)))
(for-each
(lambda (argument-list)
(display (apply bearing-difference argument-list))
(newline))
test-cases))</syntaxhighlight>
{{out}}
<pre>> (bearing-difference-test)
-25
-90
-175
175
-170
170
118.11839999999995
80.71090000000004
139.58328312338563
72.34391851868713
161.50295230740448
-37.29885558826936
</pre>
=={{header|Seed7}}==
Line 2,369 ⟶ 5,139:
which can be used to solve this task easily.
<
include "float.s7i";
Line 2,400 ⟶ 5,170:
writeln(getDifference(1174.8380510598456, -154146.66490124757));
writeln(getDifference(60175.77306795546, 42213.07192354373));
end func;</
{{out}}
Line 2,423 ⟶ 5,193:
=={{header|Sidef}}==
<
(var b = ((b2 - b1 + 720) % 360)) > 180 ? (b - 360) : b
}
Line 2,447 ⟶ 5,217:
) {
printf("%25s %25s %25s\n", b1, b2, bearingAngleDiff(b1, b2))
}</
{{out}}
<pre> B1 B2 Difference
Line 2,466 ⟶ 5,236:
=={{header|Swift}}==
<
let diff = (a2 - a1).truncatingRemainder(dividingBy: 360)
Line 2,493 ⟶ 5,263:
]
print(testCases.map(angleDifference))</
{{out}}
Line 2,500 ⟶ 5,270:
=={{header|Tcl}}==
<
proc angleDiff {b1 b2} {
set angle [::tcl::mathfunc::fmod [expr ($b2 - $b1)] 360]
Line 2,529 ⟶ 5,299:
puts [angleDiff 1174.8380510598456 -154146.66490124757]
puts [angleDiff 60175.77306795546 42213.07192354373]
</syntaxhighlight>
{{out}}
<pre>
Line 2,551 ⟶ 5,321:
=={{header|VBA}}==
{{trans|Phix}}<
Dim s As String
s = CStr(Format(a, "0.######"))
Line 2,584 ⟶ 5,354:
test 1174.83805105985, -154146.664901248
test 60175.7730679555, 42213.0719235437
End Sub</
<pre> b1 b2 diff
---------------- ---------------- ----------------
Line 2,602 ⟶ 5,372:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Function Delta_Bearing(b1 As Decimal, b2 As Decimal) As Decimal
Line 2,652 ⟶ 5,422:
End Sub
End Module</
{{out}}
<pre>25
Line 2,666 ⟶ 5,436:
-161.50295230785
37.2988555882</pre>
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import math
type Bearing = f64
const test_cases = [
[Bearing(20), 45],
[Bearing(-45), 45],
[Bearing(-85), 90],
[Bearing(-95), 90],
[Bearing(-45), 125],
[Bearing(-45), 145],
[Bearing(29.4803), -88.6381],
[Bearing(-78.3251), -159.036],
]
fn main() {
for tc in test_cases {
println(tc[1].sub(tc[0]))
println(angle_difference(tc[1],tc[0]))
}
}
fn (b2 Bearing) sub(b1 Bearing) Bearing {
d := b2 - b1
match true {
d < -180 {
return d + 360
}
d > 180 {
return d - 360
}
else {
return d
}
}
}
fn angle_difference(b2 Bearing, b1 Bearing) Bearing {
return math.mod(math.mod(b2-b1, 360)+360+180, 360) - 180
}</syntaxhighlight>
{{out}}
<pre>
25.
25.
90
90
175.
175.
-175.
-175.
170
170
-170
-170
-118.1184
-118.11840000000001
-80.7109
-80.71089999999998
</pre>
=={{header|Wren}}==
<
var d = (b2 - b1) % 360
if (d < -180) d = d + 360
Line 2,697 ⟶ 5,528:
var offset = (p0 < 0) ? " " : " "
System.print("%(offset)%(p0) and %(p1) -> %(diff)")
}</
{{out}}
Line 2,715 ⟶ 5,546:
60175.773067955 and 42213.071923544 -> 37.2989
</pre>
=={{header|XBS}}==
<syntaxhighlight lang="xbs">settype Bearing = {Angle:number}
class Bearing {
private method construct(Angle:number=0)
self.Angle=(((Angle%360)+540)%360)-180;
method ToString():string
send tostring(math.nround(self.Angle,4))+"°";
private method __sub(b2:Bearing):Bearing{
send new Bearing(self.Angle-b2.Angle);
}
}
const BearingAngles:[[number]] = [
[20,45],
[-45,45],
[-85,90],
[-95,90],
[-45,125],
[-45,145],
[29.4803,-88.6381],
[-78.3251,-159.036],
[-70099.74233810938,29840.67437876723],
[-165313.6666297357,33693.9894517456],
[1174.8380510598456,-154146.66490124757],
[60175.77306795546,42213.07192354373]
];
foreach(v of BearingAngles){
set b1:Bearing=new Bearing(v[0]);
set b2:Bearing=new Bearing(v[1]);
log(b2::ToString()+" - "+b1::ToString()+" = "+(b2-b1)::ToString());
}</syntaxhighlight>
{{out}}
<pre>
45° - 20° = 25°
45° - -45° = 90°
90° - -85° = 175°
90° - -95° = -175°
125° - -45° = 170°
145° - -45° = -170°
-88.6381° - 29.4803° = -118.1184°
-159.036° - -78.3251° = -80.7109°
-39.3256° - 100.2577° = -139.5833°
-146.0105° - -73.6666° = -72.3439°
-66.6649° - 94.8381° = -161.503°
93.0719° - 55.7731° = 37.2989°
</pre>
=={{header|XPL0}}==
Pairs of bearing angles are input from the console or from a file
(terminated with Ctrl+C) redirected on the command line.
<syntaxhighlight lang="xpl0">real B1, B2, Ang;
[Text(0, " Bearing 1 Bearing 2 Difference");
loop [B1:= RlIn(1);
B2:= RlIn(1);
Ang:= B2 - B1;
while Ang > 180. do Ang:= Ang - 360.;
while Ang < -180. do Ang:= Ang + 360.;
CrLf(0);
RlOut(0, B1); ChOut(0, 9);
RlOut(0, B2); ChOut(0, 9);
RlOut(0, Ang);
];
]</syntaxhighlight>
{{out}}
<pre>
Bearing 1 Bearing 2 Difference
20.00000 45.00000 25.00000
-45.00000 45.00000 90.00000
-85.00000 90.00000 175.00000
-95.00000 90.00000 -175.00000
-45.00000 125.00000 170.00000
-45.00000 145.00000 -170.00000
29.48030 -88.63810 -118.11840
-78.32510 -159.03600 -80.71090
-70099.74234 29840.67438 -139.58328
-165313.66663 33693.98945 -72.34392
1174.83805 -154146.66490 -161.50295
60175.77307 42213.07192 37.29886
</pre>
=={{header|Yabasic}}==
{{trans|Python}}
<syntaxhighlight lang="freebasic">// Rosetta Code problem: http://rosettacode.org/wiki/Angle_difference_between_two_bearings
// by Jjuanhdez, 06/2022
print "Input in -180 to +180 range:"
getDifference(20.0, 45.0)
getDifference(-45.0, 45.0)
getDifference(-85.0, 90.0)
getDifference(-95.0, 90.0)
getDifference(-45.0, 125.0)
getDifference(-45.0, 145.0)
getDifference(-45.0, 125.0)
getDifference(-45.0, 145.0)
getDifference(29.4803, -88.6381)
getDifference(-78.3251, -159.036)
print "\nInput in wider range:"
getDifference(-70099.74233810938, 29840.67437876723)
getDifference(-165313.6666297357, 33693.9894517456)
getDifference(1174.8380510598456, -154146.66490124757)
end
sub getDifference(b1, b2)
r = mod((b2 - b1), 360.0)
if r >= 180.0 r = r - 360.0
print r
end sub</syntaxhighlight>
=={{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;"
.fmt(b1,b2,bearingAngleDiff(b1,b2)) });</
{{out}}
<pre>
|