Horizontal sundial calculations: Difference between revisions

{{trans|Python}}

 

V lng = Float(input(‘Enter longitude => ’))

V ref = Float(input(‘Enter legal meridian => ’))

hra -= lng - ref

V hla = degrees(atan(slat * tan(radians(hra))))

 

{{out}}

{{trans|ALGOL 68}}

sundial.adb:

with Ada.Numerics.Elementary_Functions;

procedure Sundial is

end;

end loop;

{{out}}

<pre>Enter latitude: -4.95

> Simon

-->

REAL lat, slat, lng, ref;

print ( "Enter latitude => " ); read (lat);

new line(stand out)

OD

{{out}}

<pre>

{{trans|F#}}

AutoHotkey is not a command-line programming language, let me make that clear. However, in translating the F# I found that the command line really is best for this type of app. The first 3 comments in the script describe the workarounds used to interface with the commandline.

Pi := 4*ATan(1)

,Degrees := Pi/180

FileAppend, %clockhour%`t`t%shr%`t`t%dhla%`n, CONOUT$

}

{{out}}

<pre>Enter Latitude:-4.95

 

=={{header|AWK}}==

# syntax: GAWK -f HORIZONTAL_SUNDIAL_CALCULATIONS.AWK

BEGIN {

function dr(x) { return x * 3.14159265 / 180 } # degrees to radians

function rd(x) { return x * 180 / 3.14159265 } # radians to degrees

<p>output:</p>

<pre>

{{works with|QBasic}}

{{trans|ALGOL-68}}

10 REM Horizontal sundial calculations

20 DEF FNM(X) = INT(X*1000+0.5)/1000

240 NEXT H

250 END

 

==={{header|BASIC256}}===

end

 

print time; ap$; chr(9); hra; chr(9); chr(9); hla

next hora

 

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

LET rad2deg = theta*180/PI

END FUNCTION

PRINT USING "## ####.## ####.###": hora, hra, hla

NEXT hora

 

==={{header|Yabasic}}===

end

 

print time using "##", ap$, chr$(9), hra using "####.##", chr$(9), chr$(9), hla using "####.###"

next hour

 

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

INPUT "Enter latitude (degrees) : " latitude

IF ABS(hra) > 90 hla += 180 * SGN(hra * latitude)

PRINT FNusing("##.##", hour), FNusing(" ####.### ", hra), FNusing(" ####.###", hla)

{{out}}

(note the correct '''negative''' value for time 18:00)

=={{header|C}}==

{{trans|ALGOL 68}}

#include <math.h>

 

 

return 0;

 

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

 

namespace RosettaCode

}

}

 

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

#include <iostream>

#include <numbers>

}

}

{{out}}

<pre>

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

 

DATA DIVISION.

dial-hour-line-angle-disp

END-PERFORM

 

{{out}}

=={{header|D}}==

{{trans|Python}}

 

double radians(in double x) pure nothrow { return x * (PI / 180); }

writefln("HR=%3d; HRA=%7.3f; HLA=%7.3f", h, hra, hla);

}

{{out|Example run}}

<pre>Enter latitude => -4.95

=={{header|DWScript}}==

{{trans|Java}}

begin

PrintLn(Format('latitude: %7.2f', [lat]));

end;

 

{{out}}

<pre>latitude: -4.95

 

=={{header|EasyLang}}==

write s$

v = number input

hla = atan2 (slat * sin hra) cos hra

print h + 12 & "\t" & hra & "\t\t" & hla

 

=={{header|ERRE}}==

 

FUNCTION RAD(X)

 

END PROGRAM

{{out}}

<pre>

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

include std/mathcons.e

 

if getc(0) then end if

{{out}}

<pre>

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

{{trans|C#}}

 

open System

//To keep the console window open, can be omitted with block comment (" (* comment *) ")

Console.WriteLine("Press any key to continue...")

{{out|Example output}}

<pre>

=={{header|Factor}}==

{{trans|Java}}

math.parser math.ranges math.trig sequences ;

IN: rosetta-code.sundial

: sundial-demo ( -- ) get-input nl 3dup .diff nl .angles ;

 

{{out}}

<pre>

 

=={{header|Forth}}==

pad 32 accept pad swap >float 0= throw ;

: >radians ( deg -- rad ) 180e f/ pi f* ;

fdup f. ." , "

>radians fsincos fswap frot f* fswap fatan2 >degrees f.

 

=={{header|Fortran}}==

{{works with|gfortran}} with <tt>-fbackslash</tt> option

 

real :: lat, slat, lng, ref

end function rd

 

 

=={{header|FreeBASIC}}==

{{trans|BBC BASIC}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> Enter latitude (degrees): -4.95

 

=={{header|FutureBasic}}==

 

def fn rad2deg( theta as double ) as double = theta * 180 / pi

fn SolarHourAngle( -4.95, -150.5, -150.0 )

 

 

Output:

 

=={{header|Go}}==

 

import (

fmt.Printf("%2.0f %8.3f %8.3f\n", h, hra, hla)

}

{{out}}

<pre>

{{trans|ALGOL 68}}

{{works with|PC-BASIC|any}}

10 ' Horizontal sundial calculations

20 PRINT "Enter latitude => ";

220 NEXT H%

230 END

{{out}}

<pre>

 

=={{header|Haskell}}==

roundDec d = (/ 10.0 ^ d) . fromIntegral . round . (* 10.0 ^ d)

 

take 16 (show (roundDec 3 sha) ++ repeat ' ') ++

" " ++ show (roundDec 3 dhla))

{{out}}

<pre>*Rosetta.HorSunDial> main

 

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

PrintSundial(-4.95, -150.5, -150);

end

" HRA=",hra,", HLA=",hla)

}

{{out}}

<pre>latitude: -4.95

 

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

110 OPTION ANGLE RADIANS

120 TEXT 80

230 LET HLA=ATN(S*TAN(HRA*DR))*RD

240 PRINT "HR = ";H,"HRA =";HRA,"HLA =";HLA

 

=={{header|J}}==

atan2=: {:@*.@j. NB. arc tangent of y divided by x

r=.((,. (,. (atan2 *&slat)/@+.@r.&.rfd)) diff + 15&*) i:6

smoutput lbl ,: ('3.0';'7.3';'7.3') 8!:1 r

{{out|Example}}

Latitude _4.95

Longitude _150.5

│ 5 │ 75.500 │-18.451 │

│ 6 │ 90.500 │-95.775 │

 

=={{header|Java}}==

{{trans|C}} (Substitutes in atan2 for the hour line angle calculation)

 

public class Sundial {

}

}

{{out}}

<pre>Enter latitude: -4.95

=={{header|Julia}}==

{{trans|Python}}

print("Enter latitude => ")

lat = parse(Float64, readline(STDIN))

@printf "HR = %3d; HRA = %7.3f; HLA = %7.3f\n" h hra hla

end

 

{{out}}

 

=={{header|Kotlin}}==

import java.lang.Math.cos

import java.lang.Math.sin

println("%2d %s %+7.3f %+7.3f".format(hr, am, sha, dhla))

}

Sample input/output:

{{out}}

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

Based on Algol & BBC BASIC versions. Note Liberty BASIC works in radians.

pi = 3.14159265

input "Enter latitude (degrees) : "; latitude ' -4.95

function sgn(x)

if x > 0 then sgn = 1 else sgn = -1

{{out}}

<pre>

=={{header|LiveCode}}==

Translation of BASIC versions.

ask "Enter lng,lat,meridian"

if it is empty then exit mouseup

function sgn x

if x >0 then return 1 else return -1

 

=={{header|Logo}}==

make "lat readword

type "|Enter longitude: |

make "hla arctan product sin :lat quotient sin :hra cos :hra

print (sentence "hour :hour ": :hra ", :hla)

 

=={{header|Lua}}==

{{trans|Python}}

lat = tonumber(io.read())

 

hla = math.deg(math.atan(slat * math.tan(math.rad(hra))))

print(string.format("HR=%3d; HRA=%7.3f; HLA=%7.3f", h, hra, hla))

 

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

lng = Input["longitude", -150.5];

ref = Input["legal meridian", -150];

{h, -6, 6}

] // Prepend[{"Hour", "Sun hour angle",

{{out}}

<pre>Hour Sun hour angle Dial hour line angle

=={{header|Microsoft Small Basic}}==

{{trans|ALGOL-68}}

TextWindow.Write("Enter latitude => ")

lat = TextWindow.ReadNumber()

TextWindow.WriteLine("")

EndFor

{{out}}

 

 

=={{header|МК-61/52}}==

6 /-/ П3

ИП3 1 5 * ИП1 ИП2 - - П4

tg ИП0 * arctg ИП4 ИП3 С/П

ИП3 1 + П3 7 - x=0 12

 

''Input'': ''latitude'' ^ ''longitude'' ^ ''legal meridian'' С/П ... С/П ...; switch of the angle measure set to ''Г''.

{{trans|ALGOL-68}}

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE SunDial;

 

END;

END SunDial.

{{out}}

Enter latitude => -4.95

=={{header|newLISP}}==

{{trans|Lua}}

(define (radians degrees) (mul degrees (div pi 180)))

(define (degrees radians) (mul radians (div 180 pi)))

)

 

 

=={{header|Nim}}==

{{trans|Python}}

let lat = parseFloat readLineFromStdin "Enter latitude => "

let hra = float(15 * h) - lng + med

let hla = arctan(slat * tan(hra.degToRad)).radToDeg

 

{{out}}

=={{header|Objeck}}==

{{trans|C#}}

class Sundial {

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

}

}

 

=={{header|OCaml}}==

{{trans|ALGOL 68}}

let pi = 4. *. atan 1. in

print_endline "Enter latitude => ";

Printf.printf "HR= %3d; \t HRA=%7.3f; \t HLA= %7.3f\n" h hra hla;

done

{{out}}

<pre>

 

=={{header|Octave}}==

lng = input("Enter longitude: ");

ref = input("Enter legal meridian: ");

hlas = atand( tand(hras) .* slat );

printf("HR= %3d; \t HRA=%7.3f; \t HLA= %7.3f\n",

 

=={{header|OoRexx}}==

{{trans|REXX}}

/* Use trigonometric functions provided by rxCalc */

parse arg lat lng mer . /*get the optional arguments from the CL*/

sep: say indent copies('-',w1) copies('-',w2) copies('-',w3)

Return

{{out}}

Not the same as for REXX anymore as the REXX computer programming example has been updated.

 

=={{header|Pascal}}==

 

Const

tab, ' HLA= ', hla:7:3)

end

 

=={{header|Perl}}==

{{trans|Raku}}

binmode STDOUT, ":utf8";

 

printf "%2d %s %8.3f %8.3f\n",

($hour + 12) % 12 || 12, ($hour < 0 ? 'AM' : 'PM'), $sun_deg, $line_deg;

{{out}}

<pre>Enter latitude => -4.95

=={{header|Phix}}==

For better behaviour/proper input on pwa/p2js I suppose this should really be a pGUI app.

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

<span style="color: #008080;">function</span> <span style="color: #000000;">prompt</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">text</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">v</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%3d:00%s %12.3f %17.3f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">hour12</span><span style="color: #0000FF;">,</span><span style="color: #000000;">am</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ha</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hla</span><span style="color: #0000FF;">})</span>

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

{{out}}

<pre>

=={{header|PicoLisp}}==

{{trans|ALGOL 68}}

 

(de prompt (Str . Arg)

(align 8 (round Hra))

"; HLA="

{{out}}

<pre>Enter latitude => -4.95

 

=={{header|PowerShell}}==

function Get-Sundial

{

$sundial | Select-Object -Property "Sine of Latitude", "Longitude Difference" | Format-List

$sundial.Hours | Format-Table -AutoSize

{{Out}}

<pre>

=={{header|PureBasic}}==

{{trans|ALGOL 68}}

Define.f lat, slat, lng, ref

Define.i h

Next

{{out}}

<pre>Enter latitude => -4.95

=={{header|Python}}==

{{trans|ALGOL 68}}

import math

try: raw_input

hra -= lng - ref

hla = math.degrees(math.atan(slat * math.tan(math.radians(hra))))

{{out}}

<pre>

Also, I apologize for the length; I added quite a bit of commenting, and I peeled things out into functions so I could test them. Hopefully, the result--though longer--is also more readable.

 

 

;; print the table for a given latitude and longitude-offset,

(check-= (to-hla -30 90) -90 1e-5)

(check < (to-hla -30 91) -90)

{{Out}}

<pre>Welcome to DrRacket, version 5.3.3.5--2013-02-20(5eddac74/d) [3m].

=={{header|Raku}}==

(formerly Perl 6)

sub postfix:<®> ($a) { $a * 180 / pi } # radians to degrees

 

printf "%2d %s %7.3f %7.3f\n",

($hour + 12) % 12 || 12, ($hour < 0 ?? 'AM' !! 'PM'), $sun_deg, $line_deg;

{{out|Example output}}

<pre>

 

No attempt was made to explain the inner workings of the trigonometric functions.

numeric digits length( pi() ) - length(.) /*in case sundial is in polar regions. */

parse arg lat lng . /*obtain optional arguments from the CL*/

m.=9; numeric form; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g*.5'e'_ % 2

do j=0 while h>9; m.j= h; h= h % 2 + 1; end /*j*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Horizontal sundial calculations

 

see "" + hour + " " + hra + " " + hla + nl

next

Output:

<pre>

{{trans|ALGOL 68}}

{{trans|Python}}

DtoR = PI/180

 

hla = atan( slat * tan( hra * DtoR ))/ DtoR

puts "HR =%3d; HRA =%7.3f; HLA =%7.3f" % [h, hra, hla]

{{out}}

<pre>

 

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

pi = 22 / 7

if x >0 then sgn =1 else sgn =-1

end function

{{out}}

<pre>

 

=={{header|Rust}}==

use std::io;

struct SundialCalculation {

}

 

{{out}}

<pre>

 

=={{header|Sather}}==

 

getvalue(s:STR):FLT is

end;

end;

 

=={{header|Scala}}==

 

import scala.math.{atan2, cos, sin, toDegrees, toRadians}

}

 

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

"; HLA= " <& hla digits 3 lpad 7);

end for;

{{out}}

<pre>Enter latitude: -4.95

=={{header|Sidef}}==

{{trans|Raku}}

var longitude = read('Enter longitude => ', Number)

var meridian = read('Enter legal meridian => ', Number)

printf("%2d %s  %7.3f  %7.3f\n",

(hour + 12) % 12 || 12, (hour < 0 ? 'AM' : 'PM'), sun_deg, line_deg)

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

pi := 1 arcTan * 4.

'Enter latitude: ' display. lat := stdin nextLine asNumber.

hla := (hra degreesToRadians tan * slat) arcTan radiansToDegrees.

('HR= %1; %4 HRA=%2; %4 HLA= %3' % { h. hra. hla. $<9> }) displayNl.

 

=={{header|Tcl}}==

{{trans|ALGOL 68}}

fconfigure stdout -buffering none

puts -nonewline "Enter latitude => "; gets stdin lat

set hla [expr {atan($slat * tan($hra*$PI/180)) * 180/$PI}]

puts [format "HR=%+3d; HRA=%+8.3f; HLA=%+8.3f" $h $hra $hla]

{{out|Sample output}}

<pre>

{{trans|Go}}

{{libheader|Wren-fmt}}

import "/fmt" for Fmt

 

var hla = (slat*s).atan(c) * 180 / Num.pi

Fmt.print("$2.0f $8.3f $8.3f", h, hra, hla)

 

{{out}}

{{libheader|libc}}

It must be linked with the C standard library and startup code.

extern printf, scanf

 

 

o_ft:

 

=={{header|XBasic}}==

{{trans|ALGOL-68}}

{{works with|Windows XBasic}}

PROGRAM "sundial"

VERSION "0.0001"

END FUNCTION

END PROGRAM

{{out}}

<pre>

 

=={{header|XPL0}}==

def Pi = 3.14159265358979323846,

Deg2Rad = Pi/180.0,

RlOut(0, HA); ChOut(0, Tab); RlOut(0, HLA); CrLf(0);

];

 

{{out}}

=={{header|zkl}}==

{{trans|F#}}

//(radian measure)/Degrees => Degree measure

const pi=(0.0).pi, toDeg=(0.0).pi/180;

dhla :=(sineLatitude*(shr*toDeg).tan()).atan()/toDeg;

Console.writeln("%s\t\t%5.1f\t\t%+7.3f".fmt(clockHour,shr,dhla));

{{out}}

<pre>

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

{{trans|ERRE}}

20 DEF FN d(x)=x*180/PI

30 INPUT "Enter latitude (degrees): ";latitude

150 IF ABS (hra)>90 THEN LET hla=hla+180*SGN (hra*latitude)

160 PRINT h;" ";hra;" ";hla