Box the compass

You are encouraged to You are encouraged to solve this task according to the task description, using any language you may know.

Avast me hearties!

There be many a land lubber that knows naught of the pirate ways and gives direction by degree! They know not how to box the compass!





Task description

Create a function that takes a heading in degrees and returns the correct 32-point compass heading. Use the function to print and display a table of Index, Compass point, and Degree; rather like the corresponding columns from, the first table of the wikipedia article, but use only the following 33 headings as input:

[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] . (They should give the same order of points but are spread throughout the ranges of acceptance).





Notes;

The headings and indices can be calculated from this pseudocode:

for i in 0..32 inclusive: heading = i * 11.25 case i %3: if 1: heading += 5.62; break if 2: heading -= 5.62; break end index = ( i mod 32) + 1

The column of indices can be thought of as an enumeration of the thirty two cardinal points (see talk page)..







Translation of: Python

V majors = ‘north east south west’.split(‘ ’)

majors *= 2

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

V quarter2 = quarter1.map(p -> p.replace(‘NE’, ‘EN’))



F degrees2compasspoint(=d)

d = (d % 360) + 360 / 64

V majorindex = Int(d / 90)

V minorindex = Int((d % 90 * 4) I/ 45)

V p1 = :majors[majorindex]

V p2 = :majors[majorindex + 1]

[String] q

I p1 C (‘north’, ‘south’)

q = :quarter1

E

q = :quarter2

R q[minorindex].replace(‘N’, p1).replace(‘E’, p2).capitalize()



:start:

L(i) 33

V d = i * 11.25

S i % 3

1

d += 5.62

2

d -= 5.62

V n = i % 32 + 1

print(‘#2.0 #<18 #4.2°’.format(n, degrees2compasspoint(d), d))

Output:

1 North 0.00° 2 North by east 16.87° 3 North-northeast 16.88° ... 31 North-northwest 337.50° 32 North by west 354.37° 1 North 354.38°

Inspired by the C++ program, but without the need for a specific library.

with Ada. Text_IO ;



procedure Box_The_Compass is



type Degrees is digits 5 range 0.00 .. 359.99 ;

type Index_Type is mod 32 ;



function Long_Name ( Short: String ) return String is



function Char_To_Name ( Char: Character ) return String is

begin

case Char is

when 'N' | 'n' => return Char & "orth" ;

when 'S' | 's' => return Char & "outh" ;

when 'E' | 'e' => return Char & "ast" ;

when 'W' | 'w' => return Char & "est" ;

when 'b' => return " by " ;

when '-' => return "-" ;

when others => raise Constraint_Error;

end case ;

end Char_To_Name;



begin

if Short'Length = 0 or else Short ( Short'First ) =' ' then

return "" ;

else

return Char_To_Name ( Short ( Short'First ) )

& Long_Name ( Short ( Short'First+ 1 .. Short 'Last ) ) ;

end if ;

end Long_Name;



procedure Put_Line ( Angle: Degrees ) is



function Index ( D: Degrees ) return Index_Type is

begin

return Index_Type ( Integer ( Degrees'Rounding ( D/ 11.25 ) ) mod 32 ) ;

end Index;



I: Integer := Integer ( Index ( Angle ) ) + 1 ;

package DIO is new Ada. Text_IO . Float_IO ( Degrees ) ;

Abbr: constant array ( Index_Type ) of String ( 1 .. 4 )

:= ( "N " , "Nbe " , "N-ne" , "Nebn" , "Ne " , "Nebe" , "E-ne" , "Ebn " ,

"E " , "Ebs " , "E-se" , "Sebe" , "Se " , "Sebs" , "S-se" , "Sbe " ,

"S " , "Sbw " , "S-sw" , "Swbs" , "Sw " , "Swbw" , "W-sw" , "Wbs " ,

"W " , "Wbn " , "W-nw" , "Nwbw" , "Nw " , "Nwbn" , "N-nw" , "Nbw " ) ;



begin

DIO. Put ( Angle, Fore => 3 , Aft => 2 , Exp => 0 ) ; -- format "zzx.xx"

Ada. Text_IO . Put ( " |" ) ;

if I <= 9 then

Ada. Text_IO . Put ( " " ) ;

end if ;

Ada. Text_IO . Put_Line ( " " & Integer'Image ( I ) & " | "

& Long_Name ( Abbr ( Index ( Angle ) ) ) ) ;

end Put_Line;



Difference: constant array ( 0 .. 2 ) of Degrees'Base

:= ( 0 => 0.0 , 1 => + 5.62 , 2 => - 5.62 ) ;



begin

Ada. Text_IO . Put_Line ( " angle | box | compass point" ) ;

Ada. Text_IO . Put_Line ( " ---------------------------------" ) ;

for I in 0 .. 32 loop

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

end loop ;

end Box_The_Compass;

Output:

angle | box | compass point --------------------------------- 0.00 | 1 | North 16.87 | 2 | North by east 16.88 | 3 | North-northeast 33.75 | 4 | Northeast by north 50.62 | 5 | Northeast 50.63 | 6 | Northeast by east 67.50 | 7 | East-northeast 84.37 | 8 | East by north 84.38 | 9 | East 101.25 | 10 | East by south 118.12 | 11 | East-southeast 118.13 | 12 | Southeast by east 135.00 | 13 | Southeast 151.87 | 14 | Southeast by south 151.88 | 15 | South-southeast 168.75 | 16 | South by east 185.62 | 17 | South 185.63 | 18 | South by west 202.50 | 19 | South-southwest 219.37 | 20 | Southwest by south 219.38 | 21 | Southwest 236.25 | 22 | Southwest by west 253.12 | 23 | West-southwest 253.13 | 24 | West by south 270.00 | 25 | West 286.87 | 26 | West by north 286.88 | 27 | West-northwest 303.75 | 28 | Northwest by west 320.62 | 29 | Northwest 320.63 | 30 | Northwest by north 337.50 | 31 | North-northwest 354.37 | 32 | North by west 354.38 | 1 | North

Works with: ALGOL 68 version Revision 1 - no extensions to language used.

#!/usr/local/bin/a68g --script #



[ ] STRING

long by nesw = ( " by " , "North" , "East" , "South" , "West" ) ,

short by nesw = ( "b" , "N" , "E" , "S" , "W" ) ;



MODE MINUTES = REAL ; # minutes type #

INT last minute = 360 * 60 ;

INT point width = last minute OVER 32 ;



PROC direction name = ( REAL direction in minutes , [ ] STRING locale directions ) STRING : (



STRING by = locale directions [ 1 ] ;

[ ] STRING nesw = locale directions [ @- 1 ] ;



PRIO MASK = 7 ; # same PRIOrity as * and / #

OP MASK = ( INT n , BITS lower ) INT : ABS ( BIN n AND NOT lower ) ,

DECAP = ( STRING s ) STRING : IF UPB s > 1 THEN REPR ( ABS s [ 1 ] - ABS "A" + ABS "a" ) + s [ 2 : ] ELSE s FI ;



PROC point name = ( INT in point ) STRING : (



INT point = in point MOD 32 # 32 points of a compass # ;

IF point MOD 8 = 0 THEN

# name the principle point: eg. N, E, S or W #

nesw [ point OVER 8 ]



ELIF point MOD 4 = 0 THEN

# name the half: eg. NE, SE, SW or NW #

point name ( ( point + 8 ) MASK 2r1111 ) + DECAP point name ( point MASK 2r1111 + 8 )



ELIF point MOD 2 = 0 THEN

# name the quarter: eg. N-NE, E-NE, E-SE, S-SE, S-SW, W-SW, W-NW or N-NW #

point name ( ( point + 4 ) MASK 2r111 ) + "-" + point name ( point MASK 2r111 + 4 )



ELSE # Name the sixteenth point: #

# eg. NbE,NEbN,NEbE,EbN,EbS,SEbE,SEbS,SbE,SbW,SWbS,SWbW,WbS,WbN,NWbW,NWbN,NbW #

INT opp point = point OVER 8 + ABS NOT ODD ( point OVER 2 ) ;

point name ( ( point + 2 ) MASK 2r11 ) + by + nesw ( opp point MOD 4 )

FI

) ;

point name ( ROUND ( direction in minutes / point width ) )

) ;



PROC traditional name = ( MINUTES minutes ) STRING : (

INT degrees = ROUND ( minutes / 60 ) ;

degrees = 0 | "Tramontana" |:

degrees = 45 | "Greco or Bora" |:

degrees = 90 | "Levante" |:

degrees = 135 | "Sirocco" |:

degrees = 180 | "Ostro" |:

degrees = 225 | "Libeccio" |:

degrees = 270 | "Poniente or Zephyrus" |:

degrees = 315 | "Mistral" |:

degrees = 360 | "Tramontana" | ""

) ;



# First generate the test set results #

test : (

printf ( $ "Test:" l$ ) ;

FOR i FROM 0 TO 32 DO

REAL heading = i * 11.25 +

CASE i MOD 3 IN

+5.62 ,

-5.62

OUT 0

ESAC ;

INT index = ( i MOD 32 ) + 1 ;

printf ( ( $zd " " , g23k , zzd.zzl$ , index , direction name ( heading * 60 , long by nesw ) , heading ) )

OD

) ;



table : (

OP OVER = ( REAL r , INT base ) INT : ENTIER ABS r OVER base ,

MOD = ( REAL r , INT base ) REAL : ( INT i = ENTIER r ; i MOD base + r - i ) ;



printf (

$l "Table:" l

" #|Compass point" 22k "|Abbr|Traditional wind point| Lowest°′ | Middle°′ | Highest°′" l$

) ;



OP DEGMIN = ( REAL minutes ) STRUCT ( INT d , REAL m ) : ( minutes MOD last minute OVER 60 , minutes MOD 60 ) ;



FOR point FROM 1 TO 32 DO

REAL centre = ( point - 1 ) * point width ;

REAL from = centre - point width / 2 ,

to = centre + point width / 2 - 1 / 120 ;

printf ( (

$g ( - 2 ) "|" $ , point ,

$g$ , direction name ( centre , long by nesw ) ,

$22k "|" g$ , direction name ( centre , short by nesw ) ,

$27k "|" g$ , traditional name ( centre ) ,

$50k$ , $ "|" g ( - 3 ) "°" , dd.dd "′" $ , DEGMIN from , DEGMIN centre , DEGMIN to ,

$l$

) )

OD

)

Output:

Test: 1 North 0.00 2 North by East 16.87 3 North-Northeast 16.88 4 Northeast by North 33.75 5 Northeast 50.62 6 Northeast by East 50.63 7 East-Northeast 67.50 8 East by North 84.37 9 East 84.38 10 East by South 101.25 11 East-Southeast 118.12 12 Southeast by East 118.13 13 Southeast 135.00 14 Southeast by South 151.87 15 South-Southeast 151.88 16 South by East 168.75 17 South 185.62 18 South by West 185.63 19 South-Southwest 202.50 20 Southwest by South 219.37 21 Southwest 219.38 22 Southwest by West 236.25 23 West-Southwest 253.12 24 West by South 253.13 25 West 270.00 26 West by North 286.87 27 West-Northwest 286.88 28 Northwest by West 303.75 29 Northwest 320.62 30 Northwest by North 320.63 31 North-Northwest 337.50 32 North by West 354.37 1 North 354.38 Table: #|Compass point |Abbr|Traditional wind point| Lowest°′ | Middle°′ | Highest°′ 1|North |N |Tramontana |354°22.50′| 0°00.00′| 5°37.49′ 2|North by East |NbE | | 5°37.50′| 11°15.00′| 16°52.49′ 3|North-Northeast |N-NE| | 16°52.50′| 22°30.00′| 28°07.49′ 4|Northeast by North|NEbN| | 28°07.50′| 33°45.00′| 39°22.49′ 5|Northeast |NE |Greco or Bora | 39°22.50′| 45°00.00′| 50°37.49′ 6|Northeast by East |NEbE| | 50°37.50′| 56°15.00′| 61°52.49′ 7|East-Northeast |E-NE| | 61°52.50′| 67°30.00′| 73°07.49′ 8|East by North |EbN | | 73°07.50′| 78°45.00′| 84°22.49′ 9|East |E |Levante | 84°22.50′| 90°00.00′| 95°37.49′ 10|East by South |EbS | | 95°37.50′|101°15.00′|106°52.49′ 11|East-Southeast |E-SE| |106°52.50′|112°30.00′|118°07.49′ 12|Southeast by East |SEbE| |118°07.50′|123°45.00′|129°22.49′ 13|Southeast |SE |Sirocco |129°22.50′|135°00.00′|140°37.49′ 14|Southeast by South|SEbS| |140°37.50′|146°15.00′|151°52.49′ 15|South-Southeast |S-SE| |151°52.50′|157°30.00′|163°07.49′ 16|South by East |SbE | |163°07.50′|168°45.00′|174°22.49′ 17|South |S |Ostro |174°22.50′|180°00.00′|185°37.49′ 18|South by West |SbW | |185°37.50′|191°15.00′|196°52.49′ 19|South-Southwest |S-SW| |196°52.50′|202°30.00′|208°07.49′ 20|Southwest by South|SWbS| |208°07.50′|213°45.00′|219°22.49′ 21|Southwest |SW |Libeccio |219°22.50′|225°00.00′|230°37.49′ 22|Southwest by West |SWbW| |230°37.50′|236°15.00′|241°52.49′ 23|West-Southwest |W-SW| |241°52.50′|247°30.00′|253°07.49′ 24|West by South |WbS | |253°07.50′|258°45.00′|264°22.49′ 25|West |W |Poniente or Zephyrus |264°22.50′|270°00.00′|275°37.49′ 26|West by North |WbN | |275°37.50′|281°15.00′|286°52.49′ 27|West-Northwest |W-NW| |286°52.50′|292°30.00′|298°07.49′ 28|Northwest by West |NWbW| |298°07.50′|303°45.00′|309°22.49′ 29|Northwest |NW |Mistral |309°22.50′|315°00.00′|320°37.49′ 30|Northwest by North|NWbN| |320°37.50′|326°15.00′|331°52.49′ 31|North-Northwest |N-NW| |331°52.50′|337°30.00′|343°07.49′ 32|North by West |NbW | |343°07.50′|348°45.00′|354°22.49′

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

Translation of: JavaScript

(ES6 version)

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

use framework "Foundation"

use scripting additions



-- BOXING THE COMPASS --------------------------------------------------------



property plstLangs : [ { | name |: "English" } & ¬

{ expansions: { N: "north" , S: "south" , E: "east" , W: "west" , b: " by " } } & ¬

{ |N|: "N" , |NNNE|: "NbE" , |NNE|: "N-NE" , |NNENE|: "NEbN" , |NE|: "NE" , |NENEE|: "NEbE" } & ¬

{ |NEE|: "E-NE" , |NEEE|: "EbN" , |E|: "E" , |EEES|: "EbS" , |EES|: "E-SE" , |EESES|: "SEbE" } & ¬

{ |ES|: "SE" , |ESESS|: "SEbS" , |ESS|: "S-SE" , |ESSS|: "SbE" , |S|: "S" , |SSSW|: "SbW" } & ¬

{ |SSW|: "S-SW" , |SSWSW|: "SWbS" , |SW|: "SW" , |SWSWW|: "SWbW" , |SWW|: "W-SW" } & ¬

{ |SWWW|: "WbS" , |W|: "W" , |WWWN|: "WbN" , |WWN|: "W-NW" , |WWNWN|: "NWbW" } & ¬

{ |WN|: "NW" , |WNWNN|: "NWbN" , |WNN|: "N-NW" , |WNNN|: "NbW" } , ¬

¬

{ | name |: "Chinese" , |N|: "北" , |NNNE|: "北微东" , |NNE|: "东北偏北" } & ¬

{ |NNENE|: "东北微北" , |NE|: "东北" , |NENEE|: "东北微东" , |NEE|: "东北偏东" } & ¬

{ |NEEE|: "东微北" , |E|: "东" , |EEES|: "东微南" , |EES|: "东南偏东" , |EESES|: "东南微东" } & ¬

{ |ES|: "东南" , |ESESS|: "东南微南" , |ESS|: "东南偏南" , |ESSS|: "南微东" , |S|: "南" } & ¬

{ |SSSW|: "南微西" , |SSW|: "西南偏南" , |SSWSW|: "西南微南" , |SW|: "西南" } & ¬

{ |SWSWW|: "西南微西" , |SWW|: "西南偏西" , |SWWW|: "西微南" , |W|: "西" } & ¬

{ |WWWN|: "西微北" , |WWN|: "西北偏西" , |WWNWN|: "西北微西" , |WN|: "西北" } & ¬

{ |WNWNN|: "西北微北" , |WNN|: "西北偏北" , |WNNN|: "北微西" } ]



-- Scale invariant keys for points of the compass

-- (allows us to look up a translation for one scale of compass (32 here)

-- for use in another size of compass (8 or 16 points)

-- (Also semi-serviceable as more or less legible keys without translation)



-- compassKeys :: Int -> [String]

on compassKeys ( intDepth )

-- Simplest compass divides into two hemispheres

-- with one peak of ambiguity to the left,

-- and one to the right (encoded by the commas in this list):

set urCompass to [ "N" , "S" , "N" ]



-- Necessity drives recursive subdivision of broader directions, shrinking

-- boxes down to a workable level of precision:

script subdivision

on |λ| ( lstCompass, N )

if N ≤ 1 then

lstCompass

else

script subKeys

on |λ| ( a, x, i, xs )

-- Borders between N and S engender E and W.

-- further subdivisions (boxes)

-- concatenate their two parent keys.

if i > 1 then

cond ( N = intDepth, ¬

a & { cond ( x = "N" , "W" , "E" ) } & x, ¬

a & { item ( i - 1 ) of xs & x } & x )

else

a & x

end if

end |λ|

end script



|λ| ( foldl ( subKeys, { } , lstCompass ) , N - 1 )

end if

end |λ|

end script



tell subdivision to items 1 thru - 2 of |λ| ( urCompass, intDepth )

end compassKeys



-- pointIndex :: Int -> Num -> String

on pointIndex ( power, degrees )

set nBoxes to 2 ^ power

set i to round ( degrees + ( 360 / ( nBoxes * 2 ) ) ) ¬

mod 360 * nBoxes / 360 rounding up

cond ( i > 0 , i, 1 )

end pointIndex



-- pointNames :: Int -> Int -> [String]

on pointNames ( precision, iBox )

set k to item iBox of compassKeys ( precision )



script translation

on |λ| ( recLang )

set maybeTrans to keyValue ( recLang, k )

set strBrief to cond ( maybeTrans is missing value , k, maybeTrans )



set recExpand to keyValue ( recLang, "expansions" )



if recExpand is not missing value then

script expand

on |λ| ( c )

set t to keyValue ( recExpand, c )

cond ( t is not missing value , t, c )

end |λ|

end script

set strName to ( intercalate ( cond ( precision > 5 , " " , "" ) , ¬

map ( expand, characters of strBrief ) ) )

toUpper ( text item 1 of strName ) & text items 2 thru - 1 of strName

else

strBrief

end if

end |λ|

end script



map ( translation, plstLangs )

end pointNames



-- maxLen :: [String] -> Int

on maxLen ( xs )

length of maximumBy ( comparing ( my |length| ) , xs )

end maxLen



-- alignRight :: Int -> String -> String

on alignRight ( nWidth, x )

justifyRight ( nWidth, space , x )

end alignRight



-- alignLeft :: Int -> String -> String

on alignLeft ( nWidth, x )

justifyLeft ( nWidth, space , x )

end alignLeft



-- show :: asString => a -> Text

on show ( x )

x as string

end show



-- compassTable :: Int -> [Num] -> Maybe String

on compassTable ( precision, xs )

if precision < 1 then

missing value

else

set intPad to 2

set rightAligned to curry ( alignRight )

set leftAligned to curry ( alignLeft )

set join to curry ( my intercalate )



-- INDEX COLUMN

set lstIndex to map ( |λ| ( precision ) of curry ( pointIndex ) , xs )

set lstStrIndex to map ( show, lstIndex )

set nIndexWidth to maxLen ( lstStrIndex )

set colIndex to map ( |λ| ( nIndexWidth + intPad ) of rightAligned, lstStrIndex )



-- ANGLES COLUMN

script degreeFormat

on |λ| ( x )

set { c, m } to splitOn ( "." , x as string )

c & "." & ( text 1 thru 2 of ( m & "0" ) ) & "°"

end |λ|

end script

set lstAngles to map ( degreeFormat, xs )

set nAngleWidth to maxLen ( lstAngles ) + intPad

set colAngles to map ( |λ| ( nAngleWidth ) of rightAligned, lstAngles )



-- NAMES COLUMNS

script precisionNames

on |λ| ( iBox )

pointNames ( precision, iBox )

end |λ|

end script



set lstTrans to transpose ( map ( precisionNames, lstIndex ) )

set lstTransWidths to map ( maxLen, lstTrans )



script spacedNames

on |λ| ( lstLang, i )

map ( |λ| ( ( item i of lstTransWidths ) + 2 ) of leftAligned, lstLang )

end |λ|

end script



set colsTrans to map ( spacedNames, lstTrans )



-- TABLE

intercalate ( linefeed, ¬

map ( |λ| ( "" ) of join, ¬

transpose ( { colIndex } & { colAngles } & ¬

{ replicate ( length of lstIndex, " " ) } & colsTrans ) ) )

end if

end compassTable







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

on run

set xs to [ 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 ]



-- If we supply other precisions, like 4 or 6, (2^n -> 16 or 64 boxes)

-- the bearings will be divided amongst smaller or larger numbers of boxes,

-- either using name translations retrieved by the generic hash

-- or using the keys of the hash itself (combined with any expansions)

-- to substitute for missing names for very finely divided boxes.



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

end run





-- GENERIC FUNCTIONS ---------------------------------------------------------



-- comparing :: (a -> b) -> (a -> a -> Ordering)

on comparing ( f )

set mf to mReturn ( f )

script

on |λ| ( a, b )

set x to mf ' s |λ| ( a )

set y to mf ' s |λ| ( b )

if x < y then

- 1

else

if x > y then

1

else

0

end if

end if

end |λ|

end script

end comparing



-- cond :: Bool -> a -> a -> a

on cond ( bool, f, g )

if bool then

f

else

g

end if

end cond



-- curry :: (Script|Handler) -> Script

on curry ( f )

script

on |λ| ( a )

script

on |λ| ( b )

|λ| ( a, b ) of mReturn ( f )

end |λ|

end script

end |λ|

end script

end curry



-- foldl :: (a -> b -> a) -> a -> [b] -> a

on foldl ( f, startValue, xs )

tell mReturn ( f )

set v to startValue

set lng to length of xs

repeat with i from 1 to lng

set v to |λ| ( v, item i of xs, i, xs )

end repeat

return v

end tell

end foldl



-- intercalate :: Text -> [Text] -> Text

on intercalate ( strText, lstText )

set { dlm, my text item delimiters } to { my text item delimiters , strText }

set strJoined to lstText as text

set my text item delimiters to dlm

return strJoined

end intercalate



-- justifyLeft :: Int -> Char -> Text -> Text

on justifyLeft ( N, cFiller, strText )

if N > length of strText then

text 1 thru N of ( strText & replicate ( N, cFiller ) )

else

strText

end if

end justifyLeft



-- justifyRight :: Int -> Char -> Text -> Text

on justifyRight ( N, cFiller, strText )

if N > length of strText then

text - N thru - 1 of ( ( replicate ( N, cFiller ) as text ) & strText )

else

strText

end if

end justifyRight



-- keyValue :: Record -> String -> Maybe String

on keyValue ( rec, strKey )

set ca to current application

set v to ( ca ' s NSDictionary ' s dictionaryWithDictionary:rec ) 's objectForKey:strKey

if v is not missing value then

item 1 of ( ( ca ' s NSArray ' s arrayWithObject:v ) as list )

else

missing value

end if

end keyValue



-- length :: [a] -> Int

on |length| ( xs )

length of xs

end |length|



-- map :: (a -> b) -> [a] -> [b]

on map ( f, xs )

tell mReturn ( f )

set lng to length of xs

set lst to { }

repeat with i from 1 to lng

set end of lst to |λ| ( item i of xs, i, xs )

end repeat

return lst

end tell

end map



-- maximumBy :: (a -> a -> Ordering) -> [a] -> a

on maximumBy ( f, xs )

set cmp to mReturn ( f )

script max

on |λ| ( a, b )

if a is missing value or cmp ' s |λ| ( a, b ) < 0 then

b

else

a

end if

end |λ|

end script



foldl ( max, missing value , xs )

end maximumBy



-- Lift 2nd class handler function into 1st class script wrapper

-- mReturn :: Handler -> Script

on mReturn ( f )

if class of f is script then

f

else

script

property |λ| : f

end script

end if

end mReturn



-- replicate :: Int -> a -> [a]

on replicate ( N, a )

set out to { }

if N < 1 then return out

set dbl to { a }



repeat while ( N > 1 )

if ( N mod 2 ) > 0 then set out to out & dbl

set N to ( N div 2 )

set dbl to ( dbl & dbl )

end repeat

return out & dbl

end replicate



-- splitOn :: Text -> Text -> [Text]

on splitOn ( strDelim, strMain )

set { dlm, my text item delimiters } to { my text item delimiters , strDelim }

set xs to text items of strMain

set my text item delimiters to dlm

return xs

end splitOn



-- transpose :: [[a]] -> [[a]]

on transpose ( xss )

script column

on |λ| ( _, iCol )

script row

on |λ| ( xs )

item iCol of xs

end |λ|

end script



map ( row, xss )

end |λ|

end script



map ( column, item 1 of xss )

end transpose



-- toLower :: String -> String

on toLower ( str )

set ca to current application

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

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

end toLower



-- toTitle :: String -> String

on toTitle ( str )

set ca to current application

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

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

end toTitle



-- toUpper :: String -> String

on toUpper ( str )

set ca to current application

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

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

end toUpper

Output:

1 0.00° North 北 2 16.87° North by east 北微东 3 16.88° North-northeast 东北偏北 4 33.75° Northeast by north 东北微北 5 50.62° Northeast 东北 6 50.63° Northeast by east 东北微东 7 67.50° East-northeast 东北偏东 8 84.37° East by north 东微北 9 84.38° East 东 10 101.25° East by south 东微南 11 118.12° East-southeast 东南偏东 12 118.13° Southeast by east 东南微东 13 135.00° Southeast 东南 14 151.87° Southeast by south 东南微南 15 151.88° South-southeast 东南偏南 16 168.75° South by east 南微东 17 185.62° South 南 18 185.63° South by west 南微西 19 202.50° South-southwest 西南偏南 20 219.37° Southwest by south 西南微南 21 219.38° Southwest 西南 22 236.25° Southwest by west 西南微西 23 253.12° West-southwest 西南偏西 24 253.13° West by south 西微南 25 270.00° West 西 26 286.87° West by north 西微北 27 286.88° West-northwest 西北偏西 28 303.75° Northwest by west 西北微西 29 320.62° Northwest 西北 30 320.63° Northwest by north 西北微北 31 337.50° North-northwest 西北偏北 32 354.37° North by west 北微西 1 354.38° North 北

Translation of: C++

Works with: AutoHotkey_L

get_Index ( angle ) {

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

}



get_Abbr_From_Index ( i ) {

static points

:= [ "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" ]

return points [ i ]

}



Build_Name_From_Abbr ( a ) {

Loop Parse , a

{

i := A_Index

if ( ( i = 2 ) && ( SubStr ( a , i , 1 ) ! = "b" ) && ( StrLen ( a ) == 3 ) )

retval .= "-"

retval .= { N: "north" , S: "south" , E: "east"

, W: "west" , b: " by " } [ A_LoopField ]

}

return Chr ( Asc ( SubStr ( retval , 1 , 1 ) ) - 32 ) . SubStr ( retval , 2 )

}



; test



headings := [ 0.00 , 16.87 , 16.88 , 33.75 , 50.62 , 50.63 , 67.50 , 84.37 , 84.38 , 101.25

, 118.12 , 118.13 , 135.00 , 151.87 , 151.88 , 168.75 , 185.62 , 185.63

, 202.50 , 219.37 , 219.38 , 236.25 , 253.12 , 253.13 , 270.00 , 286.87

, 286.88 , 303.75 , 320.62 , 320.63 , 337.50 , 354.37 , 354.38 ]

For n , a in headings

{

i := get_Index ( a )

out .= SubStr ( " " i , - 1 ) " "

. SubStr ( Build_Name_From_Abbr ( get_Abbr_From_Index ( i ) )

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

}

clipboard := out

Output

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38



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

303.75 , 320.62 , 320.63 , 337.5 , 354.37 , 354.38 ]



For $i = 0 To UBound ( $avArray ) - 1

Boxing_the_compass ( $avArray [ $i ] )

Next



Func Boxing_the_compass ( $Degree )

Local $namearray [ 33 ] = [ "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" ]

ConsoleWrite ( StringFormat ( "%-2s" , Mod ( Floor ( $Degree / 11.25 + 0.5 ) , 32 ) ) & " : " & _

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

EndFunc ;==>Boxing_the_compass



0 : North : 0 1 : North by east : 16.87 2 : North-northeast : 16.88 3 : Northeast by north : 33.75 4 : Northeast : 50.62 5 : Northeast by east : 50.63 6 : East-northeast : 67.5 7 : East by north : 84.37 8 : East : 84.38 9 : East by south : 101.25 10 : East-southeast : 118.12 11 : Southeast by east : 118.13 12 : Southeast : 135 13 : Southeast by south : 151.87 14 : South-southeast : 151.88 15 : South by east : 168.75 16 : South : 185.62 17 : South by west : 185.63 18 : South-southwest : 202.5 19 : Southwest by south : 219.37 20 : Southwest : 219.38 21 : Southwest by west : 236.25 22 : West-southwest : 253.12 23 : West by south : 253.13 24 : West : 270 25 : West by north : 286.87 26 : West-northwest : 286.88 27 : Northwest by west : 303.75 28 : Northwest : 320.62 29 : Northwest by north : 320.63 30 : North-northwest : 337.5 31 : North by west : 354.37 0 : North : 354.38

#!/usr/bin/awk -f

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

}



function ceil ( x ) {

y = int ( x )

return y < x ? y + 1 : y

}



function compassbox ( d ) {

return ceil ( ( ( d + 360 / 64 ) % 360 ) * 32 / 360 ) ;

}



{

box = compassbox ( $1 ) ;

printf "%6.2f : %2d \t %s

" , $1 ,box,A [ box ] ;

}



Output :

Output:

0.00 : 1 N 16.87 : 2 NbE 16.88 : 3 NNE 33.75 : 4 NEbN 50.62 : 5 NE 50.63 : 6 NEbE 67.50 : 7 ENE 84.37 : 8 EbN 84.38 : 9 E 101.25 : 10 EbS 118.12 : 11 ESE 118.13 : 12 SEbE 135.00 : 13 SE 151.87 : 14 SEbS 151.88 : 15 SSE 168.75 : 16 SbE 185.62 : 17 S 185.63 : 18 SbW 202.50 : 19 SSW 219.37 : 20 SWbS 219.38 : 21 SW 236.25 : 22 SWbW 253.12 : 23 WSW 253.13 : 24 WbS 270.00 : 25 W 286.87 : 26 WbN 286.88 : 27 WNW 303.75 : 28 NWbW 320.62 : 29 NW 320.63 : 30 NWbN 337.50 : 31 NNW 354.37 : 32 NbW 354.38 : 1 N

Works with: BBC BASIC for Windows

DIM bearing(32)

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

\ 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



FOR i% = 0 TO 32

box% = FNcompassbox(bearing(i%), compass$)

PRINT ; bearing(i%), ; box%, compass$

NEXT

END



DEF FNcompassbox(bearing, RETURN box$)

LOCAL pt%

pt% = INT(bearing / 360 * 32 + 0.5) MOD 32

box$ = FNpt(pt%)

LEFT$(box$,1) = CHR$(ASC(LEFT$(box$,1))-32)

= pt% + 1



DEF FNpt(pt%)

LOCAL pt$() : DIM pt$(3)

IF pt% AND 1 THEN = FNpt((pt% + 1) AND 28) + " by " + \

\ FNpt(((2 - (pt% AND 2)) * 4) + pt% AND 24)

IF pt% AND 2 THEN = FNpt((pt% + 2) AND 24) + "-" + FNpt((pt% OR 4) AND 28)

IF pt% AND 4 THEN = FNpt((pt% + 8) AND 16) + FNpt((pt% OR 8) AND 24)

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

= pt$(pt% DIV 8)



Output:

0 1 North 16.87 2 North by east 16.88 3 North-northeast 33.75 4 Northeast by north 50.62 5 Northeast 50.63 6 Northeast by east 67.5 7 East-northeast 84.37 8 East by north 84.38 9 East 101.25 10 East by south 118.12 11 East-southeast 118.13 12 Southeast by east 135 13 Southeast 151.87 14 Southeast by south 151.88 15 South-southeast 168.75 16 South by east 185.62 17 South 185.63 18 South by west 202.5 19 South-southwest 219.37 20 Southwest by south 219.38 21 Southwest 236.25 22 Southwest by west 253.12 23 West-southwest 253.13 24 West by south 270 25 West 286.87 26 West by north 286.88 27 West-northwest 303.75 28 Northwest by west 320.62 29 Northwest 320.63 30 Northwest by north 337.5 31 North-northwest 354.37 32 North by west 354.38 1 North

>>::"}"9**\4+3%79*9*5-*79*9*5--+:5>>>06p:55+%68*+v

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

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

|p60-1<|<!p80:<N|Ev"northwest"0"North by west"0p8<

>:#,_>>>_08g1-^W|S>"-htroN"0"htron yb tsewhtroN"0v

#v"est-northwest"0"Northwest by west"0"Northwest"<

N>"W"0"htron yb tseW"0"tseW"0"htuos yb tseW"0"ts"v

#v0"Southwest"0"Southwest by west"0"West-southwe"<

S>"htuos yb tsewhtuoS"0"tsewhtuos-htuoS"0"tsew y"v

#v"h-southeast"0"South by east"0"South"0"South b"<

E>"tuoS"0"htuos yb tsaehtuoS"0"tsaehtuoS"0"tsae "v

#v"East by south"0"East-southeast"0"Southeast by"<

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

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

^>"oN"0"tsaehtron-htroN"0"tsae yb htroN"0"htroN"01

Output:

000.00 1 North 016.87 2 North by east 016.88 3 North-northeast 033.75 4 Northeast by north 050.62 5 Northeast 050.63 6 Northeast by east 067.50 7 East-northeast 084.37 8 East by north 084.38 9 East 101.25 10 East by south 118.12 11 East-southeast 118.13 12 Southeast by east 135.00 13 Southeast 151.87 14 Southeast by south 151.88 15 South-southeast 168.75 16 South by east 185.62 17 South 185.63 18 South by west 202.50 19 South-southwest 219.37 20 Southwest by south 219.38 21 Southwest 236.25 22 Southwest by west 253.12 23 West-southwest 253.13 24 West by south 270.00 25 West 286.87 26 West by north 286.88 27 West-northwest 303.75 28 Northwest by west 320.62 29 Northwest 320.63 30 Northwest by north 337.50 31 North-northwest 354.37 32 North by west 354.38 1 North

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

#include <stdio.h>



int main ( )

{

int i , j ;

double degrees [ ] = { 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 } ;

const char * 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 " ;



for ( i = 0 ; i < 33 ; i ++ ) {

j = .5 + degrees [ i ] * 32 / 360 ;



printf ( "%2d %.22s %6.2f

" , ( j % 32 ) + 1 , names + ( j % 32 ) * 22 ,

degrees [ i ] ) ;

}



return 0 ;

}

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38



using System ;

using System.Collections.Generic ;



namespace BoxTheCompass

{

class Compass

{

string [ ] cp = new string [ ] { "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" } ;



public void compassHeading ( float a )

{

int h = Convert . ToInt32 ( Math . Floor ( a / 11 . 25f + . 5f ) ) % 32 ;

Console . WriteLine ( "{0,2}: {1,-22} : {2,6:N}" ,h + 1 , cp [ h ] , a ) ;

}

} ;

class Program

{

static void Main ( string [ ] args )

{

Compass c = new Compass ( ) ;

float [ ] degs = new float [ ] { 0 . 0f, 16 . 87f, 16 . 88f, 33 . 75f, 50 . 62f, 50 . 63f, 67 . 5f, 84 . 37f, 84 . 38f, 101 . 25f,

118 . 12f, 118 . 13f, 135 . 0f, 151 . 87f, 151 . 88f, 168 . 75f, 185 . 62f, 185 . 63f, 202 . 5f, 219 . 37f, 219 . 38f, 236 . 25f,

253 . 12f, 253 . 13f, 270 . 0f, 286 . 87f, 286 . 88f, 303 . 75f, 320 . 62f, 320 . 63f, 337 . 5f, 354 . 37f, 354 . 38f } ;



foreach ( float d in degs )

c . compassHeading ( d ) ;



Console . WriteLine ( "

Press any key to continue..." ) ;

Console . ReadKey ( ) ;

}

}

}



Output:

1: North : 0.00 2: North by east : 16.87 3: North-northeast : 16.88 4: Northeast by north : 33.75 5: Northeast : 50.62 6: Northeast by east : 50.63 7: East-northeast : 67.50 8: East by north : 84.37 9: East : 84.38 10: East by south : 101.25 11: East-southeast : 118.12 12: Southeast by east : 118.13 13: Southeast : 135.00 14: Southeast by south : 151.87 15: South-southeast : 151.88 16: South by east : 168.75 17: South : 185.62 18: South by west : 185.63 19: South-southwest : 202.50 20: Southwest by south : 219.37 21: Southwest : 219.38 22: Southwest by west : 236.25 23: West-southwest : 253.12 24: West by south : 253.13 25: West : 270.00 26: West by north : 286.87 27: West-northwest : 286.88 28: Northwest by west : 303.75 29: Northwest : 320.62 30: Northwest by north : 320.63 31: North-northwest : 337.50 32: North by west : 354.37 1: North : 354.38

Output:

Using the Boost libraries

#include <string>

#include <boost/array.hpp>

#include <boost/assign/list_of.hpp>

#include <boost/format.hpp>

#include <boost/foreach.hpp>

#include <iostream>

#include <math.h>

using std :: string ;

using namespace boost :: assign ;



int get_Index ( float angle )

{

return static_cast < int > ( floor ( angle / 11.25 + 0.5 ) ) % 32 + 1 ;

}



string get_Abbr_From_Index ( int i )

{

static boost :: array < std :: string , 32 > points ( list_of

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

return points [ i - 1 ] ;

}



string Build_Name_From_Abbreviation ( string a )

{

string retval ;

for ( int i = 0 ; i < a. size ( ) ; ++ i ) {

if ( ( 1 == i ) && ( a [ i ] ! = 'b' ) && ( a. size ( ) == 3 ) ) retval + = "-" ;

switch ( a [ i ] ) {

case 'N' : retval + = "north" ; break ;

case 'S' : retval + = "south" ; break ;

case 'E' : retval + = "east" ; break ;

case 'W' : retval + = "west" ; break ;

case 'b' : retval + = " by " ; break ;

}

}

retval [ 0 ] = toupper ( retval [ 0 ] ) ;

return retval ;

}



int main ( )

{

boost :: array < float , 33 > headings ( list_of

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

int i ;

boost :: format f ( "%1$4d %2$-20s %3$_7.2f" ) ;



BOOST_FOREACH ( float a, headings )

{

i = get_Index ( a ) ;

std :: cout << f % i % Build_Name_From_Abbreviation ( get_Abbr_From_Index ( i ) ) % a << std :: endl ;

}

return 0 ;

}

Output:

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38

Translation of: Tcl

( ns boxing-the-compass

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



( def headings

( for [ i ( range 0 ( inc 32 ) ) ]

( let [ heading ( * i 11.25 ) ]

( case ( mod i 3 )

1 ( + heading 5.62 )

2 ( - heading 5.62 )

heading ) ) ) )



( defn angle2compass

[ angle ]

( let [ dirs [ "N" "NbE" "N-NE" "NEbN" "NE" "NEbE" "E-NE" "EbN"

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

"S" "SbW" "S-SW" "SWbS" "SW" "SWbW" "W-SW" "WbS"

"W" "WbN" "W-NW" "NWbW" "NW" "NWbN" "N-NW" "NbW" ]

unpack { \N "north" \E "east" \W "west" \S "south" \b " by " \- "-" }

sep ( / 360 ( count dirs ) )

dir ( int ( / ( mod ( + angle ( / sep 2 ) ) 360 ) sep ) ) ]

( capitalize ( apply str ( map unpack ( dirs dir ) ) ) ) ) )



( print

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

"

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

headings ) ) )

Output:

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38

Works with GnuCOBOL

identification division .

program-id . box-compass .

data division .

working-storage section .

01 point pic 99 .

01 degrees usage float-short .

01 degrees- rounded pic 999v99 .

01 show-degrees pic zz9 . 99 .

01 box pic z9 .

01 fudge pic 9 .

01 compass pic x ( 4 ) .

01 compass-point pic x ( 18 ) .

01 shortform pic x .

01 short-names .

05 short-name pic x ( 4 ) occurs 33 times .

01 overlay .

05 value "N " & "NbE " & "N-NE" & "NEbN" & "NE " &

"NEbE" & "E-NE" & "EbN " & "E " & "EbS " &

"E-SE" & "SEbE" & "SE " & "SEbS" & "S-SE" &

"SbE " & "S " & "SbW " & "S-SW" & "SWbS" &

"SW " & "SWbW" & "W-SW" & "WbS " & "W " &

"WbN " & "W-NW" & "NWbW" & "NW " & "NWbN" &

"N-NW" & "NbW " & "N " .



procedure division .

display "Index Compass point Degree"



move overlay to short-names .

perform varying point from 0 by 1 until point > 32

compute box = function mod ( point 32 ) + 1

compute degrees = point * 11.25

compute fudge = function mod ( point 3 )

evaluate fudge

when equal 1

add 5.62 to degrees

when equal 2

subtract 5.62 from degrees

end- evaluate



compute degrees- rounded rounded = degrees

move degrees- rounded to show-degrees

inspect show-degrees replacing trailing '00' by '0 '

inspect show-degrees replacing trailing '50' by '5 '



move short-name ( point + 1 ) to compass

move spaces to compass-point

display space box space space space with no advancing

perform varying tally from 1 by 1 until tally > 4

move compass ( tally: 1 ) to shortform

move function concatenate ( function trim ( compass-point ) ,

function substitute ( shortform ,

"N" , "North" ,

"E" , "East" ,

"S" , "South" ,

"W" , "West" ,

"b" , " byZ" ,

"-" , "-" ) )

to compass-point

end- perform

move function substitute ( compass-point , "Z" , " " )

to compass-point

move function lower-case ( compass-point ) to compass-point

move function upper-case ( compass-point ( 1 : 1 ) )

to compass-point ( 1 : 1 )

display compass-point space show-degrees

end- perform

goback .

Output:

Index Compass point Degree 1 North 0.0 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.5 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.0 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.5 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.0 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.5 32 North by west 354.37 1 North 354.38

Translation of: Java

import std. stdio , std. string , std. math , std. array ;



struct boxTheCompass {

immutable static string [ 32 ] points ;



pure nothrow static this ( ) {

immutable cardinal = [ "north" , "east" , "south" , "west" ] ;

immutable desc = [ "1" , "1 by 2" , "1-C" , "C by 1" , "C" ,

"C by 2" , "2-C" , "2 by 1" ] ;



foreach ( immutable i ; 0 .. 4 ) {

immutable s1 = cardinal [ i ] ;

immutable s2 = cardinal [ ( i + 1 ) % 4 ] ;

immutable sc = ( s1 == "north" || s1 == "south" ) ?

( s1 ~ s2 ) : ( s2 ~ s1 ) ;

foreach ( immutable j ; 0 .. 8 )

points [ i * 8 + j ] = desc [ j ] . replace ( "1" , s1 ) .

replace ( "2" , s2 ) . replace ( "C" , sc ) ;

}

}



static string opCall ( in double degrees ) pure /*nothrow*/ {

immutable testD = ( degrees / 11.25 ) + 0.5 ;

return points [ cast ( int ) floor ( testD % 32 ) ] . capitalize ;

}

}



void main ( ) {

foreach ( immutable i ; 0 .. 33 ) {

immutable heading = i * 11.25 + [ 0 , 5.62 , - 5.62 ] [ i % 3 ] ;

writefln ( "%s \t %18s \t %s" , i % 32 + 1 ,

heading. boxTheCompass , heading ) ;

}

}

Output:

1 North 0 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.5 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.5 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.5 32 North by west 354.37 1 North 354.38

Alternative version [ edit ]

void main ( ) {

import std. stdio ;



immutable box = [

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



immutable angles = [

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



foreach ( immutable phi ; angles ) {

immutable i = ( cast ( int ) ( phi * 32.0 / 360.0 + 0.5 ) ) % 32 ;

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

}

}

Output:

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38

Translation of: Ruby

defmodule Box do

defp head do

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

|> Enum.flat_map(fn [a,b] ->

c = if a=="north" or a=="south", do: "#{a}#{b}", else: "#{b}#{a}"

[ a, "#{a} by #{b}", "#{a}-#{c}", "#{c} by #{a}",

c, "#{c} by #{b}", "#{b}-#{c}", "#{b} by #{a}" ]

end)

|> Enum.with_index

|> Enum.map(fn {s, i} -> {i+1, String.capitalize(s)} end)

|> Map.new

end



def compass do

header = head()

angles = Enum.map(0..32, fn i -> i * 11.25 + elem({0, 5.62, -5.62}, rem(i, 3)) end)

Enum.each(angles, fn degrees ->

index = rem(round(32 * degrees / 360), 32) + 1

:io.format "~2w ~-20s ~6.2f~n", [index, header[index], degrees]

end)

end

end



Box.compass

Output:

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38

constant 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" }



function deg2ind ( atom degree )

return remainder ( floor ( degree * 32 / 360 + .5 ) , 32 ) + 1

end function



sequence degrees

degrees = { }

for i = 0 to 32 do

degrees &= i * 11.25 + 5.62 * ( remainder ( i + 1 , 3 ) - 1 )

end for



integer j

for i = 1 to length ( degrees ) do

j = deg2ind ( degrees [ i ] )

printf ( 1 , "%6.2f %2d %-22s

" , { degrees [ i ] , j , names [ j ] } )

end for

Output:

0.00 1 North 16.87 2 North by east 16.88 3 North-northeast 33.75 4 Northeast by north 50.62 5 Northeast 50.63 6 Northeast by east 67.50 7 East-northeast 84.37 8 East by north 84.38 9 East 101.25 10 East by south 118.12 11 East-southeast 118.13 12 Southeast by east 135.00 13 Southeast 151.87 14 Southeast by south 151.88 15 South-southeast 168.75 16 South by east 185.62 17 South 185.63 18 South by west 202.50 19 South-southwest 219.37 20 Southwest by south 219.38 21 Southwest 236.25 22 Southwest by west 253.12 23 West-southwest 253.13 24 West by south 270.00 25 West 286.87 26 West by north 286.88 27 West-northwest 303.75 28 Northwest by west 320.62 29 Northwest 320.63 30 Northwest by north 337.50 31 North-northwest 354.37 32 North by west 354.38 1 North

Translation of: Perl

let box = [ |

"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" | ]



[ 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 ]

|> List . iter ( fun phi ->

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

printf "%3d %18s %6.2f°

" ( i + 1 ) box . [ i ] phi )

Output:

1 North 0.00° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.50° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135.00° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.50° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270.00° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.50° 32 North by west 354.37° 1 North 354.38°

USING: formatting kernel math sequences ;



CONSTANT: box

{

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

}



{

0 16.87 16.88 33.75 50.62 50.63 67.5 84.37 84.38 101.25

118.12 118.13 135 151.87 151.88 168.75 185.62 185.63 202.5

219.37 219.38 236.25 253.12 253.13 270 286.87 286.88 303.75

320.62 320.63 337.5 354.37 354.38

}



[

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

"%6.2f° %2d %s

" printf

] each

Output:

0.00° 1 North 16.87° 2 North by east 16.88° 3 North-northeast 33.75° 4 Northeast by north 50.62° 5 Northeast 50.63° 6 Northeast by east 67.50° 7 East-northeast 84.37° 8 East by north 84.38° 9 East 101.25° 10 East by south 118.12° 11 East-southeast 118.13° 12 Southeast by east 135.00° 13 Southeast 151.87° 14 Southeast by south 151.88° 15 South-southeast 168.75° 16 South by east 185.62° 17 South 185.63° 18 South by west 202.50° 19 South-southwest 219.37° 20 Southwest by south 219.38° 21 Southwest 236.25° 22 Southwest by west 253.12° 23 West-southwest 253.13° 24 West by south 270.00° 25 West 286.87° 26 West by north 286.88° 27 West-northwest 303.75° 28 Northwest by west 320.62° 29 Northwest 320.63° 30 Northwest by north 337.50° 31 North-northwest 354.37° 32 North by west 354.38° 1 North

Works with: Fortran version 90 and later

Program Compass

implicit none



integer :: i , ind

real :: heading



do i = 0 , 32

heading = i * 11.25

if ( mod ( i, 3 ) == 1 ) then

heading = heading + 5.62

else if ( mod ( i, 3 ) == 2 ) then

heading = heading - 5.62

end if

ind = mod ( i, 32 ) + 1

write ( * , "(i2, a20, f8.2)" ) ind, compasspoint ( heading ) , heading

end do



contains



function compasspoint ( h )

character ( 18 ) :: compasspoint

character ( 18 ) :: points ( 32 ) = ( / "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 " / )

real , intent ( in ) :: h

real :: x



x = h / 11.25 + 1.5

if ( x > = 33.0 ) x = x - 32.0

compasspoint = points ( int ( x ) )

end function compasspoint

end program Compass

Output:

1 North 0.00 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.50 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135.00 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.50 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270.00 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.50 32 North by west 354.37 1 North 354.38

' version 04-11-2016

' compile with: fbc -s console



Dim As String names ( 0 To ... ) = { "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" }



Dim As Double degrees ( 0 To ... ) = { 0 , 16.87 , 16.88 , 33.75 , 50.62 , 50.63 , _

67.5 , 84.37 , 84.38 , 101.25 , 118.12 , 118.13 , 135 , 151.87 , 151.88 , 168.75 , _

185.62 , 185.63 , 202.5 , 219.37 , 219.38 , 236.25 , 253.12 , 253.13 , 270 , _

286.87 , 286.88 , 303.75 , 320.62 , 320.63 , 337.5 , 354.37 , 354.38 }



Dim As ULong i, j



For i = LBound ( degrees ) To UBound ( degrees )

j = Int ( ( degrees ( i ) + 5.625 ) / 11.25 )

If j > 31 Then j = j - 32

Print Using "####.## ## " ; degrees ( i ) ; j;

Print names ( j )

Next



' empty keyboard buffer

While Inkey <> "" : Wend

Print : Print "hit any key to end program"

Sleep

End

Output:

0.00 0 North 16.87 1 North by east 16.88 2 North-northeast 33.75 3 Northeast by north 50.62 4 Northeast 50.63 5 Northeast by east 67.50 6 East-northeast 84.37 7 East by north 84.38 8 East 101.25 9 East by south 118.12 10 East-southeast 118.13 11 Southeast by east 135.00 12 Southeast 151.87 13 Southeast by south 151.88 14 South-southeast 168.75 15 South by east 185.62 16 South 185.63 17 South by west 202.50 18 South-southwest 219.37 19 Southwest by south 219.38 20 Southwest 236.25 21 Southwest by west 253.12 22 West-southwest 253.13 23 West by south 270.00 24 West 286.87 25 West by north 286.88 26 West-northwest 303.75 27 Northwest by west 320.62 28 Northwest 320.63 29 Northwest by north 337.50 30 North-northwest 354.37 31 North by west 354.38 0 North

Click this link to run this code

Public Sub Main ( )

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" ]

Dim sHeading As String [ ] = [ "N" , "NbE" , "NNE" , "NEbE" , "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" ]

Dim siLoop As Short

Dim sDirection As String

Dim fCount, fTemp As Float



For Each fCount In fDeg

fTemp = Round ( fCount / 11.25 )

If fTemp = 32 Then fTemp = 0

For siLoop = 0 To Len ( sHeading [ fTemp ] )

sDirection &= cHeading [ Mid ( sHeading [ fTemp ] , siLoop + 1 , 1 ) ] & " "

Next

Print "Index=" & Format ( fTemp + 1 , "#0" ) & " " & Format ( Str ( fCount ) , "##0.00" ) & " degrees = " & sDirection

sDirection = ""

Next



End

Output:

Index= 1 0.00 degrees = North Index= 2 16.87 degrees = North by East Index= 3 16.88 degrees = North North East Index= 4 33.75 degrees = North East by East Index= 5 50.62 degrees = North East Index= 6 50.63 degrees = North East by East Index= 7 67.50 degrees = East North East Index= 8 84.37 degrees = East by North Index= 9 84.38 degrees = East Index=10 101.25 degrees = East by South Index=11 118.12 degrees = East South East Index=12 118.13 degrees = South East by East Index=13 135.00 degrees = South East Index=14 151.87 degrees = South East by South Index=15 151.88 degrees = South South East Index=16 168.75 degrees = South by East Index=17 185.62 degrees = South Index=18 185.63 degrees = South by West Index=19 202.50 degrees = South South West Index=20 219.37 degrees = South West by South Index=21 219.38 degrees = South West Index=22 236.25 degrees = South West by West Index=23 253.12 degrees = West South West Index=24 253.13 degrees = West by South Index=25 270.00 degrees = West Index=26 286.87 degrees = West by North Index=27 286.88 degrees = West North West Index=28 303.75 degrees = North West by West Index=29 320.62 degrees = North West Index=30 320.63 degrees = North West by North Index=31 337.50 degrees = North North West Index=32 354.37 degrees = North by West Index= 1 354.38 degrees = North

package main



import "fmt"



// function required by task

func degrees2compasspoint ( h float32 ) string {

return compassPoint [ cpx ( h )]

}



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

// input heading h is in degrees. Note this index is a zero-based index

// suitable for indexing into the table of printable compass points,

// and is not the same as the index specified to be printed in the output.

func cpx ( h float32 ) int {

x := int ( h / 11 . 25 +. 5 ) % 32

if x < 0 {

x += 32

}

return x

}



// printable compass points

var compassPoint = [] string {

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

}



func main () {

fmt . Println ( "Index Compass point Degree" )

for i , h := range [] float32 { 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 } {

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

fmt . Printf ( "%4d %-19s %7.2f°

" , index , degrees2compasspoint ( h ), h )

}

}

Index Compass point Degree 1 North 0.00° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.50° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135.00° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.50° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270.00° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.50° 32 North by west 354.37° 1 North 354.38°

def asCompassPoint ( angle ) {

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



int index = Math . floor ( angle / 11.25 + 0.5 )

int cardinalIndex = ( index / 8 )



def c1 = cardinalDirections [ cardinalIndex % 4 ]

def c2 = cardinalDirections [ ( cardinalIndex + 1 ) % 4 ]

def c3 = ( cardinalIndex == 0 || cardinalIndex == 2 ) ? "$c1$c2" : "$c2$c1"



def point = [

"$c1" , "$c1 by $c2" , "$c1-$c3" , "$c3 by $c1" , "$c3" , "$c3 by $c2" , "$c2-$c3" , "$c2 by $c1"

] [ index % 8 ]

point. substring ( 0 , 1 ) . toUpperCase ( ) + point. substring ( 1 )

}

Number . metaClass . asCompassPoint = { asCompassPoint ( delegate ) }



[ 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 ] . eachWithIndex { angle, index ->

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

}

Output:

1 North 0.0° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.5° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135.0° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.5° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270.0° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.5° 32 North by west 354.37° 1 North 354.38°

import Data . Char ( toUpper )



import Data . Maybe ( fromMaybe )



import Text . Printf ( PrintfType , printf )



dirs :: [ String ]

dirs =

[ "N"

, "NbE"

, "N-NE"

, "NEbN"

, "NE"

, "NEbE"

, "E-NE"

, "EbN"

, "E"

, "EbS"

, "E-SE"

, "SEbE"

, "SE"

, "SEbS"

, "S-SE"

, "SbE"

, "S"

, "SbW"

, "S-SW"

, "SWbS"

, "SW"

, "SWbW"

, "W-SW"

, "WbS"

, "W"

, "WbN"

, "W-NW"

, "NWbW"

, "NW"

, "NWbN"

, "N-NW"

, "NbW"

]



-- Index between 0 and 31 -> the corresponding compass point name.

pointName :: Int -> String

pointName = capitalize . concatMap ( fromMaybe "?" . fromChar ) . ( dirs !! )

where

fromChar c =

lookup

c

[ ( 'N' , "north" )

, ( 'S' , "south" )

, ( 'E' , "east" )

, ( 'W' , "west" )

, ( 'b' , " by " )

, ( '-' , "-" )

]

capitalize ( c:cs ) = toUpper c : cs



-- Degrees -> compass point index between 0 and 31.

pointIndex :: Double -> Int

pointIndex d = ( round ( d * 1000 ) + 5625 ) ` mod ` 360000 ` div ` 11250



printPointName :: PrintfType t => String -> t

printPointName d =

let deg = read d :: Double

idx = pointIndex deg

in printf "%2d %-18s %6.2f°

" ( idx + 1 ) ( pointName idx ) deg



main :: IO ( )

main = mapM_ ( printPointName . show ) [ 0 .. 31 ]

Output:

1 North 0.00° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.50° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135.00° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.50° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270.00° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.50° 32 North by west 354.37° 1 North 354.38°

import Algorithms as algo;

import Text as text;



class Compass {

_majors = none;

_quarter1 = none;

_quarter2 = none;

constructor() {

_majors = algo.materialize( text.split( "north east south west", " " ), tuple );

_majors += _majors;

_quarter1 = text.split( "N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N", "," );

_quarter2 = algo.materialize( algo.map( _quarter1, @( s ){ copy( s ).replace( "NE", "EN" ); } ), list );

}

degrees_to_compasspoint( d ) {

d = d % 360. + 360. / 64.;

majorindex, minor = ( integer( d ) / 90, d % 90. );

minorindex = integer( minor * 4. ) / 45;

p1, p2 = _majors[majorindex: majorindex + 2];

q = none;

if ( p1 ∈ { "north", "south" } ) {

q = _quarter1;

} else {

q = _quarter2;

}

return ( text.capitalize( copy( q[minorindex] ).replace( "N", p1 ).replace( "E", p2 ) ) );

}

}



main() {

print(

" # | Angle | Compass point

"

"---+---------|-------------------

"

);

c = Compass();

for ( i : algo.range( 33 ) ) {

d = real( i ) * 11.25;

m = i % 3;

if ( m == 1 ) {

d += 5.62;

} else if ( m == 2 ) {

d -= 5.62;

}

n = i % 32 + 1;

print( "{:2d} | {:6.2f}° | {}

".format( n, d, c.degrees_to_compasspoint( d ) ) );

}

}

# | Angle | Compass point ---+---------|------------------- 1 | 0.00° | North 2 | 16.87° | North by east 3 | 16.88° | North-northeast 4 | 33.75° | Northeast by north 5 | 50.62° | Northeast 6 | 50.63° | Northeast by east 7 | 67.50° | East-northeast 8 | 84.37° | East by north 9 | 84.38° | East 10 | 101.25° | East by south 11 | 118.12° | East-southeast 12 | 118.13° | Southeast by east 13 | 135.00° | Southeast 14 | 151.87° | Southeast by south 15 | 151.88° | South-southeast 16 | 168.75° | South by east 17 | 185.62° | South 18 | 185.63° | South by west 19 | 202.50° | South-southwest 20 | 219.37° | Southwest by south 21 | 219.38° | Southwest 22 | 236.25° | Southwest by west 23 | 253.12° | West-southwest 24 | 253.13° | West by south 25 | 270.00° | West 26 | 286.87° | West by north 27 | 286.88° | West-northwest 28 | 303.75° | Northwest by west 29 | 320.62° | Northwest 30 | 320.63° | Northwest by north 31 | 337.50° | North-northwest 32 | 354.37° | North by west 1 | 354.38° | North

This example is incomplete. 354.38? Please ensure that it meets all task requirements and remove this message.

link strings , numbers



procedure main ( )



every heading := 11.25 * ( i := 0 to 32 ) do {

case i % 3 of {

1 : heading +:= 5.62

2 : heading -:= 5.62

}

write ( right ( i + 1 , 3 ) , " " , left ( direction ( heading ) , 20 ) , " " , fix ( heading ,, 7 , 2 ) )

}

end



procedure direction ( d ) # compass heading given +/- degrees

static dirs

initial {

every put ( dirs := [ ] ,

replacem ( ! [ "N" , "NbE" , "N-NE" , "NEbN" , "NE" , "NEbE" , "E-NE" , "EbN" ,

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

"S" , "SbW" , "S-SW" , "SWbS" , "SW" , "SWbW" , "W-SW" , "WbS" ,

"W" , "WbN" , "W-NW" , "NWbW" , "NW" , "NWbN" , "N-NW" , "NbW" ] ,

"N" , "north" , "E" , "east" , "W" , "west" , "S" , "south" , "b" , " by " ) )

}



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

end

Output:

strings for replacem numbers for round, fix

1 north 0.00 2 north by east 16.87 3 north-northeast 16.88 4 northeast by north 33.75 5 northeast 50.62 6 northeast by east 50.63 7 east-northeast 67.50 8 east by north 84.37 9 east 84.38 10 east by south 101.25 11 east-southeast 118.12 12 southeast by east 118.13 13 southeast 135.00 14 southeast by south 151.87 15 south-southeast 151.88 16 south by east 168.75 17 south 185.62 18 south by west 185.63 19 south-southwest 202.50 20 southwest by south 219.37 21 southwest 219.38 22 southwest by west 236.25 23 west-southwest 253.12 24 west by south 253.13 25 west 270.00 26 west by north 286.87 27 west-northwest 286.88 28 northwest by west 303.75 29 northwest 320.62 30 northwest by north 320.63 31 north-northwest 337.50 32 north by west 354.37

100 PROGRAM "Compass.bas"

110 STRING DR$(1 TO 33)*18

120 FOR I=1 TO 33

130 READ DR$(I)

140 NEXT

150 DO

160 READ IF MISSING EXIT DO:D

170 LET DIR=COMP(D)

180 PRINT D;TAB(12);DIR,DR$(DIR)

190 LOOP

200 DEF COMP(D)=CEIL(MOD((D+360/64),360)*32/360)

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

230 DATA 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

0 1 North 16.87 2 North by east 16.88 3 North-northeast 33.75 4 Northeast by north 50.62 5 Northeast 50.63 6 Northeast by east 67.5 7 East-northeast 84.37 8 East by north 84.38 9 East 101.25 10 East by south 118.12 11 East-southeast 118.13 12 Southeast by east 135 13 Southeast 151.87 14 Southeast by south 151.88 15 South-southeast 168.75 16 South by east 185.62 17 South 185.63 18 South by west 202.5 19 South-southwest 219.37 20 Southwest by south 219.38 21 Southwest 236.25 22 Southwest by west 253.12 23 West-southwest 253.13 24 West by south 270 25 West 286.87 26 West by north 286.88 27 West-northwest 303.75 28 Northwest by west 320.62 29 Northwest 320.63 30 Northwest by north 337.5 31 North-northwest 354.37 32 North by west 354.38 1 North

require 'strings'

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

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

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

S,SbW,S-SW,SWbS,SW,SWbW,W-SW,WbS,W,WbN,W-NW,NWbW,NW,NWbN,N-NW,NbW,

)

indice=: 32 | 0.5 <[email protected]+ %& 11.25

deg2pnt=: dirs {~ indice

Output:Output:

Example use:

i. 10

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:

( ":@>:@indice,. ' ' ,.>@deg2pnt,. ' ' ,.":@,. )( *& 11.25 + 5.62 * 0 1 _1 {~ 3 &| ) i. 33

1 North 0

2 North by east 16.87

3 North-northeast 16.88

4 Northeast by north 33.75

5 Northeast 50.62

6 Northeast by east 50.63

7 East-northeast 67.5

8 East by north 84.37

9 East 84.38

10 East by south 101.25

11 East-southeast 118.12

12 Southeast by east 118.13

13 Southeast 135

14 Southeast by south 151.87

15 South-southeast 151.88

16 South by east 168.75

17 South 185.62

18 South by west 185.63

19 South-southwest 202.5

20 Southwest by south 219.37

21 Southwest 219.38

22 Southwest by west 236.25

23 West-southwest 253.12

24 West by south 253.13

25 West 270

26 West by north 286.87

27 West-northwest 286.88

28 Northwest by west 303.75

29 Northwest 320.62

30 Northwest by north 320.63

31 North-northwest 337.5

32 North by west 354.37

1 North 354.38

Translation of: Visual Basic .NET

public class BoxingTheCompass {

private static String [ ] points = new String [ 32 ] ;



public static void main ( String [ ] args ) {

buildPoints ( ) ;



double heading = 0 ;



for ( int i = 0 ; i <= 32 ; i ++ ) {

heading = i * 11.25 ;

switch ( i % 3 ) {

case 1 :

heading += 5.62 ;

break ;

case 2 :

heading -= 5.62 ;

break ;

default :

}



System . out . printf ( "%s \t %18s \t %s°

" , ( i % 32 ) + 1 , initialUpper ( getPoint ( heading ) ) , heading ) ;

}

}



private static void buildPoints ( ) {

String [ ] cardinal = { "north" , "east" , "south" , "west" } ;

String [ ] pointDesc = { "1" , "1 by 2" , "1-C" , "C by 1" , "C" , "C by 2" , "2-C" , "2 by 1" } ;



String str1, str2, strC ;



for ( int i = 0 ; i <= 3 ; i ++ ) {

str1 = cardinal [ i ] ;

str2 = cardinal [ ( i + 1 ) % 4 ] ;

strC = ( str1. equals ( "north" ) || str1. equals ( "south" ) ) ? ( str1 + str2 ) : ( str2 + str1 ) ;

for ( int j = 0 ; j <= 7 ; j ++ ) {

points [ i * 8 + j ] = pointDesc [ j ] . replace ( "1" , str1 ) . replace ( "2" , str2 ) . replace ( "C" , strC ) ;

}

}

}



private static String initialUpper ( String s ) {

return s. substring ( 0 , 1 ) . toUpperCase ( ) + s. substring ( 1 ) ;

}



private static String getPoint ( double degrees ) {

double testD = ( degrees / 11.25 ) + 0.5 ;

return points [ ( int ) Math . floor ( testD % 32 ) ] ;

}

}

Output:

1 North 0.0° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.5° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135.0° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.5° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270.0° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.5° 32 North by west 354.37° 1 North 354.38°

ES5 [ edit ]

An iterative, web-based approach:

function createRow ( i , point , heading ) {

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

td ;



td = document. createElement ( 'td' ) ;

td. appendChild ( document. createTextNode ( i ) ) ;

tr. appendChild ( td ) ;



td = document. createElement ( 'td' ) ;

point = point. substr ( 0 , 1 ) . toUpperCase ( ) + point. substr ( 1 ) ;

td. appendChild ( document. createTextNode ( point ) ) ;

tr. appendChild ( td ) ;



td = document. createElement ( 'td' ) ;

td. appendChild ( document. createTextNode ( heading ) ) ;

tr. appendChild ( td ) ;



return tr ;

}



function getPoint ( i ) {

var j = i % 8 ,

i = Math . floor ( i / 8 ) % 4 ,

cardinal = [ 'north' , 'east' , 'south' , 'west' ] ,

pointDesc = [ '1' , '1 by 2' , '1-C' , 'C by 1' , 'C' , 'C by 2' , '2-C' , '2 by 1' ] ,

str1 , str2 , strC ;



str1 = cardinal [ i ] ;

str2 = cardinal [ ( i + 1 ) % 4 ] ;

strC = ( str1 === 'north' || str1 === 'south' ) ? str1 + str2 : str2 + str1 ;

return pointDesc [ j ] . replace ( '1' , str1 ) . replace ( '2' , str2 ) . replace ( 'C' , strC ) ;

}



var i ,

heading ,

table = document. createElement ( 'table' ) ,

tbody = document. createElement ( 'tbody' ) ,

tr ;

for ( i = 0 ; i <= 32 ; i += 1 ) {

heading = i * 11.25 + [ 0 , 5.62 , - 5.62 ] [ i % 3 ] ;

tr = createRow ( i % 32 + 1 , getPoint ( i ) , heading + '°' ) ;

tbody. appendChild ( tr ) ;

}

table. appendChild ( tbody ) ;

document. body . appendChild ( table ) ;



Output:

1 North 0° 2 North by east 16.87° 3 North-northeast 16.88° 4 Northeast by north 33.75° 5 Northeast 50.62° 6 Northeast by east 50.63° 7 East-northeast 67.5° 8 East by north 84.37° 9 East 84.38° 10 East by south 101.25° 11 East-southeast 118.12° 12 Southeast by east 118.13° 13 Southeast 135° 14 Southeast by south 151.87° 15 South-southeast 151.88° 16 South by east 168.75° 17 South 185.62° 18 South by west 185.63° 19 South-southwest 202.5° 20 Southwest by south 219.37° 21 Southwest 219.38° 22 Southwest by west 236.25° 23 West-southwest 253.12° 24 West by south 253.13° 25 West 270° 26 West by north 286.87° 27 West-northwest 286.88° 28 Northwest by west 303.75° 29 Northwest 320.62° 30 Northwest by north 320.63° 31 North-northwest 337.5° 32 North by west 354.37° 1 North 354.38°

ES6 [ edit ]

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

( ( ) => {

'use strict' ;



// GENERIC FUNCTIONS



// toTitle :: String -> String

let toTitle = s => s. length ? ( s [ 0 ] . toUpperCase ( ) + s. slice ( 1 ) ) : '' ;



// COMPASS DATA AND FUNCTIONS



// Scale invariant keys for points of the compass

// (allows us to look up a translation for one scale of compass (32 here)

// for use in another size of compass (8 or 16 points)

// (Also semi-serviceable as more or less legible keys without translation)



// compassKeys :: Int -> [String]

let compassKeys = depth => {

let urCompass = [ 'N' , 'S' , 'N' ] ,

subdivision = ( compass , n ) => n <= 1 ? (

compass

) : subdivision ( // Borders between N and S engender E and W.

// other new boxes concatenate their parent keys.

compass. reduce ( ( a , x , i , xs ) => {

if ( i > 0 ) {

return ( n === depth ) ? (

a. concat ( [ x === 'N' ? 'W' : 'E' ] , x )

) : a. concat ( [ xs [ i - 1 ] + x , x ] ) ;

} else return a. concat ( x ) ;

} , [ ] ) ,

n - 1

) ;

return subdivision ( urCompass , depth )

. slice ( 0 , - 1 ) ;

} ;



// https://zh.wikipedia.org/wiki/%E7%BD%97%E7%9B%98%E6%96%B9%E4%BD%8D

let lstLangs = [ {

'name' : 'English' ,

expansions : {

N : 'north' ,

S : 'south' ,

E : 'east' ,

W : 'west' ,

b : ' by ' ,

'-' : '-'

} ,

'N' : 'N' ,

'NNNE' : 'NbE' ,

'NNE' : 'N-NE' ,

'NNENE' : 'NEbN' ,

'NE' : 'NE' ,

'NENEE' : 'NEbE' ,

'NEE' : 'E-NE' ,

'NEEE' : 'EbN' ,

'E' : 'E' ,

'EEES' : 'EbS' ,

'EES' : 'E-SE' ,

'EESES' : 'SEbE' ,

'ES' : 'SE' ,

'ESESS' : 'SEbS' ,

'ESS' : 'S-SE' ,

'ESSS' : 'SbE' ,

'S' : 'S' ,

'SSSW' : 'SbW' ,

'SSW' : 'S-SW' ,

'SSWSW' : 'SWbS' ,

'SW' : 'SW' ,

'SWSWW' : 'SWbW' ,

'SWW' : 'W-SW' ,

'SWWW' : 'WbS' ,

'W' : 'W' ,

'WWWN' : 'WbN' ,

'WWN' : 'W-NW' ,

'WWNWN' : 'NWbW' ,

'WN' : 'NW' ,

'WNWNN' : 'NWbN' ,

'WNN' : 'N-NW' ,

'WNNN' : 'NbW'

} , {

'name' : 'Chinese' ,

'N' : '北' ,

'NNNE' : '北微东' ,

'NNE' : '东北偏北' ,

'NNENE' : '东北微北' ,

'NE' : '东北' ,

'NENEE' : '东北微东' ,

'NEE' : '东北偏东' ,

'NEEE' : '东微北' ,

'E' : '东' ,

'EEES' : '东微南' ,

'EES' : '东南偏东' ,

'EESES' : '东南微东' ,

'ES' : '东南' ,

'ESESS' : '东南微南' ,

'ESS' : '东南偏南' ,

'ESSS' : '南微东' ,

'S' : '南' ,

'SSSW' : '南微西' ,

'SSW' : '西南偏南' ,

'SSWSW' : '西南微南' ,

'SW' : '西南' ,

'SWSWW' : '西南微西' ,

'SWW' : '西南偏西' ,

'SWWW' : '西微南' ,

'W' : '西' ,

'WWWN' : '西微北' ,

'WWN' : '西北偏西' ,

'WWNWN' : '西北微西' ,

'WN' : '西北' ,

'WNWNN' : '西北微北' ,

'WNN' : '西北偏北' ,

'WNNN' : '北微西'

} ] ;



// pointIndex :: Int -> Num -> Int

let pointIndex = ( power , degrees ) => {

let nBoxes = ( power ? Math . pow ( 2 , power ) : 32 ) ;

return Math . ceil (

( degrees + ( 360 / ( nBoxes * 2 ) ) ) % 360 * nBoxes / 360

) || 1 ;

} ;



// pointNames :: Int -> Int -> [String]

let pointNames = ( precision , iBox ) => {

let k = compassKeys ( precision ) [ iBox - 1 ] ;

return lstLangs. map ( dctLang => {

let s = dctLang [ k ] || k , // fallback to key if no translation

dctEx = dctLang. expansions ;



return dctEx ? toTitle ( s. split ( '' )

. map ( c => dctEx [ c ] )

. join ( precision > 5 ? ' ' : '' ) )

. replace ( / / g , ' ' ) : s ;

} ) ;

} ;



// maximumBy :: (a -> a -> Ordering) -> [a] -> a

let maximumBy = ( f , xs ) =>

xs. reduce ( ( a , x ) => a === undefined ? x : (

f ( x , a ) > 0 ? x : a

) , undefined ) ;



// justifyLeft :: Int -> Char -> Text -> Text

let justifyLeft = ( n , cFiller , strText ) =>

n > strText. length ? (

( strText + replicate ( n , cFiller )

. join ( '' ) )

. substr ( 0 , n )

) : strText ;



// justifyRight :: Int -> Char -> Text -> Text

let justifyRight = ( n , cFiller , strText ) =>

n > strText. length ? (

( replicate ( n , cFiller )

. join ( '' ) + strText )

. slice ( - n )

) : strText ;



// replicate :: Int -> a -> [a]

let replicate = ( n , a ) => {

let v = [ a ] ,

o = [ ] ;

if ( n < 1 ) return o ;

while ( n > 1 ) {

if ( n & 1 ) o = o. concat ( v ) ;

n >>= 1 ;

v = v. concat ( v ) ;

}

return o. concat ( v ) ;

} ;



// transpose :: [[a]] -> [[a]]

let transpose = xs =>

xs [ 0 ] . map ( ( _ , iCol ) => xs. map ( ( row ) => row [ iCol ] ) ) ;



// length :: [a] -> Int

// length :: Text -> Int

let length = xs => xs. length ;



// compareByLength = (a, a) -> (-1 | 0 | 1)

let compareByLength = ( a , b ) => {

let [ na , nb ] = [ a , b ] . map ( length ) ;

return na < nb ? - 1 : na > nb ? 1 : 0 ;

} ;



// maxLen :: [String] -> Int

let maxLen = xs => maximumBy ( compareByLength , xs )

. length ;



// compassTable :: Int -> [Num] -> Maybe String

let compassTable = ( precision , xs ) => {

if ( precision < 1 ) return undefined ;

else {

let intPad = 2 ;



let lstIndex = xs. map ( x => pointIndex ( precision , x ) ) ,

lstStrIndex = lstIndex. map ( x => x. toString ( ) ) ,

nIndexWidth = maxLen ( lstStrIndex ) ,

colIndex = lstStrIndex. map (

x => justifyRight ( nIndexWidth , ' ' , x )

) ;



let lstAngles = xs. map ( x => x. toFixed ( 2 ) + '°' ) ,

nAngleWidth = maxLen ( lstAngles ) + intPad ,

colAngles = lstAngles. map ( x => justifyRight ( nAngleWidth , ' ' , x ) ) ;



let lstTrans = transpose (

lstIndex. map ( i => pointNames ( precision , i ) )

) ,

lstTransWidths = lstTrans. map ( x => maxLen ( x ) + 2 ) ,

colsTrans = lstTrans

. map ( ( lstLang , i ) => lstLang

. map ( x => justifyLeft ( lstTransWidths [ i ] , ' ' , x ) )

) ;



return transpose ( [ colIndex ]

. concat ( [ colAngles ] , [ replicate ( lstIndex. length , " " ) ] )

. concat ( colsTrans ) )

. map ( x => x. join ( '' ) )

. join ( '

' ) ;

}

}



// TEST

let xs = [ 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

] ;



// If we supply other precisions, like 4 or 6, (2^n -> 16 or 64 boxes)

// the bearings will be divided amongst smaller or larger numbers of boxes,

// either using name translations retrieved by the generic hash

// or using the hash itself (combined with any expansions)

// to substitute for missing names for very finely divided boxes.



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

} ) ( ) ;

Output:

1 0.00° North 北 2 16.87° North by east 北微东 3 16.88° North-northeast 东北偏北 4 33.75° Northeast by north 东北微北 5 50.62° Northeast 东北 6 50.63° Northeast by east 东北微东 7 67.50° East-northeast 东北偏东 8 84.37° East by north 东微北 9 84.38° East 东 10 101.25° East by south 东微南 11 118.12° East-southeast 东南偏东 12 118.13° Southeast by east 东南微东 13 135.00° Southeast 东南 14 151.87° Southeast by south 东南微南 15 151.88° South-southeast 东南偏南 16 168.75° South by east 南微东 17 185.62° South 南 18 185.63° South by west 南微西 19 202.50° South-southwest 西南偏南 20 219.37° Southwest by south 西南微南 21 219.38° Southwest 西南 22 236.25° Southwest by west 西南微西 23 253.12° West-southwest 西南偏西 24 253.13° West by south 西微南 25 270.00° West 西 26 286.87° West by north 西微北 27 286.88° West-northwest 西北偏西 28 303.75° Northwest by west 西北微西 29 320.62° Northwest 西北 30 320.63° Northwest by north 西北微北 31 337.50° North-northwest 西北偏北 32 354.37° North by west 北微西 1 354.38° North 北

Works with: Julia version 1.2

Translation of: Python

using Printf



function degree2compasspoint(d::Float64)

majors = ("north", "east", "south", "west", "north", "east", "south", "west")

quarter1 = ("N", "N by E", "N-NE", "NE by N", "NE", "NE by E", "E-NE", "E by N")

quarter2 = map(p -> replace(p, "NE" => "EN"), quarter1)



d = d % 360 + 360 / 64

imajor, minor = divrem(d, 90)

iminor = div(minor * 4, 45)

imajor += 1

iminor += 1

p1, p2 = majors[imajor:imajor+1]

q = p1 in ("north", "south") ? quarter1 : quarter2

titlecase(replace(replace(q[iminor], 'N' => p1), 'E' => p2))

end



for i in 0:32

d = i * 11.25

i % 3 == 1 && (d += 5.62)

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

@printf("%2i %-17s %10.2f°

", i % 32 + 1, degree2compasspoint(d), d)

end

Output:

1 North 0.00° 2 North By East 16.87° 3 North-Northeast 16.88° 4 Northeast By North 33.75° 5 Northeast 50.62° 6 Northeast By East 50.63° 7 East-Northeast 67.50° 8 East By North 84.37° 9 East 84.38° 10 East By South 101.25° 11 East-Southeast 118.12° 12 Southeast By East 118.13° 13 Southeast 135.00° 14 Southeast By South 151.87° 15 South-Southeast 151.88° 16 South By East 168.75° 17 South 185.62° 18 South By West 185.63° 19 South-Southwest 202.50° 20 Southwest By South 219.37° 21 Southwest 219.38° 22 Southwest By West 236.25° 23 West-Southwest 253.12° 24 West By South 253.13° 25 West 270.00° 26 West By North 286.87° 27 West-Northwest 286.88° 28 Northwest By West 303.75° 29 Northwest 320.62° 30 Northwest By North 320.63° 31 North-Northwest 337.50° 32 North By West 354.37° 1 North 354.38°

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

d:("N;Nbe;N-ne;Nebn;Ne;Nebe;E-ne;Ebn;")

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

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

d,:("W;Wbn;W-nw;Nwbw;Nw;Nwbn;N-nw;Nbw;N")



split:{1_'(&x=y)_ x:y,x}

dd:split[d;";"]



/ lookup table

s1:"NEWSnewsb-"

s2:("North";"East";"West";"South";"north";"east";"west";"south";" by ";"-")

c:.({`$x}'s1),'{`$x}'s2 / create the dictionary

cc:{,/{$c[`$$x]}'x} / lookup function



/ calculate the degrees

f:{m:x!3;(11.25*x)+:[1=m;+5.62;2=m;-5.62;0]}

The table:

`0:{((2$(1+x!32))," ",([email protected][x]),([email protected]))}'!#dd

1 North 0.00

2 North by east 16.87

3 North-northeast 16.88

4 Northeast by north 33.75

5 Northeast 50.62

6 Northeast by east 50.63

7 East-northeast 67.50

8 East by north 84.37

9 East 84.38

10 East by south 101.25

11 East-southeast 118.12

12 Southeast by east 118.13

13 Southeast 135.00

14 Southeast by south 151.87

15 South-southeast 151.88

16 South by east 168.75

17 South 185.62

18 South by west 185.63

19 South-southwest 202.50

20 Southwest by south 219.37

21 Southwest 219.38

22 Southwest by west 236.25

23 West-southwest 253.12

24 West by south 253.13

25 West 270.00

26 West by north 286.87

27 West-northwest 286.88

28 Northwest by west 303.75

29 Northwest 320.62

30 Northwest by north 320.63

31 North-northwest 337.50

32 North by west 354.37

1 North 354.38

// version 1.1.2



fun expand ( cp : String ) : String {

val sb = StringBuilder ( )

for ( c in cp ) {

sb. append ( when ( c ) {

'N' - > "north"

'E' - > "east"

'S' - > "south"

'W' - > "west"

'b' - > " by "

else - > "-"

} )

}

return sb. toString ( ) . capitalize ( )

}



fun main ( args : Array < String > ) {

val cp = arrayOf (

"N" , "NbE" , "N-NE" , "NEbN" , "NE" , "NEbE" , "E-NE" , "EbN" ,

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

"S" , "SbW" , "S-SW" , "SWbS" , "SW" , "SWbW" , "W-SW" , "WbS" ,

"W" , "WbN" , "W-NW" , "NWbW" , "NW" , "NWbN" , "N-NW" , "NbW"

)

println ( "Index Degrees Compass point" )

println ( "----- ------- -------------" )

val f = "%2d %6.2f %s"

for ( i in 0 .. 32 ) {

val index = i % 32

var heading = i * 11.25

when ( i % 3 ) {

1 - > heading + = 5.62

2 - > heading - = 5.62

}

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

}

}

Output:

Index Degrees Compass point ----- ------- ------------- 1 0.00 North 2 16.87 North by east 3 16.88 North-northeast 4 33.75 Northeast by north 5 50.62 Northeast 6 50.63 Northeast by east 7 67.50 East-northeast 8 84.37 East by north 9 84.38 East 10 101.25 East by south 11 118.12 East-southeast 12 118.13 Southeast by east 13 135.00 Southeast 14 151.87 Southeast by south 15 151.88 South-southeast 16 168.75 South by east 17 185.62 South 18 185.63 South by west 19 202.50 South-southwest 20 219.37 Southwest by south 21 219.38 Southwest 22 236.25 Southwest by west 23 253.12 West-southwest 24 253.13 West by south 25 270.00 West 26 286.87 West by north 27 286.88 West-northwest 28 303.75 Northwest by west 29 320.62 Northwest 30 320.63 Northwest by north 31 337.50 North-northwest 32 354.37 North by west 1 354.38 North

Translation of: D

Works with: langur version 0.6.13

val .box = ["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"]



val .angles = [

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]



writeln "index degrees compass point"

writeln "----- ------- -------------"



for .phi in .angles {

val .i = truncate(.phi x 32 / 360 + 0.5) rem 32 + 1

writeln $"\.i:5; \.phi:r2:6; \.box[.i];"

}

Output:

index degrees compass point ----- ------- ------------- 1 0.00 North 2 16.87 North by east 3 16.88 North-northeast 4 33.75 Northeast by north 5 50.62 Northeast 6 50.63 Northeast by east 7 67.50 East-northeast 8 84.37 East by north 9 84.38 East 10 101.25 East by south 11 118.12 East-southeast 12 118.13 Southeast by east 13 135.00 Southeast 14 151.87 Southeast by south 15 151.88 South-southeast 16 168.75 South by east 17 185.62 South 18 185.63 South by west 19 202.50 South-southwest 20 219.37 Southwest by south 21 219.38 Southwest 22 236.25 Southwest by west 23 253.12 West-southwest 24 253.13 West by south 25 270.00 West 26 286.87 West by north 27 286.88 West-northwest 28 303.75 Northwest by west 29 320.62 Northwest 30 320.63 Northwest by north 31 337.50 North-northwest 32 354.37 North by west 1 354.38 North

define pointsarray() => {

local(points = array)

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

local(heading = loop_count * 11.25)

if(loop_count % 3 == 1) => {

#heading += 5.62

else(loop_count % 3 == 2)

#heading -= 5.62

}

#points->insert(#heading)

}

return #points

}

define compassShort => array(

'N','Nbe','N-ne','Nebn','Ne','Nebe','E-ne','Ebn',

'E','Ebs','E-se','Sebe','Se','Sebs','S-se','Sbe',

'S','Sbw','S-sw','Swbs','Sw','Swbw','W-sw','Wbs',

'W','Wbn','W-nw','Nwbw','Nw','Nwbn','N-nw','Nbw', 'N')

define compassLong(short::string) => {

local(o = string)

with i in #short->values do => { #o->append(compassLongProcessor(#i)) }

return #o

}

define compassLongProcessor(char::string) => {

#char == 'N' ? return #char + 'orth'

#char == 'S' ? return #char + 'outh'

#char == 'E' ? return #char + 'ast'

#char == 'W' ? return #char + 'est'

#char == 'b' ? return ' by '

#char == '-' ? return '-'

}

// test output points as decimals

//pointsarray



// test output the array of text values

//compassShort



// test output the long names of the text values

//with s in compassShort do => {^ compassLong(#s) + '\r' ^}



'angle | box | compass point

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

'

local(counter = 0)

with p in pointsarray do => {^

local(pformatted = #p->asString(-precision=2))

while(#pformatted->size < 6) => { #pformatted->append(' ') }

#counter += 1

#counter > 32 ? #counter = 1

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



^}

Output:

angle | box | compass point --------------------------------- 0.00 | 1 | North 16.87 | 2 | North by east 16.88 | 3 | North-northeast 33.75 | 4 | Northeast by north 50.62 | 5 | Northeast 50.63 | 6 | Northeast by east 67.50 | 7 | East-northeast 84.37 | 8 | East by north 84.38 | 9 | East 101.25 | 10 | East by south 118.12 | 11 | East-southeast 118.13 | 12 | Southeast by east 135.00 | 13 | Southeast 151.87 | 14 | Southeast by south 151.88 | 15 | South-southeast 168.75 | 16 | South by east 185.62 | 17 | South 185.63 | 18 | South by west 202.50 | 19 | South-southwest 219.37 | 20 | Southwest by south 219.38 | 21 | Southwest 236.25 | 22 | Southwest by west 253.12 | 23 | West-southwest 253.13 | 24 | West by south 270.00 | 25 | West 286.87 | 26 | West by north 286.88 | 27 | West-northwest 303.75 | 28 | Northwest by west 320.62 | 29 | Northwest 320.63 | 30 | Northwest by north 337.50 | 31 | North-northwest 354.37 | 32 | North by west 354.38 | 1 | North

dim point$ ( 32 )



for i = 1 to 32

read d$ : point$ ( i ) = d$

next i



for i = 0 to 32

heading = i * 11.25

if ( i mod 3 ) = 1 then

heading = heading + 5.62

else

if ( i mod 3 ) = 2 then heading = heading - 5.62

end if

ind = i mod 32 + 1

print ind , compasspoint$ ( heading ) , heading

next i



end



function compasspoint$ ( h )

x = h / 11.25 + 1.5

if ( x >= 33.0 ) then x = x - 32.0

compasspoint$ = point$ ( int ( x ) )

end function



data "North " , "North by east " , "North-northeast "

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

data "East by north " , "East " , "East by south " , "East-southeast "

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

data "South by east " , "South " , "South by west " , "South-southwest "

data "Southwest by south" , "Southwest " , "Southwest by west " , "West-southwest "

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

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

data "North by west

Output:

1 North 0 2 North by east 16.87 3 North-northeast 16.88 4 Northeast by north 33.75 5 Northeast 50.62 6 Northeast by east 50.63 7 East-northeast 67.5 8 East by north 84.37 9 East 84.38 10 East by south 101.25 11 East-southeast 118.12 12 Southeast by east 118.13 13 Southeast 135 14 Southeast by south 151.87 15 South-southeast 151.88 16 South by east 168.75 17 South 185.62 18 South by west 185.63 19 South-southwest 202.5 20 Southwest by south 219.37 21 Southwest 219.38 22 Southwest by west 236.25 23 West-southwest 253.12 24 West by south 253.13 25 West 270 26 West by north 286.87 27 West-northwest 286.88 28 Northwest by west 303.75 29 Northwest 320.62 30 Northwest by north 320.63 31 North-northwest 337.5 32 North by west 354.37 1 North 354.38

Translation of: C

; This is not strictly LLVM, as it uses the C library function "printf".

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



; Additional comments have been inserted, as well as changes made from the output produced by clang such as putting more meaningful labels for the jumps



;--- The declarations for the external C functions

declare i32 @printf ( i8 *, ... )



$ "COMPASS_STR" = comdat any

$ "OUTPUT_STR" = comdat any



@main.degrees = private unnamed_addr constant [ 33 x double ] [ double 0.000000e+00 , double 1.687000e+01 , double 1.688000e+01 , double 3.375000e+01 , double 5.062000e+01 , double 5.063000e+01 , double 6.750000e+01 , double 8.437000e+01 , double 0x40551851EB851EB8 , double 1.012500e+02 , double 1.181200e+02 , double 1.181300e+02 , double 1.350000e+02 , double 1.518700e+02 , double 1.518800e+02 , double 1.687500e+02 , double 1.856200e+02 , double 1.856300e+02 , double 2.025000e+02 , double 2.193700e+02 , double 2.193800e+02 , double 2.362500e+02 , double 2.531200e+02 , double 2.531300e+02 , double 2.700000e+02 , double 2.868700e+02 , double 2.868800e+02 , double 3.037500e+02 , double 3.206200e+02 , double 3.206300e+02 , double 3.375000e+02 , double 3.543700e+02 , double 3.543800e+02 ] , align 16

@ "COMPASS_STR" = linkonce_odr unnamed_addr constant [ 727 x i8 ] c "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 \00" , comdat , align 1

@ "OUTPUT_STR" = linkonce_odr unnamed_addr constant [ 19 x i8 ] c "%2d %.22s %6.2f\0A\00" , comdat , align 1



; Function Attrs: noinline nounwind optnone uwtable

define i32 @main ( ) # 0 {

%1 = alloca i32 , align 4 ;-- allocate i

%2 = alloca i32 , align 4 ;-- allocate j

%3 = alloca [ 33 x double ] , align 16 ;-- allocate degrees

%4 = alloca i8 *, align 8 ;-- allocate names

%5 = bitcast [ 33 x double ] * %3 to i8 *

call void @llvm.memcpy.p0i8.p0i8. i64 ( i8 * %5 , i8 * bitcast ( [ 33 x double ] * @main.degrees to i8 * ) , i64 264 , i32 16 , i1 false )

store i8 * getelementptr inbounds ( [ 727 x i8 ] , [ 727 x i8 ] * @ "COMPASS_STR" , i32 0 , i32 0 ) , i8 ** %4 , align 8

store i32