Rosetta Code

Box the compass: Difference between revisions

Page Discussion

Box the compass (view source)

Revision as of 18:27, 26 August 2022

2,660 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 25:
=={{header|11l}}==
{{trans|Python}}
<langsyntaxhighlight lang=11l>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(‘,’)
Line 52:
d -= 5.62
V n = i % 32 + 1
print(‘#2.0 #<18 #4.2°’.format(n, degrees2compasspoint(d), d))</langsyntaxhighlight>
{{out}}
<pre>
Line 67:
Atari 8-bit computer is able to show up to 40 characters per row. Therefore abbreviations of direction have been used instead of the full names.
{{libheader|Action! Tool Kit}}
<langsyntaxhighlight lang=Action!>INCLUDE "D2:PRINTF.ACT" ;from the Action! Tool Kit
INCLUDE "D2:REAL.ACT" ;from the Action! Tool Kit
 
Line 172:
Position(x,y) PrintAngle(rh)
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Box_the_compass.png Screenshot from Atari 8-bit computer]
Line 199:
Inspired by [[#C++|the C++ program]], but without the need for a specific library.
 
<langsyntaxhighlight lang=Ada>with Ada.Text_IO;
 
procedure Box_The_Compass is
Line 264:
Put_Line(Degrees(Degrees'Base(I) * 11.25 + Difference(I mod 3)));
end loop;
end Box_The_Compass;</langsyntaxhighlight>
 
Output:
Line 308:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}
<langsyntaxhighlight lang=algol68>#!/usr/local/bin/a68g --script #
 
[]STRING
Line 403:
))
OD
)</langsyntaxhighlight>
Output:
<pre>
Line 486:
Functional composition, allowing for additional languages, and different numbers of compass points – see the test section)
 
<langsyntaxhighlight lang=AppleScript>use framework "Foundation"
use scripting additions
 
Line 878:
((ca's NSString's stringWithString:(str))'s ¬
uppercaseStringWithLocale:(ca's NSLocale's currentLocale())) as text
end toUpper</langsyntaxhighlight>
{{Out}}
<pre> 1 0.00° North 北
Line 917:
{{trans|C++}}
{{works with|AutoHotkey_L}}
<langsyntaxhighlight lang=AHK>get_Index(angle){
return Mod(floor(angle / 11.25 +0.5), 32) + 1
}
Line 955:
. " ", 1, 24) . SubStr(" " a, -5) . "`r`n" ;
}
clipboard := out</langsyntaxhighlight>
;Output
<pre> 1 North 0.00
Line 993:
=={{header|AutoIt}}==
 
<langsyntaxhighlight lang=AutoIt>
Local $avArray[33] = [0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, _
151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, _
Line 1,012:
StringFormat("%-20s", $namearray[Mod(Floor($Degree / 11.25 + 0.5), 32)]) & " : " & $Degree & @CRLF)
EndFunc ;==>Boxing_the_compass
</syntaxhighlight>
</lang>
 
Output : <pre>0 : North : 0
Line 1,049:
 
=={{header|AWK}}==
<langsyntaxhighlight lang=awk>#!/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," ");
Line 1,067:
printf "%6.2f : %2d\t%s\n",$1,box,A[box];
}
</syntaxhighlight>
</lang>
Output:
<pre> 0.00 : 1 N
Line 1,104:
 
=={{header|BASIC256}}==
<langsyntaxhighlight lang=BASIC256>arraybase 1
 
dim names$ = {"North", "North by east", "North-northeast", "Northeast by north", "Northeast", "Northeast by east", "East-northeast", "East by north", "East", "East by south", "East-southeast", "Southeast by east", "Southeast", "Southeast by south", "South-southeast", "South by east", "South", "South by west", "South-southwest", "Southwest by south", "Southwest", "Southwest by west", "West-southwest", "West by south", "West", "West by north", "West-northwest", "Northwest by west", "Northwest", "Northwest by north", "North-northwest", "North by west", "North"}
Line 1,114:
if j > 31 then j -= 32
print rjust(string(j),2); " "; ljust(string(names$[j+1]),20); grados[i]
next i</langsyntaxhighlight>
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang=bbcbasic> 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, \
Line 1,145:
pt$() = "north", "east", "south", "west"
= pt$(pt% DIV 8)
</syntaxhighlight>
</lang>
Output:
<pre>0 1 North
Line 1,182:
 
=={{header|Befunge}}==
<langsyntaxhighlight lang=befunge>>>::"}"9**\4+3%79*9*5-*79*9*5--+:5>>>06p:55+%68*+v
^_@#!`*84:+1<v*9"}"*+55,,,".",,,$$_^#!:-1g60/+55\<
>_06g:v>55+,^>/5+55+/48*::::,,,,%:1+.9,:06p48*\-0v
Line 1,196:
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</langsyntaxhighlight>
 
{{output}}
Line 1,236:
Like [[wp:Box the compass|Wikipedia's article]], this program uses indexes to count the headings. There are now 33 headings, from 1 to 33, because 0.0 and 354.38 are different angles. (This differs from the task pseudocode, which mapped the 32 compass points to indexes.)
 
<langsyntaxhighlight lang=C>#include <stdio.h>
 
int main()
Line 1,288:
 
return 0;
}</langsyntaxhighlight>Output:
<pre>
1 North 0.00
Line 1,326:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang=csharp>
using System;
using System.Collections.Generic;
Line 1,363:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,404:
Using the Boost libraries
{{libheader|Boost}}
<langsyntaxhighlight lang=cpp>#include <string>
#include <boost/array.hpp>
#include <boost/assign/list_of.hpp>
Line 1,462:
}
return 0;
}</langsyntaxhighlight>
Output:
<pre>
Line 1,502:
=={{header|Clojure}}==
{{trans|Tcl}}
<langsyntaxhighlight lang=lisp>(ns boxing-the-compass
(:use [clojure.string :only [capitalize]]))
Line 1,527:
(apply str (map-indexed #(format "%2s %-18s %7.2f\n"
(inc (mod %1 32)) (angle2compass %2) %2)
headings)))</langsyntaxhighlight>
Output:
<pre> 1 North 0.00
Line 1,565:
=={{header|COBOL}}==
Works with GnuCOBOL
<langsyntaxhighlight lang=cobol> identification division.
program-id. box-compass.
data division.
Line 1,631:
display compass-point space show-degrees
end-perform
goback.</langsyntaxhighlight>
 
{{out}}
Line 1,673:
=={{header|D}}==
{{trans|Java}}
<langsyntaxhighlight lang=d>import std.stdio, std.string, std.math, std.array;
 
struct boxTheCompass {
Line 1,706:
heading.boxTheCompass, heading);
}
}</langsyntaxhighlight>
{{out}}
<pre>1 North 0
Line 1,743:
 
===Alternative version===
<langsyntaxhighlight lang=d>void main() {
import std.stdio;
 
Line 1,766:
writefln("%2d %18s %6.2f", i + 1, box[i], phi);
}
}</langsyntaxhighlight>
{{out}}
<pre> 1 North 0.00
Line 1,807:
=={{header|Elixir}}==
{{trans|Ruby}}
<langsyntaxhighlight lang=elixir>defmodule Box do
defp head do
Enum.chunk(~w(north east south west north), 2, 1)
Line 1,830:
end
 
Box.compass</langsyntaxhighlight>
 
{{out}}
Line 1,870:
 
=={{header|Euphoria}}==
<langsyntaxhighlight lang=euphoria>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",
Line 1,892:
j = deg2ind(degrees[i])
printf(1, "%6.2f %2d %-22s\n", {degrees[i], j, names[j]})
end for</langsyntaxhighlight>
 
Output:
Line 1,931:
=={{header|F_Sharp|F#}}==
{{trans|Perl}}
<langsyntaxhighlight lang=fsharp>let box = [|
"North"; "North by east"; "North-northeast"; "Northeast by north";
"Northeast"; "Northeast by east"; "East-northeast"; "East by north";
Line 1,947:
|> List.iter (fun phi ->
let i = (int (phi * 32. / 360. + 0.5)) % 32
printf "%3d %18s %6.2f°\n" (i + 1) box.[i] phi)</langsyntaxhighlight>
{{out}}
<pre> 1 North 0.00°
Line 1,984:
 
=={{header|Factor}}==
<langsyntaxhighlight lang=Factor>USING: formatting kernel math sequences ;
 
CONSTANT: box
Line 2,010:
dup 32 * 360 /f 0.5 + >integer 32 mod [ 1 + ] [ box nth ] bi
"%6.2f° %2d %s\n" printf
] each</langsyntaxhighlight>
{{out}}
<pre>
Line 2,050:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<langsyntaxhighlight lang=fortran>Program Compass
implicit none
 
Line 2,087:
compasspoint = points(int(x))
end function compasspoint
end program Compass</langsyntaxhighlight>
Output:
<pre>
Line 2,125:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang=freebasic>' version 04-11-2016
' compile with: fbc -s console
 
Line 2,156:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre> 0.00 0 North
Line 2,194:
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=823a56ac094b8963cf11f792b381fbcc Click this link to run this code]'''
<langsyntaxhighlight lang=gambas>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"]
Line 2,212:
Next
 
End</langsyntaxhighlight>
Output:
<pre>
Line 2,251:
 
=={{header|Go}}==
<langsyntaxhighlight lang=go>package main
 
import "fmt"
Line 2,317:
fmt.Printf("%4d %-19s %7.2f°\n", index, degrees2compasspoint(h), h)
}
}</langsyntaxhighlight>
<pre>
Index Compass point Degree
Line 2,356:
 
=={{header|Groovy}}==
<langsyntaxhighlight lang=groovy>def asCompassPoint(angle) {
def cardinalDirections = ["north", "east", "south", "west"]
 
Line 2,377:
354.37, 354.38].eachWithIndex { angle, index ->
println "${(index % 32) + 1}".padRight(3) + "${angle.asCompassPoint().padLeft(20)} $angle\u00b0"
}</langsyntaxhighlight>
Output:
<pre>1 North 0.0°
Line 2,414:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang=haskell>import Data.Char (toUpper)
 
import Data.Maybe (fromMaybe)
Line 2,483:
 
main :: IO ()
main = mapM_ (printPointName . show) [0 .. 31]</langsyntaxhighlight>
Output:
<pre> 1 North 0.00°
Line 2,520:
 
=={{header|Huginn}}==
<langsyntaxhighlight lang=huginn>import Algorithms as algo;
import Text as text;
 
Line 2,565:
print( "{:2d} | {:6.2f}° | {}\n".format( n, d, c.degrees_to_compasspoint( d ) ) );
}
}</langsyntaxhighlight>
Output:<pre> # | Angle | Compass point
---+---------|-------------------
Line 2,604:
=={{header|Icon}} and {{header|Unicon}}==
{{incomplete|Icon|354.38?}}
<langsyntaxhighlight lang=Icon>link strings,numbers
procedure main()
Line 2,629:
return dirs[round(((((d%360)+360)%360)/11.25)%32 + 1)]
end</langsyntaxhighlight>
 
{{libheader|Icon Programming Library}}
Line 2,669:
 
=={{header|IS-BASIC}}==
<langsyntaxhighlight lang=IS-BASIC>100 PROGRAM "Compass.bas"
110 STRING DR$(1 TO 33)*18
120 FOR I=1 TO 33
Line 2,682:
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</langsyntaxhighlight>
 
Output:<pre> 0 1 North
Line 2,720:
=={{header|J}}==
 
<langsyntaxhighlight lang=j>require'strings'
subs=: 'N,north,S,south,E,east,W,west,b, by ,'
dirs=: subs (toupper@{., }.)@rplc~L:1 0&(<;._2) 0 :0 -. ' ',LF
Line 2,727:
)
indice=: 32 | 0.5 <.@+ %&11.25
deg2pnt=: dirs {~ indice</langsyntaxhighlight>
 
Example use:
 
<langsyntaxhighlight lang=j> 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│
└─────┴─────┴─────┴─────┴─────┴─────┴─────────────┴─────────────┴─────────────┴─────────────┘</langsyntaxhighlight>
 
Required example:
 
<langsyntaxhighlight lang=j> (":@>:@indice,.' ',.>@deg2pnt,.' ',.":@,.)(*&11.25 + 5.62 * 0 1 _1 {~ 3&|) i.33
1 North 0
2 North by east 16.87
Line 2,773:
31 North-northwest 337.5
32 North by west 354.37
1 North 354.38</langsyntaxhighlight>
 
=={{header|Java}}==
{{trans|Visual Basic .NET}}
<langsyntaxhighlight lang=java>public class BoxingTheCompass{
private static String[] points = new String[32];
Line 2,825:
return points[(int)Math.floor(testD % 32)];
}
}</langsyntaxhighlight>
Output:
<pre>1 North 0.0°
Line 2,865:
An iterative, web-based approach:
 
<langsyntaxhighlight lang=javascript>function createRow(i, point, heading) {
var tr = document.createElement('tr'),
td;
Line 2,910:
table.appendChild(tbody);
document.body.appendChild(table);
</syntaxhighlight>
</lang>
Output:
<pre>1 North 0°
Line 2,949:
 
Functional composition, allowing for additional languages (and different numbers of compass points)
<langsyntaxhighlight lang=JavaScript>(() => {
'use strict';
 
Line 3,187:
 
return compassTable(5, xs); // 2^5 -> 32 boxes
})();</langsyntaxhighlight>
 
{{Out}}
Line 3,228:
{{trans|Python}}
 
<langsyntaxhighlight lang=julia>using Printf
 
function degree2compasspoint(d::Float64)
Line 3,250:
i % 3 == 2 && (d -= 5.62)
@printf("%2i %-17s %10.2f°\n", i % 32 + 1, degree2compasspoint(d), d)
end</langsyntaxhighlight>
 
{{out}}
Line 3,290:
The representation of the names was inspired by Tcl (etc.).
 
<langsyntaxhighlight lang=K> 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;")
Line 3,305:
 
/ calculate the degrees
f:{m:x!3;(11.25*x)+:[1=m;+5.62;2=m;-5.62;0]}</langsyntaxhighlight>
The table:
<langsyntaxhighlight lang=K> `0:{((2$(1+x!32))," ",(-19$cc@dd[x]),(6.2$f@x))}'!#dd
1 North 0.00
2 North by east 16.87
Line 3,341:
31 North-northwest 337.50
32 North by west 354.37
1 North 354.38</langsyntaxhighlight>
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang=scala>// version 1.1.2
 
fun expand(cp: String): String {
Line 3,380:
println(f.format(index + 1, heading, expand(cp[index])))
}
}</langsyntaxhighlight>
 
{{out}}
Line 3,424:
{{trans|D}}
{{works with|langur|0.6.13}}
<langsyntaxhighlight lang=langur>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",
Line 3,445:
val .i = truncate(.phi x 32 / 360 + 0.5) rem 32 + 1
writeln $"\.i:5; \.phi:r2:6; \.box[.i];"
}</langsyntaxhighlight>
 
{{out}}
Line 3,486:
 
=={{header|Lasso}}==
<langsyntaxhighlight lang=Lasso>define pointsarray() => {
local(points = array)
loop(-from=0,-to=32) => {
Line 3,537:
#pformatted + ' | ' + (#counter < 10 ? ' ') + #counter + ' | ' + compassLong(compassShort->get(#counter)) + '\r'
^}</langsyntaxhighlight>
 
{{out}}
Line 3,577:
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang=lb>dim point$( 32)
 
for i =1 to 32
Line 3,610:
data "West by south ", "West ", "West by north ", "West-northwest "
data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "
data "North by west</langsyntaxhighlight>
 
Output:
Line 3,649:
=={{header|LLVM}}==
{{trans|C}}
<langsyntaxhighlight lang=llvm>; 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.
Line 3,717:
 
attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
attributes #1 = { argmemonly nounwind }</langsyntaxhighlight>
{{out}}
<pre> 1 North 0.00
Line 3,754:
 
=={{header|Logo}}==
<langsyntaxhighlight lang=logo>; List of abbreviated compass point labels
make "compass_points [ N NbE N-NE NEbN NE NEbE E-NE EbN
E EbS E-SE SEbE SE SEbS S-SE SbE
Line 3,818:
; and exit
bye
</syntaxhighlight>
</lang>
 
Output:
Line 3,858:
=={{header|Lua}}==
{{trans|Logo}}
<langsyntaxhighlight lang=lua>-- List of abbreviated compass point labels
compass_points = { "N", "NbE", "N-NE", "NEbN", "NE", "NEbE", "E-NE", "EbN",
"E", "EbS", "E-SE", "SEbE", "SE", "SEbS", "S-SE", "SbE",
Line 3,906:
label = expand_point(abbr)
print(row_format:format(angle, label, index))
end</langsyntaxhighlight>
 
Output:
Line 3,947:
In a For Next loop we can change loop variable inside block, but the actual loop hidden variable can't change so for next iteration we get the proper value.
 
<langsyntaxhighlight lang=M2000 Interpreter>
Module CheckIt {
Locale 1033 'change decimal point char to dot.
Line 3,975:
}
CheckIt
</syntaxhighlight>
</lang>
 
{{out}}
Line 4,017:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight lang=Mathematica>Map[List[Part[#,1], dirs[[Part[#,1]]], ToString@Part[#,2]<>"°"]&,
Map[{Floor[Mod[ #+5.625 , 360]/11.25]+1,#}&,input] ]//TableForm</langsyntaxhighlight>
<pre>1 North 0.°
2 North by east 16.87°
Line 4,054:
 
=={{header|MATLAB}} / {{header|Octave}}==
<langsyntaxhighlight lang=MATLAB>function b = compassbox(d)
b = ceil(mod(d+360/64,360)*32/360);
end; </langsyntaxhighlight>
Output:
<pre>>> x=[0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]';
Line 4,096:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang=modula2>MODULE BoxTheCompass;
FROM FormatString IMPORT FormatString;
FROM RealStr IMPORT RealToStr;
Line 4,177:
 
ReadChar
END BoxTheCompass.</langsyntaxhighlight>
 
=={{header|MUMPS}}==
The TCL implementation was the starting point, but this isn't an exact translation.
<langsyntaxhighlight lang=MUMPS>BOXING(DEGREE)
;This takes in a degree heading, nominally from 0 to 360, and returns the compass point name.
QUIT:((DEGREE<0)||(DEGREE>360)) "land lubber can't read a compass"
Line 4,214:
. WRITE $PIECE(X,"^"),?5,DIR,?40,$JUSTIFY($PIECE(POINTS,",",P),10,2),!
KILL POINTS,UP,LO,DIR,P,X
QUIT</langsyntaxhighlight>
<p>Output:<pre>
Debugger executing 'BOXWRITE^COMPASS'
Line 4,252:
 
=={{header|NetRexx}}==
<langsyntaxhighlight lang=NetRexx>/* NetRexx */
options replace format comments java crossref savelog symbols nobinary utf8
 
Line 4,453:
 
return table
</syntaxhighlight>
</lang>
 
;Output
Line 4,528:
 
=={{header|Nim}}==
<langsyntaxhighlight lang=nim>import math, sequtils, strformat, strutils
 
const
Line 4,557:
index = heading.toCompassIndex
compassHeading = heading.toCompassHeading.alignLeft(maxNameLength)
echo fmt"{index:>2} {compassHeading} {heading:6.2f}"</langsyntaxhighlight>
Output:
<pre> 1 North 0.00
Line 4,594:
 
=={{header|Objeck}}==
<langsyntaxhighlight lang=objeck>
class BoxCompass {
function : Main(args : String[]) ~ Nil {
Line 4,629:
}
}
</syntaxhighlight>
</lang>
 
Output
Line 4,669:
 
=={{header|OCaml}}==
<langsyntaxhighlight lang=ocaml>
let test_cases = [0.0; 16.87; 16.88; 33.75; 50.62; 50.63; 67.5;
84.37; 84.38; 101.25; 118.12; 118.13; 135.0;
Line 4,702:
List.iter (print_direction) test_cases;;
 
</syntaxhighlight>
</lang>
Sample output:
<pre>
Line 4,741:
 
=={{header|OoRexx}}==
<langsyntaxhighlight lang=OOREXX>/* Rexx */
 
Do
Line 5,000:
End
Exit
</syntaxhighlight>
</lang>
 
;Output
Line 5,074:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang=parigp>box(x)={["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",
Line 5,080:
"West by south","West","West by north","West-northwest","Northwest by west","Northwest",
"Northwest by north","North-northwest","North by west"][round(x*4/45)%32+1]};
for(i=0,32,print(i%32+1" "box(x=i*11.25+if(i%3==1,5.62,if(i%3==2,-5.62)))" "x))</langsyntaxhighlight>
 
Output:
Line 5,119:
=={{header|Pascal}}==
{{trans|Fortran}}
<langsyntaxhighlight lang=pascal>program BoxTheCompass(output);
 
function compasspoint(angle: real): string;
Line 5,155:
writeln((i mod 32) + 1:2, ' ', compasspoint(heading), ' ', heading:8:4);
end;
end.</langsyntaxhighlight>
Output:
<pre>
Line 5,196:
=={{header|Perl}}==
Don't waste brain cells calculating names, not worth the effort. Code is probably shorter, faster, and easier to read this way.
<langsyntaxhighlight lang=Perl>use utf8;
 
my @names = (
Line 5,240:
my $i = int(($_ * 32 / 360) + .5) % 32;
printf "%3d %18s %6.2f°\n", $i + 1, $names[$i], $_;
}</langsyntaxhighlight>output<syntaxhighlight lang=text> 1 North 0.00°
2 North by east 16.87°
3 North-northeast 16.88°
Line 5,272:
31 North-northwest 337.50°
32 North by west 354.37°
1 North 354.38°</langsyntaxhighlight>
 
=={{header|Phix}}==
Unlike the Perl guy, for me the maths is the boring bit, building those strings is the fun!<br>
<!--<langsyntaxhighlight lang=Phix>(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">get225</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">d</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p2</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">p4</span><span style="color: #0000FF;">)</span>
Line 5,323:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_point</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
If you like, you can regard d=1 (both of them) as "clockwise-name-inherit" and d=0 as "anti-clockwise-name-inherit".<br>
{{out}}
Line 5,362:
</pre>
of course the following (more sensible but less fun, full standalone program) way works just as well, and produces the same output
<!--<langsyntaxhighlight lang=Phix>(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">compass_points</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span> <span style="color: #008000;">"North"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North by east"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"North-northeast"</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"Northeast by north"</span><span style="color: #0000FF;">,</span>
Line 5,379:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%2d %-22s %6.2f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">compass_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">compass_point</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">test_points</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
 
=={{header|Picat}}==
{{trans|Nim}}
<langsyntaxhighlight lang=Picat>go =>
Names = ["North", "North by east", "North-northeast", "Northeast by north",
"Northeast", "Northeast by east", "East-northeast", "East by north",
Line 5,400:
printf("%2d %-20s %6.2f\n", J+1, Names[J+1], D)
end,
nl.</langsyntaxhighlight>
 
{{out}}
Line 5,438:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight lang=PicoLisp>(scl 3)
 
(setq *Compass # Build lookup table
Line 5,471:
NIL
(cdr (heading H))
(round H 2) ) ) )</langsyntaxhighlight>
Output:
<pre> 1 north 0.00
Line 5,508:
 
=={{header|PowerShell}}==
<langsyntaxhighlight lang=powershell>function Convert-DegreeToDirection ( [double]$Degree )
{
Line 5,523:
$x = 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62, 185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38
$x | % { Convert-DegreeToDirection -Degree $_ }</langsyntaxhighlight>
{{out}}
<pre>north
Line 5,559:
north</pre>
A more general solution allowing you to choose whether to use 4, 8, 16, or 32 compass points.
<langsyntaxhighlight lang=powershell>function Convert-DegreeToDirection ( [double]$Degree, [int]$Points )
{
Line 5,581:
8 = ( Convert-DegreeToDirection -Degree $Degree -Points 8 )
4 = ( Convert-DegreeToDirection -Degree $Degree -Points 4 ) } }
$Values | Format-Table</langsyntaxhighlight>
{{out}}
<pre>Degree 32 16 8 4
Line 5,621:
=={{header|Prolog}}==
Part 1 : The following knowledge base takes a heading in degrees and returns the correct 32-point compass heading. It can also go in the other direction.
<langsyntaxhighlight lang=prolog>
compassangle(1, 'North',n, 0.00).
compassangle(2, 'North by east', nbe, 11.25).
Line 5,659:
 
resolveindex(Angle, Index) :- N is Angle / 11.25 + 0.5, I is floor(N),Index is (I mod 32) + 1.
</syntaxhighlight>
</lang>
Part 2 : The following rules print a table of indexes.
<langsyntaxhighlight lang=prolog>
printTableRow(Angle) :- compassangle(Index, Name, _, Angle),
write(Index), write(' '),
Line 5,669:
printTable([X|Xs]) :- printTableRow(X), nl, printTable(Xs),!.
printTable([]).
</syntaxhighlight>
</lang>
The following query prints the required table.
<langsyntaxhighlight lang=prolog>
?- printTable([0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37, 84.38, 101.25, 118.12, 118.13, 135.0, 151.87, 151.88, 168.75, 185.62,
185.63, 202.5, 219.37, 219.38, 236.25, 253.12, 253.13, 270.0, 286.87, 286.88, 303.75, 320.62, 320.63, 337.5, 354.37, 354.38]).
Line 5,708:
1 North 354.38
true.
</syntaxhighlight>
</lang>
 
=={{header|PureBasic}}==
<langsyntaxhighlight lang=PureBasic>DataSection
Data.s "N", "north", "E", "east", "W", "west", "S", "south", "b", " by " ;abbreviations, expansions
Data.s "N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE" ;dirs
Line 5,783:
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</langsyntaxhighlight>
Sample output:
<pre> 1 North 0.00
Line 5,820:
 
=={{header|Python}}==
<langsyntaxhighlight lang=python>majors = 'north east south west'.split()
majors *= 2 # no need for modulo later
quarter1 = 'N,N by E,N-NE,NE by N,NE,NE by E,E-NE,E by N'.split(',')
Line 5,844:
elif m == 2: d -= 5.62
n = i % 32 + 1
print( '%2i %-18s %7.2f°' % (n, degrees2compasspoint(d), d) )</langsyntaxhighlight>
 
;Output
Line 5,886:
{{works with|QuickBasic|4.5}}
{{trans|Liberty BASIC}}
<langsyntaxhighlight lang=qbasic>DECLARE FUNCTION compasspoint$ (h!)
 
DIM SHARED point$(32)
Line 5,919:
IF (x >= 33!) THEN x = x - 32!
compasspoint$ = point$(INT(x))
END FUNCTION</langsyntaxhighlight>
 
 
Line 5,926:
R (also known as Arrr me hearties!) is ideally suited to this task. Here's an easy to understand but inefficient way to solve it:
 
<langsyntaxhighlight lang=rsplus>
# Build a table of directions
pts <- data.frame(
Line 5,947:
res[1,]$des[1]
})
</syntaxhighlight>
</lang>
 
Here are the test inputs:
 
<langsyntaxhighlight lang=rsplus>
test <- data.frame(
deg = c( 0.0, 16.87, 16.88, 33.75, 50.62, 50.63, 67.5, 84.37,
Line 5,962:
test$heading <- heading(test$deg)
test
</syntaxhighlight>
</lang>
 
Check that the output headings cover the full range of headings:
 
<syntaxhighlight lang=R>
<lang R>
all.equal(test$heading, pts$des)
</syntaxhighlight>
</lang>
 
{{out}}
Line 6,013:
 
=={{header|Racket}}==
<langsyntaxhighlight lang=racket>#lang racket
 
;;; Generate the headings and boxes
Line 6,067:
(check-= (heading->box 5.62) 1 0)
(check-= (heading->box 5.63) 2 0)
(check-= (heading->box 16.87) 2 0))</langsyntaxhighlight>
 
Output:
Line 6,109:
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang=raku perl6line>sub point (Int $index) {
my $ix = $index % 32;
if $ix +& 1
Line 6,130:
𝜽,
tc point angle-to-point 𝜽;
}</langsyntaxhighlight>
 
Output:
Line 6,167:
1 354.38° North</pre>
=={{header|Red}}==
<langsyntaxhighlight lang=Rebol>Red []
 
d: charset [#"N" #"E" #"S" #"W"] ;; main directions
Line 6,189:
hm/:heading: reduce [ (i % 32 + 1 ) expand to-string compass-points/1 [N north b " by " S south E east W west] ]
print-line heading
]</langsyntaxhighlight>
'''output'''
<pre>
Line 6,229:
=={{header|REXX}}==
This version does normalization of the (degree) heading and can also handle negative headings.
<langsyntaxhighlight lang=rexx>/*REXX program "boxes the compass" [from degree (º) headings ───► a 32 point set]. */
parse arg $ /*allow º headings to be specified.*/
if $='' then $= 0 16.87 16.88 33.75 50.62 50.63 67.5 84.37 84.38 101.25 118.12 118.13 ,
Line 6,257:
z= changestr( left(d, 1), z, d)
end /*k*/ /* [↑] old, haystack, new*/
return changestr('b', z, " by ") /*expand "b" ───► " by ".*/</langsyntaxhighlight>
Some older REXXes don't have a &nbsp; '''changestr''' &nbsp; BIF, &nbsp; so one is included here &nbsp; ──► &nbsp; [[CHANGESTR.REX]].
<br><br>
Line 6,300:
 
=={{header|Ring}}==
<langsyntaxhighlight lang=ring>
# Project : Box the compass
 
Line 6,330:
ok
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 6,370:
=={{header|Ruby}}==
 
<langsyntaxhighlight lang=ruby>Headings = %w(north east south west north).each_cons(2).flat_map do |a, b|
[a,
"#{a} by #{b}",
Line 6,393:
index, name = heading degrees
printf "%2d %20s %6.2f\n", index, name.center(20), degrees
end</langsyntaxhighlight>
 
{{output}}
Line 6,431:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang=runbasic>global direct$
dim direct$(22)
direct$(1) = "y" 'by
Line 6,467:
data "N","N b e","N-ne","Ne b n","Ne","Ne b e","E-ne","E b n","E","E b s","E-se"
data "Se b e","Se","Se b s","S-se","S b e","S","S b w","S-sw","Sw b s","Sw","Sw b w"
data "W-sw","W b s","W","W b n","W-nw","Nw b w","Nw","Nw b n","N-nw","N b w"</langsyntaxhighlight>
<code><table border=1>
<TR><TD align=right>1</td><td>North</td><td>0.0</td></tr>
Line 6,507:
=={{header|Rust}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang=Rust>fn expand(cp: &str) -> String {
let mut out = String::new();
for c in cp.chars() {
Line 6,546:
);
}
}</langsyntaxhighlight>
{{out}}
<pre>Index Degrees Compass point
Line 6,586:
=={{header|Scala}}==
Inspired by Java version
<langsyntaxhighlight lang=Scala>object BoxingTheCompass extends App {
val cardinal = List("north", "east", "south", "west")
val pointDesc = List("1", "1 by 2", "1-C", "C by 1", "C", "C by 2", "2-C", "2 by 1")
Line 6,607:
(0 to 32).map(i=>Triple(pointDeg(i),deg2ind(pointDeg(i)),pointName(deg2ind(pointDeg(i)))))
.map{t=>(printf("%s\t%18s\t%s°\n",t._2,t._3,t._1))}
}</langsyntaxhighlight>
 
Output:
Line 6,647:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang=seed7>$ include "seed7_05.s7i";
include "float.s7i";
 
Line 6,670:
degrees[index] digits 2 lpad 6);
end for;
end func;</langsyntaxhighlight>
 
Output:
Line 6,711:
=={{header|Sidef}}==
{{trans|Raku}}
<langsyntaxhighlight lang=ruby>func point (index) {
var ix = (index % 32);
if (ix & 1) { "#{point((ix + 1) & 28)} by #{point(((2 - (ix & 2)) * 4) + ix & 24)}" }
Line 6,725:
var 𝜽 = test_angle(ix);
printf(" %2d %6.2f° %s\n", ix % 32 + 1, 𝜽, point(angle_to_point(𝜽)).tc);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 6,764:
 
=={{header|smart BASIC}}==
<langsyntaxhighlight lang=smart BASIC>/*Boxing The Compass by rbytes December 2017*/
GET SCREEN SIZE sw,sh
OPTION BASE 1
Line 6,800:
DATA "Northwest", "NW", "309.38", "315.00", "320.62", "Northwest by north", "NWbN", "320.63", "326.25", "331.87"
DATA "North-northwest", "NNW", "331.88", "337.50", "343.12", "North by west", "NbW", "343.13", "348.75", "354.37"
</syntaxhighlight>
</lang>
Output:
<pre>
Line 6,841:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang=tcl>proc angle2compass {angle} {
set dirs {
N NbE N-NE NEbN NE NEbE E-NE EbN E EbS E-SE SEbE SE SEbS S-SE SbE
Line 6,867:
# Pretty-print the results of converting an angle to a compass heading
puts [format "%2i %-18s %7.2f°" $index [angle2compass $heading] $heading]
}</langsyntaxhighlight>
Output:
<pre>
Line 6,907:
=={{header|True BASIC}}==
{{trans|QBasic}}
<langsyntaxhighlight lang=qbasic>DIM point$(32)
 
FUNCTION compasspoint$ (h)
Line 6,940:
PRINT ind, compasspoint$(heading), heading
NEXT i
END</langsyntaxhighlight>
 
=={{header|uBasic/4tH}}==
{{trans|C}}
Since uBasic is an integer interpreter, we have to do some scaling to perform this task.
<syntaxhighlight lang=text>Push 0, 1687, 1688, 3375, 5062, 5063, 6750, 8437, 8438, 10125, 11812, 11813
Push 13500, 15187, 15188, 16875, 18562, 18563, 20250, 21937, 21938, 23625
Push 25312, 25313, 27000, 28687, 28688, 30375, 32062, 32063, 33750, 35437
Line 6,998:
400 Print "North-northwest "; : Return
410 Print "North by west "; : Return
420 Print "North "; : Return</langsyntaxhighlight>
{{out}}
<pre>
Line 7,044:
Requires the standard POSIX bc(1) command to perform floating-point arithmetic.
 
<langsyntaxhighlight lang=sh># List of abbreviated compass point labels
compass_points=( N NbE N-NE NEbN NE NEbE E-NE EbN
E EbS E-SE SEbE SE SEbS S-SE SbE
Line 7,093:
label="$(expand_point $abbr)"
printf "$row_format" $angle "$label" $index
done</langsyntaxhighlight>
 
Output: <pre>Degrees | Closest Point | Index
Line 7,132:
 
=={{header|VBA}}==
<langsyntaxhighlight lang=vb>Public Sub box_the_compass()
Dim compass_point As Integer
Dim compass_points_all As New Collection
Line 7,165:
Debug.Print test_points_all(i)
Next i
End Sub</langsyntaxhighlight>{{out}}
<pre> 1 North 0
2 North by east 16,87
Line 7,202:
=={{header|Visual Basic .NET}}==
 
<langsyntaxhighlight lang=vbnet>Module BoxingTheCompass
Dim _points(32) As String
 
Line 7,248:
End Function
End Module
</syntaxhighlight>
</lang>
Output:
<pre>
Line 7,289:
{{trans|Go}}
{{libheader|Wren-fmt}}
<langsyntaxhighlight lang=ecmascript>import "/fmt" for Fmt
 
// 'cpx' returns integer index from 0 to 31 corresponding to compass point.
Line 7,354:
System.print("%(Fmt.d(4, index)) %(Fmt.s(-19, d)) %(Fmt.f(7, h, 2))°")
i = i + 1
}</langsyntaxhighlight>
 
{{out}}
Line 7,396:
=={{header|Yabasic}}==
{{trans|Liberty BASIC}}
<langsyntaxhighlight lang=Yabasic>
dim point$(32)
Line 7,433:
70 data "West by south ", "West ", "West by north ", "West-northwest "
80 data "Northwest by west ", "Northwest ", "Northwest by north", "North-northwest "
90 data "North by west "</langsyntaxhighlight>
 
=={{header|zkl}}==
{{trans|AWK}}
<langsyntaxhighlight lang=zkl>A:=("X N NbE NNE NEbN NE NEbE ENE EbN E EbS ESE " // one based array
"SEbE SE SEbS SSE SbE S SbW SSW SWbS SW SWbW "
"WSW WbS W WbN WNW NWbW NW NWbN NNW NbW").split(" ");
Line 7,453:
box:=compassBox(heading);
println("%6.2f\UB0; : %2d\t%s".fmt(heading,box,A[box]));
}</langsyntaxhighlight>
{{out}}
<pre>
Line 7,469:
=={{header|ZX Spectrum Basic}}==
{{trans|Liberty BASIC}}
<langsyntaxhighlight lang=zxbasic>10 DATA "North","North by east","North-northeast"
20 DATA "Northeast by north","Northeast","Northeast by east","East-northeast"
30 DATA "East by north","East","East by south","East-southeast"
Line 7,495:
250 STOP
260 DEF FN m(i,n)=((i/n)-INT (i/n))*n : REM modulus function
</syntaxhighlight>
</lang>
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327156"