func ExampleApproxPlanet() { // Example 15.a, p. 103. p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } e, err := pp.LoadPlanet(pp.Earth) if err != nil { fmt.Println(err) return } v, err := pp.LoadPlanet(pp.Venus) if err != nil { fmt.Println(err) return } tRise, tTransit, tSet, err := rise.ApproxPlanet(1988, 3, 20, p, e, v) if err != nil { fmt.Println(err) return } // Units for "m" values given near top of p. 104 are day fraction. fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // rising: +0.51816 12ʰ26ᵐ09ˢ // transit: +0.81965 19ʰ40ᵐ17ˢ // seting: +0.12113 02ʰ54ᵐ26ˢ }
func ExamplePlanet() { // Example 15.a, p. 103. p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } e, err := pp.LoadPlanet(pp.Earth) if err != nil { fmt.Println(err) return } v, err := pp.LoadPlanet(pp.Venus) if err != nil { fmt.Println(err) return } tRise, tTransit, tSet, err := rise.Planet(1988, 3, 20, p, e, v) if err != nil { fmt.Println(err) return } fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // rising: +0.51766 12ʰ25ᵐ26ˢ // transit: +0.81980 19ʰ40ᵐ30ˢ // seting: +0.12130 02ʰ54ᵐ40ˢ }
func ExampleApproxTimes() { // Example 15.a, p. 103. // Venus on 1988 March 20 p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } Th0 := unit.NewTime(' ', 11, 50, 58.1) α := unit.NewRA(2, 46, 55.51) δ := unit.NewAngle(' ', 18, 26, 27.3) h0 := rise.Stdh0Stellar tRise, tTransit, tSet, err := rise.ApproxTimes(p, h0, Th0, α, δ) if err != nil { fmt.Println(err) return } // Units for "m" values given near top of p. 104 are day fraction. fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // rising: +0.51816 12ʰ26ᵐ09ˢ // transit: +0.81965 19ʰ40ᵐ17ˢ // seting: +0.12113 02ʰ54ᵐ26ˢ }
func ExampleTimes() { // Example 15.a, p. 103. // Venus on 1988 March 20 p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } Th0 := unit.NewTime(' ', 11, 50, 58.1) α3 := []unit.RA{ unit.NewRA(2, 42, 43.25), unit.NewRA(2, 46, 55.51), unit.NewRA(2, 51, 07.69), } δ3 := []unit.Angle{ unit.NewAngle(' ', 18, 02, 51.4), unit.NewAngle(' ', 18, 26, 27.3), unit.NewAngle(' ', 18, 49, 38.7), } h0 := unit.AngleFromDeg(-.5667) ΔT := unit.Time(56) tRise, tTransit, tSet, err := rise.Times(p, ΔT, h0, Th0, α3, δ3) if err != nil { fmt.Println(err) return } fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // rising: +0.51766 12ʰ25ᵐ26ˢ // transit: +0.81980 19ʰ40ᵐ30ˢ // seting: +0.12130 02ʰ54ᵐ40ˢ }
func ExampleTimes_computed() { // Example 15.a, p. 103, but using meeus packages to compute values // given in the text. jd := julian.CalendarGregorianToJD(1988, 3, 20) p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } // Th0 computed rather than taken from the text. Th0 := sidereal.Apparent0UT(jd) // Venus α, δ computed rather than taken from the text. e, err := pp.LoadPlanet(pp.Earth) if err != nil { fmt.Println(err) return } v, err := pp.LoadPlanet(pp.Venus) if err != nil { fmt.Println(err) return } α := make([]unit.RA, 3) δ := make([]unit.Angle, 3) α[0], δ[0] = elliptic.Position(v, e, jd-1) α[1], δ[1] = elliptic.Position(v, e, jd) α[2], δ[2] = elliptic.Position(v, e, jd+1) for i, j := range []float64{jd - 1, jd, jd + 1} { _, m, d := julian.JDToCalendar(j) fmt.Printf("%s %.0f α: %0.2s δ: %0.1s\n", time.Month(m), d, sexa.FmtRA(α[i]), sexa.FmtAngle(δ[i])) } // ΔT computed rather than taken from the text. ΔT := deltat.Interp10A(jd) fmt.Printf("ΔT: %.1f\n", ΔT) h0 := rise.Stdh0Stellar tRise, tTransit, tSet, err := rise.Times(p, ΔT, h0, Th0, α, δ) if err != nil { fmt.Println(err) return } fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // March 19 α: 2ʰ42ᵐ43.25ˢ δ: 18°02′51.4″ // March 20 α: 2ʰ46ᵐ55.51ˢ δ: 18°26′27.3″ // March 21 α: 2ʰ51ᵐ07.69ˢ δ: 18°49′38.7″ // ΔT: 55.9 // rising: +0.51766 12ʰ25ᵐ26ˢ // transit: +0.81980 19ʰ40ᵐ30ˢ // seting: +0.12130 02ʰ54ᵐ40ˢ }
// First exercise, p. 110. func TestSep(t *testing.T) { r1 := unit.NewRA(4, 35, 55.2).Angle() d1 := unit.NewAngle(' ', 16, 30, 33) r2 := unit.NewRA(16, 29, 24).Angle() d2 := unit.NewAngle('-', 26, 25, 55) d := angle.Sep(r1, d1, r2, d2) answer := unit.NewAngle(' ', 169, 58, 0) if math.Abs((d - answer).Rad()) > 1e-4 { t.Fatal(d, answer) } }
func ExampleSep() { // Example 17.a, p. 110. r1 := unit.NewRA(14, 15, 39.7).Angle() d1 := unit.NewAngle(' ', 19, 10, 57) r2 := unit.NewRA(13, 25, 11.6).Angle() d2 := unit.NewAngle('-', 11, 9, 41) d := angle.Sep(r1, d1, r2, d2) fmt.Println(sexa.FmtAngle(d)) // Output: // 32°47′35″ }
func TestSepHav(t *testing.T) { // Example 17.a, p. 110. r1 := unit.NewRA(14, 15, 39.7).Angle() d1 := unit.NewAngle(' ', 19, 10, 57) r2 := unit.NewRA(13, 25, 11.6).Angle() d2 := unit.NewAngle('-', 11, 9, 41) d := angle.SepHav(r1, d1, r2, d2) s := fmt.Sprint(sexa.FmtAngle(d)) if s != "32°47′35″" { t.Fatal(s) } }
func TestPrecessor_Precess(t *testing.T) { // Exercise, p. 136. eqFrom := &coord.Equatorial{ RA: unit.NewRA(2, 31, 48.704), Dec: unit.NewAngle(' ', 89, 15, 50.72), } mα := unit.HourAngleFromSec(.19877) mδ := unit.AngleFromSec(-.0152) epochs := []float64{ base.JDEToJulianYear(base.B1900), 2050, 2100, } answer := []string{ "α = 1ʰ22ᵐ33ˢ.90 δ = +88°46′26″.18", "α = 3ʰ48ᵐ16ˢ.43 δ = +89°27′15″.38", "α = 5ʰ53ᵐ29ˢ.17 δ = +89°32′22″.18", } eqTo := &coord.Equatorial{} for i, epochTo := range epochs { precess.Position(eqFrom, eqTo, 2000, epochTo, mα, mδ) if answer[i] != fmt.Sprintf("α = %0.2d δ = %+0.2d", sexa.FmtRA(eqTo.RA), sexa.FmtAngle(eqTo.Dec)) { t.Fatal(i) } } }
func ExampleAngleError() { // Example p. 125. rδ := unit.NewRA(5, 32, 0.40).Angle() dδ := unit.NewAngle('-', 0, 17, 56.9) rε := unit.NewRA(5, 36, 12.81).Angle() dε := unit.NewAngle('-', 1, 12, 7.0) rζ := unit.NewRA(5, 40, 45.52).Angle() dζ := unit.NewAngle('-', 1, 56, 33.3) n, ω := line.AngleError(rδ, dδ, rε, dε, rζ, dζ) fmt.Printf("%m\n", sexa.FmtAngle(n)) fmt.Println(sexa.FmtAngle(ω)) // Output: // 7°31′ // -5′24″ }
// Exercise, p. 136. func TestPosition(t *testing.T) { eqFrom := &coord.Equatorial{ unit.NewRA(2, 31, 48.704), unit.NewAngle(' ', 89, 15, 50.72), } eqTo := &coord.Equatorial{} mα := unit.HourAngleFromSec(0.19877) mδ := unit.AngleFromSec(-0.0152) for _, tc := range []struct { α, δ string jde float64 }{ {"1ʰ22ᵐ33.90ˢ", "88°46′26.18″", base.BesselianYearToJDE(1900)}, {"3ʰ48ᵐ16.43ˢ", "89°27′15.38″", base.JulianYearToJDE(2050)}, {"5ʰ53ᵐ29.17ˢ", "89°32′22.18″", base.JulianYearToJDE(2100)}, } { epochTo := base.JDEToJulianYear(tc.jde) precess.Position(eqFrom, eqTo, 2000.0, epochTo, mα, mδ) αStr := fmt.Sprintf("%.2s", sexa.FmtRA(eqTo.RA)) δStr := fmt.Sprintf("%.2s", sexa.FmtAngle(eqTo.Dec)) if αStr != tc.α { t.Fatal("got:", αStr, "want:", tc.α) } if δStr != tc.δ { t.Fatal(δStr) } } }
func ExampleAngle() { // Example p. 123. rδ := unit.NewRA(5, 32, 0.40).Angle() dδ := unit.NewAngle('-', 0, 17, 56.9) rε := unit.NewRA(5, 36, 12.81).Angle() dε := unit.NewAngle('-', 1, 12, 7.0) rζ := unit.NewRA(5, 40, 45.52).Angle() dζ := unit.NewAngle('-', 1, 56, 33.3) n := line.Angle(rδ, dδ, rε, dε, rζ, dζ) fmt.Printf("%.4f degrees\n", n.Deg()) fmt.Printf("%m\n", sexa.FmtAngle(n)) // Output: // 172.4830 degrees // 172°29′ }
func ExampleProperMotion3D() { // Example 21.d, p. 141. eqFrom := &coord.Equatorial{ RA: unit.NewRA(6, 45, 8.871), Dec: unit.NewAngle('-', 16, 42, 57.99), } mra := unit.HourAngleFromSec(-0.03847) mdec := unit.AngleFromSec(-1.2053) r := 2.64 // given in correct unit mr := -7.6 / 977792 // magic conversion factor eqTo := &coord.Equatorial{} fmt.Printf("Δr = %.9f, Δα = %.10f, Δδ = %.10f\n", mr, mra, mdec) for _, epoch := range []float64{1000, 0, -1000, -2000, -10000} { precess.ProperMotion3D(eqFrom, eqTo, 2000, epoch, r, mr, mra, mdec) fmt.Printf("%8.1f %0.2d %0.1d\n", epoch, sexa.FmtRA(eqTo.RA), sexa.FmtAngle(eqTo.Dec)) } // Output: // Δr = -0.000007773, Δα = -0.0000027976, Δδ = -0.0000058435 // 1000.0 6ʰ45ᵐ47ˢ.16 -16°22′56″.0 // 0.0 6ʰ46ᵐ25ˢ.09 -16°03′00″.8 // -1000.0 6ʰ47ᵐ02ˢ.67 -15°43′12″.3 // -2000.0 6ʰ47ᵐ39ˢ.91 -15°23′30″.6 // -10000.0 6ʰ52ᵐ25ˢ.72 -12°50′06″.7 }
// p. 83 func TestLatDiff(t *testing.T) { φ0 := unit.NewAngle(' ', 45, 5, 46.36) diff := globe.GeocentricLatitudeDifference(φ0) if f := fmt.Sprintf("%.2d", sexa.FmtAngle(diff)); f != "11′32″.73" { t.Fatal(f) } }
func ExampleApproxTimes_computed() { // Example 15.a, p. 103, but using meeus packages to compute values // given in the text. jd := julian.CalendarGregorianToJD(1988, 3, 20) p := globe.Coord{ Lon: unit.NewAngle(' ', 71, 5, 0), Lat: unit.NewAngle(' ', 42, 20, 0), } // Th0 computed rather than taken from the text. Th0 := sidereal.Apparent0UT(jd) fmt.Printf("Th0: %.2s\n", sexa.FmtTime(Th0)) // Venus α, δ computed rather than taken from the text. e, err := pp.LoadPlanet(pp.Earth) if err != nil { fmt.Println(err) return } v, err := pp.LoadPlanet(pp.Venus) if err != nil { fmt.Println(err) return } α, δ := elliptic.Position(v, e, jd) fmt.Printf("α: %.2s\n", sexa.FmtRA(α)) fmt.Printf("δ: %.1s\n", sexa.FmtAngle(δ)) h0 := rise.Stdh0Stellar tRise, tTransit, tSet, err := rise.ApproxTimes(p, h0, Th0, α, δ) if err != nil { fmt.Println(err) return } fmt.Printf("rising: %+.5f %02s\n", tRise/86400, sexa.FmtTime(tRise)) fmt.Printf("transit: %+.5f %02s\n", tTransit/86400, sexa.FmtTime(tTransit)) fmt.Printf("seting: %+.5f %02s\n", tSet/86400, sexa.FmtTime(tSet)) // Output: // Th0: 11ʰ50ᵐ58.09ˢ // α: 2ʰ46ᵐ55.51ˢ // δ: 18°26′27.3″ // rising: +0.51816 12ʰ26ᵐ09ˢ // transit: +0.81965 19ʰ40ᵐ17ˢ // seting: +0.12113 02ʰ54ᵐ26ˢ }
func ExampleHorizontal_EqToHz() { // Example 13.b, p. 95. eq := &coord.Equatorial{ RA: unit.NewRA(23, 9, 16.641), Dec: unit.NewAngle('-', 6, 43, 11.61), } g := &globe.Coord{ Lat: unit.NewAngle(' ', 38, 55, 17), Lon: unit.NewAngle(' ', 77, 3, 56), } jd := julian.TimeToJD(time.Date(1987, 4, 10, 19, 21, 0, 0, time.UTC)) st := sidereal.Apparent(jd) hz := new(coord.Horizontal).EqToHz(eq, g, st) fmt.Printf("A = %+.3j\n", sexa.FmtAngle(hz.Az)) fmt.Printf("h = %+.3j\n", sexa.FmtAngle(hz.Alt)) // Output: // A = +68°.034 // h = +15°.125 }
func ExampleError() { // Example p. 124. rδ := unit.NewRA(5, 32, 0.40).Angle() dδ := unit.NewAngle('-', 0, 17, 56.9) rε := unit.NewRA(5, 36, 12.81).Angle() dε := unit.NewAngle('-', 1, 12, 7.0) rζ := unit.NewRA(5, 40, 45.52).Angle() dζ := unit.NewAngle('-', 1, 56, 33.3) ω := line.Error(rζ, dζ, rδ, dδ, rε, dε) e := sexa.FmtAngle(ω) fmt.Printf("%.6j\n", e) fmt.Printf("%.0f″\n", ω.Sec()) fmt.Println(e) // Output: // 0°.089876 // 324″ // 5′24″ }
func ExampleSmallest_b() { // Exercise, p. 128. r1 := unit.NewRA(9, 5, 41.44).Angle() r2 := unit.NewRA(9, 9, 29).Angle() r3 := unit.NewRA(8, 59, 47.14).Angle() d1 := unit.NewAngle(' ', 18, 30, 30) d2 := unit.NewAngle(' ', 17, 43, 56.7) d3 := unit.NewAngle(' ', 17, 49, 36.8) d, t := circle.Smallest(r1, d1, r2, d2, r3, d3) fmt.Printf("Δ = %m\n", sexa.FmtAngle(d)) if t { fmt.Println("type I") } else { fmt.Println("type II") } // Output: // Δ = 2°19′ // type I }
func ExampleSmallest_a() { // Example 20.a, p. 128. r1 := unit.NewRA(12, 41, 8.64).Angle() r2 := unit.NewRA(12, 52, 5.21).Angle() r3 := unit.NewRA(12, 39, 28.11).Angle() d1 := unit.NewAngle('-', 5, 37, 54.2) d2 := unit.NewAngle('-', 4, 22, 26.2) d3 := unit.NewAngle('-', 1, 50, 3.7) d, t := circle.Smallest(r1, d1, r2, d2, r3, d3) fd := sexa.FmtAngle(d) fmt.Printf("Δ = %.5j = %m\n", fd, fd) if t { fmt.Println("type I") } else { fmt.Println("type II") } // Output: // Δ = 4°.26363 = 4°16′ // type II }
func ExampleEllipsoid_ParallaxConstants() { // Example 11.a, p 82. // phi = geographic latitude of Palomar φ := unit.NewAngle(' ', 33, 21, 22) s, c := globe.Earth76.ParallaxConstants(φ, 1706) fmt.Printf("ρ sin φ′ = %+.6f\n", s) fmt.Printf("ρ cos φ′ = %+.6f\n", c) // Output: // ρ sin φ′ = +0.546861 // ρ cos φ′ = +0.836339 }
func TestEqToGal(t *testing.T) { g := new(coord.Galactic).EqToGal(&coord.Equatorial{ RA: unit.NewRA(17, 48, 59.74), Dec: unit.NewAngle('-', 14, 43, 8.2), }) if s := fmt.Sprintf("%.4f", g.Lon.Deg()); s != "12.9593" { t.Fatal("lon:", s) } if s := fmt.Sprintf("%+.4f", g.Lat.Deg()); s != "+6.0463" { t.Fatal("lat:", s) } }
func ExampleAberrationRonVondrak() { // Example 23.b, p. 156 α := unit.NewRA(2, 44, 12.9747) δ := unit.NewAngle(' ', 49, 13, 39.896) jd := julian.CalendarGregorianToJD(2028, 11, 13.19) Δα, Δδ := apparent.AberrationRonVondrak(α, δ, jd) fmt.Printf("Δα = %+.9f radian\n", Δα) fmt.Printf("Δδ = %+.9f radian\n", Δδ) // Output: // Δα = +0.000145252 radian // Δδ = +0.000032723 radian }
func ExampleAberration() { // Example 23.a, p. 152 α := unit.NewRA(2, 46, 11.331) δ := unit.NewAngle(' ', 49, 20, 54.54) jd := julian.CalendarGregorianToJD(2028, 11, 13.19) Δα2, Δδ2 := apparent.Aberration(α, δ, jd) fmt.Printf("%.3s %.3s\n", sexa.FmtAngle(unit.Angle(Δα2)), // (Δα2 is in HourAngle) sexa.FmtAngle(Δδ2)) // Output: // 30.045″ 6.697″ }
func ExampleNutation() { // Example 23.a, p. 152 α := unit.NewRA(2, 46, 11.331) δ := unit.NewAngle(' ', 49, 20, 54.54) jd := julian.CalendarGregorianToJD(2028, 11, 13.19) Δα1, Δδ1 := apparent.Nutation(α, δ, jd) fmt.Printf("%.3s %.3s\n", sexa.FmtAngle(unit.Angle(Δα1)), // (Δα1 is in HourAngle) sexa.FmtAngle(Δδ1)) // Output: // 15.843″ 6.217″ }
// Test with proper motion of Regulus, with equatorial motions given // in Example 21.a, p. 132, and ecliptic motions given in table 21.A, // p. 138. func TestEqProperMotionToEcl(t *testing.T) { ε := coord.NewObliquity(nutation.MeanObliquity(base.J2000)) mλ, mβ := eqProperMotionToEcl( // eq motions from p. 132. unit.NewHourAngle('-', 0, 0, 0.0169), unit.NewAngle(' ', 0, 0, 0.006), 2000.0, // eq coordinates from p. 132. new(coord.Ecliptic).EqToEcl(&coord.Equatorial{ RA: unit.NewRA(10, 8, 22.3), Dec: unit.NewAngle(' ', 11, 58, 2), }, ε)) d := math.Abs((mλ - unit.AngleFromSec(-.2348)).Rad() / mλ.Rad()) if d*169 > 1 { // 169 = significant digits of given lon t.Fatal("mλ") } d = math.Abs((mβ - unit.AngleFromSec(-.0813)).Rad() / mβ.Rad()) if d*6 > 1 { // 6 = significant digit of given lat t.Fatal("mβ") } }
func ExampleEllipsoid_Distance() { // Example 11.c p 85. c1 := globe.Coord{ unit.NewAngle(' ', 48, 50, 11), // geographic latitude unit.NewAngle('-', 2, 20, 14), // geographic longitude } c2 := globe.Coord{ unit.NewAngle(' ', 38, 55, 17), unit.NewAngle(' ', 77, 3, 56), } fmt.Printf("%.2f km\n", globe.Earth76.Distance(c1, c2)) cos := globe.ApproxAngularDistance(c1, c2) fmt.Printf("cos d = %.6f\n", cos) d := unit.Angle(math.Acos(cos)) fmt.Printf(" d = %.5j\n", sexa.FmtAngle(d)) fmt.Printf(" s = %.0f km\n", globe.ApproxLinearDistance(d)) // Output: // 6181.63 km // cos d = 0.567146 // d = 55°.44855 // s = 6166 km }
func ExampleEcliptic_EqToEcl() { // Example 13.a, p. 95. eq := &coord.Equatorial{ unit.NewRA(7, 45, 18.946), unit.NewAngle(' ', 28, 1, 34.26), } obl := coord.NewObliquity(unit.AngleFromDeg(23.4392911)) ecl := new(coord.Ecliptic).EqToEcl(eq, obl) fmt.Printf("λ = %.5j\n", sexa.FmtAngle(ecl.Lon)) fmt.Printf("β = %+.6j\n", sexa.FmtAngle(ecl.Lat)) // Output: // λ = 113°.21563 // β = +6°.684170 }
func TestDiurnalPathAtHorizon(t *testing.T) { φ := unit.AngleFromDeg(40) ε := unit.AngleFromDeg(23.44) J := parallactic.DiurnalPathAtHorizon(0, φ) Jexp := math.Pi/2 - φ if math.Abs((J-Jexp).Rad()/Jexp.Rad()) > 1e-15 { t.Fatal("0 dec:", sexa.FmtAngle(J)) } J = parallactic.DiurnalPathAtHorizon(ε, φ) Jexp = unit.NewAngle(' ', 45, 31, 0) if math.Abs((J-Jexp).Rad()/Jexp.Rad()) > 1e-3 { t.Fatal("solstice:", sexa.FmtAngle(J)) } }
func ExampleApproxAnnualPrecession() { // Example 21.a, p. 132. eq := &coord.Equatorial{ unit.NewRA(10, 8, 22.3), unit.NewAngle(' ', 11, 58, 2), } epochFrom := 2000.0 epochTo := 1978.0 Δα, Δδ := precess.ApproxAnnualPrecession(eq, epochFrom, epochTo) fmt.Printf("%+.3d\n", sexa.FmtHourAngle(Δα)) fmt.Printf("%+.2d\n", sexa.FmtAngle(Δδ)) // Output: // +3ˢ.207 // -17″.71 }
func ExamplePositionRonVondrak() { // Example 23.b, p. 156 jd := julian.CalendarGregorianToJD(2028, 11, 13.19) eq := &coord.Equatorial{ RA: unit.NewRA(2, 44, 11.986), Dec: unit.NewAngle(' ', 49, 13, 42.48), } apparent.PositionRonVondrak(eq, eq, base.JDEToJulianYear(jd), unit.HourAngleFromSec(.03425), unit.AngleFromSec(-.0895)) fmt.Printf("α = %0.3d\n", sexa.FmtRA(eq.RA)) fmt.Printf("δ = %0.2d\n", sexa.FmtAngle(eq.Dec)) // Output: // α = 2ʰ46ᵐ14ˢ.392 // δ = 49°21′07″.45 }