Box the compass: Difference between revisions

* The column of indices can be thought of as an enumeration of the thirty two cardinal points (see [[Talk:Box the compass#Direction, index, and angle|talk page]])..

<br><br>

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

{{trans|Python}}

majors *= 2

V quarter1 = ‘N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N’.split(‘,’)

d -= 5.62

V n = i % 32 + 1

{{out}}

<pre>

1 North 354.38°

</pre>

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

Atari 8-bit computer is able to show up to 40 characters per row. Therefore abbreviations of direction have been used instead of the full names.

{{libheader|Action! Tool Kit}}

INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit

 

Position(x,y) PrintAngle(rh)

OD

{{out}}

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

1 N 354.38

</pre>

=={{header|Ada}}==

 

Inspired by [[#C++|the C++ program]], but without the need for a specific library.

 

 

procedure Box_The_Compass is

Put_Line(Degrees(Degrees'Base(I) * 11.25 + Difference(I mod 3)));

end loop;

 

Output:

354.37 | 32 | North by west

354.38 | 1 | North</pre>

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - no extensions to language used.}}

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

[]STRING

))

OD

Output:

<pre>

32|North by West |NbW | |343°07.50′|348°45.00′|354°22.49′

</pre>

=={{header|AppleScript}}==

OS X Yosemite onwards (uses Foundation classes for record handling etc)

 

Functional composition, allowing for additional languages, and different numbers of compass points – see the test section)

 

use scripting additions

 

((ca's NSString's stringWithString:(str))'s ¬

uppercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

<pre> 1 0.00° North 北

32 354.37° North by west 北微西

1 354.38° North 北 </pre>

 

=={{header|AutoHotkey}}==

{{trans|C++}}

{{works with|AutoHotkey_L}}

return Mod(floor(angle / 11.25 +0.5), 32) + 1

}

. " ", 1, 24) . SubStr(" " a, -5) . "`r`n" ;

}

;Output

<pre> 1 North 0.00

32 North by west 354.37

1 North 354.38</pre>

=={{header|AutoIt}}==

 

Local $avArray[33] = [0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, _

151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, _

StringFormat("%-20s", $namearray[Mod(Floor($Degree / 11.25 + 0.5), 32)]) & " : " & $Degree & @CRLF)

EndFunc ;==>Boxing_the_compass

 

Output : <pre>0 : North : 0

31 : North by west : 354.37

0 : North : 354.38</pre>

=={{header|AWK}}==

BEGIN {

split("N NbE NNE NEbN NE NEbE ENE EbN E EbS ESE SEbE SE SEbS SSE SbE S SbW SSW SWbS SW SWbW WSW WbS W WbN WNW NWbW NW NWbN NNW NbW",A," ");

printf "%6.2f : %2d\t%s\n",$1,box,A[box];

}

Output:

<pre> 0.00 : 1 N

354.38 : 1 N</pre>

 

 

dim names$ = {"North", "North by east", "North-northeast", "Northeast by north", "Northeast", "Northeast by east", "East-northeast", "East by north", "East", "East by south", "East-southeast", "Southeast by east", "Southeast", "Southeast by south", "South-southeast", "South by east", "South", "South by west", "South-southwest", "Southwest by south", "Southwest", "Southwest by west", "West-southwest", "West by south", "West", "West by north", "West-northwest", "Northwest by west", "Northwest", "Northwest by north", "North-northwest", "North by west", "North"}

if j > 31 then j -= 32

print rjust(string(j),2); " "; ljust(string(names$[j+1]),20); grados[i]

 

{{works with|BBC BASIC for Windows}}

bearing() = 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, \

\ 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, \

pt$() = "north", "east", "south", "west"

= pt$(pt% DIV 8)

Output:

<pre>0 1 North

354.37 32 North by west

354.38 1 North</pre>

 

=={{header|Befunge}}==

^_@#!`*84:+1<v*9"}"*+55,,,".",,,$$_^#!:-1g60/+55\<

>_06g:v>55+,^>/5+55+/48*::::,,,,%:1+.9,:06p48*\-0v

W>0"tsaE"0"htron yb tsaE"0"tsaehtron-tsaE"0"tsae"v

#v"rtheast by north"0"Northeast"0"Northeast by "<<

 

{{output}}

354.37 32 North by west

354.38 1 North</pre>

=={{header|C}}==

Like [[wp:Box the compass|Wikipedia's article]], this program uses indexes to count the headings. There are now 33 headings, from 1 to 33, because 0.0 and 354.38 are different angles. (This differs from the task pseudocode, which mapped the 32 compass points to indexes.)

 

 

int main()

 

return 0;

<pre>

1 North 0.00

1 North 354.38

</pre>

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

using System;

using System.Collections.Generic;

}

}

{{out}}

<pre>

1: North : 354.38

</pre>

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

Using the Boost libraries

{{libheader|Boost}}

#include <boost/array.hpp>

#include <boost/assign/list_of.hpp>

}

return 0;

Output:

<pre>

1 North 354.38

</pre>

=={{header|Clojure}}==

{{trans|Tcl}}

(:use [clojure.string :only [capitalize]]))

(apply str (map-indexed #(format "%2s %-18s %7.2f\n"

(inc (mod %1 32)) (angle2compass %2) %2)

Output:

<pre> 1 North 0.00

32 North by west 354.37

1 North 354.38</pre>

=={{header|COBOL}}==

Works with GnuCOBOL

program-id. box-compass.

data division.

display compass-point space show-degrees

end-perform

 

{{out}}

1 North 354.38

</pre>

=={{header|D}}==

{{trans|Java}}

 

struct boxTheCompass {

heading.boxTheCompass, heading);

}

{{out}}

<pre>1 North 0

 

===Alternative version===

import std.stdio;

 

writefln("%2d %18s %6.2f", i + 1, box[i], phi);

}

{{out}}

<pre> 1 North 0.00

32 North by west 354.37

1 North 354.38</pre>

=={{header|Delphi}}==

See [https://rosettacode.org/wiki/Box_the_compass#Pascal Pascal].

 

=={{header|Elixir}}==

{{trans|Ruby}}

defp head do

Enum.chunk(~w(north east south west north), 2, 1)

end

 

 

{{out}}

 

=={{header|Euphoria}}==

"Northeast","Northeast by east","East-northeast","East by north","East",

"East by south","East-southeast","Southeast by east","Southeast","Southeast by south",

j = deg2ind(degrees[i])

printf(1, "%6.2f %2d %-22s\n", {degrees[i], j, names[j]})

 

Output:

354.37 32 North by west

354.38 1 North</pre>

=={{header|F_Sharp|F#}}==

{{trans|Perl}}

"North"; "North by east"; "North-northeast"; "Northeast by north";

"Northeast"; "Northeast by east"; "East-northeast"; "East by north";

|> List.iter (fun phi ->

let i = (int (phi * 32. / 360. + 0.5)) % 32

{{out}}

<pre> 1 North 0.00°

32 North by west 354.37°

1 North 354.38°</pre>

=={{header|Factor}}==

 

CONSTANT: box

dup 32 * 360 /f 0.5 + >integer 32 mod [ 1 + ] [ box nth ] bi

"%6.2f° %2d %s\n" printf

{{out}}

<pre>

354.38° 1 North

</pre>

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

implicit none

 

compasspoint = points(int(x))

end function compasspoint

Output:

<pre>

32 North by west 354.37

1 North 354.38</pre>

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> 0.00 0 North

354.37 31 North by west

354.38 0 North</pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=823a56ac094b8963cf11f792b381fbcc Click this link to run this code]'''

Dim fDeg As Float[] = [0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]

Dim cHeading As Collection = ["N": "North", "S": "South", "W": "West", "E": "East", "b": "by"]

Next

 

Output:

<pre>

Index= 1 354.38 degrees = North

</pre>

=={{header|Go}}==

 

import "fmt"

fmt.Printf("%4d %-19s %7.2f°\n", index, degrees2compasspoint(h), h)

}

<pre>

Index Compass point Degree

1 North 354.38°

</pre>

=={{header|Groovy}}==

def cardinalDirections = ["north", "east", "south", "west"]

 

354.37, 354.38].eachWithIndex { angle, index ->

println "${(index % 32) + 1}".padRight(3) + "${angle.asCompassPoint().padLeft(20)} $angle\u00b0"

Output:

<pre>1 North 0.0°

32 North by west 354.37°

1 North 354.38°</pre>

=={{header|Haskell}}==

 

import Data.Maybe (fromMaybe)

 

main :: IO ()

Output:

<pre> 1 North 0.00°

32 North by west 354.37°

1 North 354.38°</pre>

=={{header|Huginn}}==

import Text as text;

 

print( "{:2d} | {:6.2f}° | {}\n".format( n, d, c.degrees_to_compasspoint( d ) ) );

}

Output:<pre> # | Angle | Compass point

---+---------|-------------------

32 | 354.37° | North by west

1 | 354.38° | North</pre>

=={{header|Icon}} and {{header|Unicon}}==

{{incomplete|Icon|354.38?}}

procedure main()

return dirs[round(((((d%360)+360)%360)/11.25)%32 + 1)]

 

{{libheader|Icon Programming Library}}

31 north-northwest 337.50

32 north by west 354.37</pre>

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

110 STRING DR$(1 TO 33)*18

120 FOR I=1 TO 33

210 DATA North,North by east,North-northeast,Northeast by north,Northeast,Northeast by east,East-northeast,East by north,East,East by south,East-southeast,Southeast by east,Southeast,Southeast by south,South-southeast,South by east

220 DATA South,South by west,South-southwest,Southwest by south,Southwest,Southwest by west,West-southwest,West by south,West,West by north,West-northwest,Northwest by west,Northwest,Northwest by north,North-northwest,North by west,North

 

Output:<pre> 0 1 North

354.37 32 North by west

354.38 1 North</pre>

=={{header|J}}==

 

subs=: 'N,north,S,south,E,east,W,west,b, by ,'

dirs=: subs (toupper@{., }.)@rplc~L:1 0&(<;._2) 0 :0 -. ' ',LF

)

indice=: 32 | 0.5 <.@+ %&11.25

 

Example use:

 

0 1 2 3 4 5 6 7 8 9

deg2pnt i.10

┌─────┬─────┬─────┬─────┬─────┬─────┬─────────────┬─────────────┬─────────────┬─────────────┐

│North│North│North│North│North│North│North by east│North by east│North by east│North by east│

 

Required example:

 

1 North 0

2 North by east 16.87

31 North-northwest 337.5

32 North by west 354.37

 

}

}

}

}

}

 

=={{header|JavaScript}}==

An iterative, web-based approach:

 

var tr = document.createElement('tr'),

td;

table.appendChild(tbody);

document.body.appendChild(table);

Output:

<pre>1 North 0°

 

Functional composition, allowing for additional languages (and different numbers of compass points)

'use strict';

 

 

return compassTable(5, xs); // 2^5 -> 32 boxes

 

{{Out}}

32 354.37° North by west 北微西

1 354.38° North 北 </pre>

 

=={{header|Julia}}==

{{trans|Python}}

 

 

function degree2compasspoint(d::Float64)

i % 3 == 2 && (d -= 5.62)

@printf("%2i %-17s %10.2f°\n", i % 32 + 1, degree2compasspoint(d), d)

{{out}}

<pre> 1 North 0.00°

The representation of the names was inspired by Tcl (etc.).

 

d,:("E;Ebs;E-se;Sebe;Se;Sebs;S-se;Sbe;")

d,:("S;Sbw;S-sw;Swbs;Sw;Swbw;W-sw;Wbs;")

 

/ calculate the degrees

The table:

1 North 0.00

2 North by east 16.87

31 North-northwest 337.50

32 North by west 354.37

=={{header|Kotlin}}==

 

fun expand(cp: String): String {

println(f.format(index + 1, heading, expand(cp[index])))

}

 

{{out}}

1 354.38 North

</pre>

=={{header|langur}}==

{{trans|D}}

"Northeast", "Northeast by east", "East-northeast", "East by north",

"East", "East by south", "East-southeast", "Southeast by east",

 

for .phi in .angles {

 

{{out}}

 

=={{header|Lasso}}==

local(points = array)

loop(-from=0,-to=32) => {

#pformatted + ' | ' + (#counter < 10 ? ' ') + #counter + ' | ' + compassLong(compassShort->get(#counter)) + '\r'

 

{{out}}

354.37 | 32 | North by west

354.38 | 1 | North</pre>

=={{header|Liberty BASIC}}==

 

for i =1 to 32

data "West by south ", "West ", "West by north ", "West-northwest "

data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "

 

Output:

32 North by west 354.37

1 North 354.38</pre>

=={{header|LLVM}}==

{{trans|C}}

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

 

attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }

{{out}}

<pre> 1 North 0.00

32 North by west 354.37

1 North 354.38</pre>

=={{header|Logo}}==

make "compass_points [ N NbE N-NE NEbN NE NEbE E-NE EbN

E EbS E-SE SEbE SE SEbS S-SE SbE

; and exit

bye

 

Output:

354.37 | North by west | 32

354.38 | North | 1</pre>

=={{header|Lua}}==

{{trans|Logo}}

compass_points = { "N", "NbE", "N-NE", "NEbN", "NE", "NEbE", "E-NE", "EbN",

"E", "EbS", "E-SE", "SEbE", "SE", "SEbS", "S-SE", "SbE",

label = expand_point(abbr)

print(row_format:format(angle, label, index))

 

Output:

354.37 | North by west | 32

354.38 | North | 1</pre>

=={{header|M2000 Interpreter}}==

In a For Next loop we can change loop variable inside block, but the actual loop hidden variable can't change so for next iteration we get the proper value.

 

Module CheckIt {

Locale 1033 'change decimal point char to dot.

}

CheckIt

 

{{out}}

354.38°| 1 | North

</pre >

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

<pre>1 North 0.°

2 North by east 16.87°

32 North by west 354.37°

1 North 354.38°</pre>

=={{header|MATLAB}} / {{header|Octave}}==

b = ceil(mod(d+360/64,360)*32/360);

Output:

<pre>>> x=[0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]';

354.37 : 32

354.38 : 1</pre>

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

FROM FormatString IMPORT FormatString;

FROM RealStr IMPORT RealToStr;

 

ReadChar

=={{header|MUMPS}}==

The TCL implementation was the starting point, but this isn't an exact translation.

;This takes in a degree heading, nominally from 0 to 360, and returns the compass point name.

QUIT:((DEGREE<0)||(DEGREE>360)) "land lubber can't read a compass"

. WRITE $PIECE(X,"^"),?5,DIR,?40,$JUSTIFY($PIECE(POINTS,",",P),10,2),!

KILL POINTS,UP,LO,DIR,P,X

<p>Output:<pre>

Debugger executing 'BOXWRITE^COMPASS'

32 North by west 354.37

1 North 354.38</pre></p>

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary utf8

 

 

return table

 

;Output

1 N North 354.380

</pre>

=={{header|Nim}}==

 

const

index = heading.toCompassIndex

compassHeading = heading.toCompassHeading.alignLeft(maxNameLength)

Output:

<pre> 1 North 0.00

32 North by west 354.37

1 North 354.38</pre>

=={{header|Objeck}}==

class BoxCompass {

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

}

}

 

Output

1 North 354.38

</pre>

=={{header|OCaml}}==

let test_cases = [0.0; 16.87; 16.88; 33.75; 50.62; 50.63; 67.5;

84.37; 84.38; 101.25; 118.12; 118.13; 135.0;

List.iter (print_direction) test_cases;;

 

Sample output:

<pre>

1 North 354.38

</pre>

=={{header|OoRexx}}==

 

Do

End

Exit

 

;Output

1 N North 354.380° (354°22′48″)

</pre>

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

"Northeast by east","East-northeast","East by north","East","East by south","East-southeast",

"Southeast by east","Southeast","Southeast by south","South-southeast","South by east","South",

"West by south","West","West by north","West-northwest","Northwest by west","Northwest",

"Northwest by north","North-northwest","North by west"][round(x*4/45)%32+1]};

 

Output:

32 North by west 354.370000

1 North 354.380000</pre>

=={{header|Pascal}}==

{{trans|Fortran}}

 

function compasspoint(angle: real): string;

writeln((i mod 32) + 1:2, ' ', compasspoint(heading), ' ', heading:8:4);

end;

Output:

<pre>

1 North 354.3800

</pre>

=={{header|Perl}}==

Don't waste brain cells calculating names, not worth the effort. Code is probably shorter, faster, and easier to read this way.

 

my @names = (

my $i = int(($_ * 32 / 360) + .5) % 32;

printf "%3d %18s %6.2f°\n", $i + 1, $names[$i], $_;

2 North by east 16.87°

3 North-northeast 16.88°

31 North-northwest 337.50°

32 North by west 354.37°

=={{header|Phix}}==

Unlike the Perl guy, for me the maths is the boring bit, building those strings is the fun!<br>

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">get225</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p4</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;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_point</span><span style="color: #0000FF;">})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

If you like, you can regard d=1 (both of them) as "clockwise-name-inherit" and d=0 as "anti-clockwise-name-inherit".<br>

{{out}}

</pre>

of course the following (more sensible but less fun, full standalone program) way works just as well, and produces the same output

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">compass_points</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span> <span style="color: #008000;">"North"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North by east"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North-northeast"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Northeast by north"</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;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

=={{header|Picat}}==

{{trans|Nim}}

Names = ["North", "North by east", "North-northeast", "Northeast by north",

"Northeast", "Northeast by east", "East-northeast", "East by north",

printf("%2d %-20s %6.2f\n", J+1, Names[J+1], D)

end,

 

{{out}}

32 North by west 354.37

1 North 354.38</pre>

=={{header|PicoLisp}}==

 

(setq *Compass # Build lookup table

NIL

(cdr (heading H))

Output:

<pre> 1 north 0.00

32 north by west 354.37

1 north 354.38</pre>

=={{header|PowerShell}}==

{

$x = 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38

{{out}}

<pre>north

north</pre>

A more general solution allowing you to choose whether to use 4, 8, 16, or 32 compass points.

{

8 = ( Convert-DegreeToDirection -Degree $Degree -Points 8 )

4 = ( Convert-DegreeToDirection -Degree $Degree -Points 4 ) } }

{{out}}

<pre>Degree 32 16 8 4

354.37 north by west north north north

354.38 north north north north</pre>

=={{header|Prolog}}==

Part 1 : The following knowledge base takes a heading in degrees and returns the correct 32-point compass heading. It can also go in the other direction.

compassangle(1, 'North',n, 0.00).

compassangle(2, 'North by east', nbe, 11.25).

 

resolveindex(Angle, Index) :- N is Angle / 11.25 + 0.5, I is floor(N),Index is (I mod 32) + 1.

Part 2 : The following rules print a table of indexes.

printTableRow(Angle) :- compassangle(Index, Name, _, Angle),

write(Index), write(' '),

printTable([X|Xs]) :- printTableRow(X), nl, printTable(Xs),!.

printTable([]).

The following query prints the required table.

?- printTable([0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62,

185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]).

1 North 354.38

true.

=={{header|PureBasic}}==

Data.s "N", "north", "E", "east", "W", "west", "S", "south", "b", " by " ;abbreviations, expansions

Data.s "N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE" ;dirs

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

Sample output:

<pre> 1 North 0.00

32 North by west 354.37

1 354.38</pre>

=={{header|Python}}==

majors *= 2 # no need for modulo later

quarter1 = 'N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N'.split(',')

elif m == 2: d -= 5.62

n = i % 32 + 1

 

;Output

32 North by west 354.37°

1 North 354.38°</pre>

 

=={{header|QBasic}}==

{{works with|QuickBasic|4.5}}

{{trans|Liberty BASIC}}

 

DIM SHARED point$(32)

IF (x >= 33!) THEN x = x - 32!

compasspoint$ = point$(INT(x))

 

 

=={{header|R}}==

R (also known as Arrr me hearties!) is ideally suited to this task. Here's an easy to understand but inefficient way to solve it:

 

pts <- data.frame(

des = c("N", "NxE", "NNE", "NExN", "NE", "NExE", "ENE", "ExN",

heading <- Vectorize(function(deg) {

res <- pts

res$diff <- abs(res$deg - deg)

res <- res[order(res$diff), ]

res[1,]$des[1]

})

 

Here are the test inputs:

 

test <- data.frame(

deg = c( 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37,

test$heading <- heading(test$deg)

test

 

Check that the output headings cover the full range of headings:

 

all.equal(test$heading, pts$des)

 

{{out}}

[1] TRUE

</pre>

=={{header|Racket}}==

 

;;; Generate the headings and boxes

(check-= (heading->box 5.62) 1 0)

(check-= (heading->box 5.63) 2 0)

 

Output:

32 | 354.37 | North by west

1 | 354.38 | North</pre>

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015.12}}

my $ix = $index % 32;

if $ix +& 1

𝜽,

tc point angle-to-point 𝜽;

 

Output:

1 354.38° North</pre>

=={{header|Red}}==

 

d: charset [#"N" #"E" #"S" #"W"] ;; main directions

hm/:heading: reduce [ (i % 32 + 1 ) expand to-string compass-points/1 [N north b " by " S south E east W west] ]

print-line heading

'''output'''

<pre>

=={{header|REXX}}==

This version does normalization of the (degree) heading and can also handle negative headings.

 

Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].

<br><br>

<pre>

ºheading compass heading

 

=={{header|Ring}}==

# Project : Box the compass

 

ok

next

Output:

<pre>

354.37 31 North by west

354.38 0 North

</pre>

 

=={{header|Ruby}}==

 

[a,

"#{a} by #{b}",

index, name = heading degrees

printf "%2d %20s %6.2f\n", index, name.center(20), degrees

 

{{output}}

 

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

dim direct$(22)

direct$(1) = "y" 'by

data "N","N b e","N-ne","Ne b n","Ne","Ne b e","E-ne","E b n","E","E b s","E-se"

data "Se b e","Se","Se b s","S-se","S b e","S","S b w","S-sw","Sw b s","Sw","Sw b w"

<code><table border=1>

<TR><TD align=right>1</td><td>North</td><td>0.0</td></tr>

</table>

</code>

=={{header|Rust}}==

{{trans|Kotlin}}

let mut out = String::new();

for c in cp.chars() {

);

}

{{out}}

<pre>Index Degrees Compass point

32 354.37 north by west

1 354.38 north</pre>

=={{header|Scala}}==

Inspired by Java version

val cardinal = List("north", "east", "south", "west")

val pointDesc = List("1", "1 by 2", "1-C", "C by 1", "C", "C by 2", "2-C", "2 by 1")

(0 to 32).map(i=>Triple(pointDeg(i),deg2ind(pointDeg(i)),pointName(deg2ind(pointDeg(i)))))

.map{t=>(printf("%s\t%18s\t%s°\n",t._2,t._3,t._1))}

 

Output:

1 North 354.38°

</pre>

=={{header|Seed7}}==

include "float.s7i";

 

degrees[index] digits 2 lpad 6);

end for;

 

Output:

1 North 354.38

</pre>

=={{header|Sidef}}==

{{trans|Raku}}

var ix = (index % 32);

if (ix & 1) { "#{point((ix + 1) & 28)} by #{point(((2 - (ix & 2)) * 4) + ix & 24)}" }

var 𝜽 = test_angle(ix);

printf(" %2d %6.2f° %s\n", ix % 32 + 1, 𝜽, point(angle_to_point(𝜽)).tc);

{{out}}

<pre>

1 354.38° North

</pre>

=={{header|smart BASIC}}==

GET SCREEN SIZE sw,sh

OPTION BASE 1

DATA "Northwest", "NW", "309.38", "315.00", "320.62", "Northwest by north", "NWbN", "320.63", "326.25", "331.87"

DATA "North-northwest", "NNW", "331.88", "337.50", "343.12", "North by west", "NbW", "343.13", "348.75", "354.37"

Output:

<pre>

31 North-northwest NNW 331.88 337.50 343.12

32 North by west NbW 343.13 348.75 354.37

</pre>

 

=={{header|Tcl}}==

set dirs {

N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE

# Pretty-print the results of converting an angle to a compass heading

puts [format "%2i %-18s %7.2f°" $index [angle2compass $heading] $heading]

Output:

<pre>

1 North 354.38°

</pre>

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

{{trans|QBasic}}

 

FUNCTION compasspoint$ (h)

PRINT ind, compasspoint$(heading), heading

NEXT i

=={{header|uBasic/4tH}}==

{{trans|C}}

Since uBasic is an integer interpreter, we have to do some scaling to perform this task.

Push 13500, 15187, 15188, 16875, 18562, 18563, 20250, 21937, 21938, 23625

Push 25312, 25313, 27000, 28687, 28688, 30375, 32062, 32063, 33750, 35437

400 Print "North-northwest "; : Return

410 Print "North by west "; : Return

{{out}}

<pre>

0 OK, 0:900

</pre>

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

Requires the standard POSIX bc(1) command to perform floating-point arithmetic.

 

compass_points=( N NbE N-NE NEbN NE NEbE E-NE EbN

E EbS E-SE SEbE SE SEbS S-SE SbE

label="$(expand_point $abbr)"

printf "$row_format" $angle "$label" $index

 

Output: <pre>Degrees | Closest Point | Index

354.38 | North | 1

</pre>

=={{header|VBA}}==

Dim compass_point As Integer

Dim compass_points_all As New Collection

Debug.Print test_points_all(i)

Next i

<pre> 1 North 0

2 North by east 16,87

32 North by west 354,37

1 North 354,38 </pre>

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

 

Dim _points(32) As String

 

End Function

End Module

Output:

<pre>

1: North 354.38°

</pre>

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

// 'cpx' returns integer index from 0 to 31 corresponding to compass point.

var index = i%32 + 1 // printable index computed per pseudocode

var d = degreesToCompassPoint.call(h)

i = i + 1

 

{{out}}

32 North by west 354.37°

1 North 354.38°

</pre>

 

=={{header|Yabasic}}==

{{trans|Liberty BASIC}}

dim point$(32)

70 data "West by south ", "West ", "West by north ", "West-northwest "

80 data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "

 

=={{header|zkl}}==

{{trans|AWK}}

"SEbE SE SEbS SSE SbE S SbW SSW SWbS SW SWbW "

"WSW WbS W WbN WNW NWbW NW NWbN NNW NbW").split(" ");

box:=compassBox(heading);

println("%6.2f\UB0; : %2d\t%s".fmt(heading,box,A[box]));

{{out}}

<pre>

354.38 : 1 N

</pre>

=={{header|ZX Spectrum Basic}}==

{{trans|Liberty BASIC}}

20 DATA "Northeast by north","Northeast","Northeast by east","East-northeast"

30 DATA "East by north","East","East by south","East-southeast"

250 STOP

260 DEF FN m(i,n)=((i/n)-INT (i/n))*n : REM modulus function