init

astro.go

@@ -0,0 +1,190 @@
+package astro
+
+import (
+	"errors"
+	"time"
+
+	"b612.me/astro/basic"
+)
+
+/*
+获取当前时刻（本地时间）对应的儒略日时间
+*/
+func NowJDE() float64 {
+	return basic.GetNowJDE()
+}
+
+/*
+日期转儒略日
+*/
+func Date2JDE(date time.Time) float64 {
+	day := float64(date.Day()) + float64(date.Hour())/24.0 + float64(date.Minute())/24.0/60.0 + float64(date.Second())/24.0/3600.0 + float64(date.Nanosecond())/1000000000.0/3600.0/24.0
+	return basic.JDECalc(date.Year(), int(date.Month()), day)
+}
+
+/*
+儒略日转日期
+*/
+func JDE2Date(jde float64) time.Time {
+	return basic.JDE2Date(jde)
+}
+
+/*
+公历转农历
+返回：月，日，是否闰月，文字描述
+*/
+func Lunar(year, month, day int) (int, int, bool, string) {
+	return basic.GetLunar(year, month, day)
+}
+
+/*
+农历转公历
+*/
+func Solar(year, month, day int, leap bool) time.Time {
+	jde := basic.GetSolar(year, month, day, leap)
+	return JDE2Date(jde)
+}
+
+/*
+  太阳升起时间
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  aero，true时进行大气修正
+*/
+func SunRiseTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
+	var err error = nil
+	tz := 0.00
+	if aero {
+		tz = 1
+	}
+	tm := basic.GetSunRiseTime(jde, lon, lat, timezone, tz)
+	if tm == -2 {
+		err = errors.New("极夜")
+	}
+	if tm == -1 {
+		err = errors.New("极昼")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+  太阳落下时间
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  aero，true时进行大气修正
+*/
+func SunDownTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
+	var err error = nil
+	tz := 0.00
+	if aero {
+		tz = 1
+	}
+	tm := basic.GetSunDownTime(jde, lon, lat, timezone, tz)
+	if tm == -2 {
+		err = errors.New("极夜")
+	}
+	if tm == -1 {
+		err = errors.New("极昼")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+  晨朦影
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  angle，朦影角度：可选-6 -12 -18
+*/
+func MorningTwilightTime(jde, lon, lat, timezone, angle float64) (time.Time, error) {
+	var err error = nil
+	tm := basic.GetAsaTime(jde, lon, lat, timezone, angle)
+	if tm == -2 {
+		err = errors.New("不存在")
+	}
+	if tm == -1 {
+		err = errors.New("不存在")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+  昏朦影
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  angle，朦影角度：可选-6 -12 -18
+*/
+func EveningTwilightTime(jde, lon, lat, timezone, angle float64) (time.Time, error) {
+	var err error = nil
+	tm := basic.GetBanTime(jde, lon, lat, timezone, angle)
+	if tm == -2 {
+		err = errors.New("不存在")
+	}
+	if tm == -1 {
+		err = errors.New("不存在")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+  月亮升起时间
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  aero，true时进行大气修正
+*/
+func MoonRiseTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
+	var err error = nil
+	tz := 0.00
+	if aero {
+		tz = 1
+	}
+	tm := basic.GetMoonRiseTime(jde, lon, lat, timezone, tz)
+	if tm == -2 {
+		err = errors.New("极夜")
+	}
+	if tm == -1 {
+		err = errors.New("极昼")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+  月亮落下时间
+  jde，世界时当地0时 JDE
+  lon，经度，东正西负
+  lat，纬度，北正南负
+  timezone，时区，东正西负
+  aero，true时进行大气修正
+*/
+func MoonDownTime(jde, lon, lat, timezone float64, aero bool) (time.Time, error) {
+	var err error = nil
+	tz := 0.00
+	if aero {
+		tz = 1
+	}
+	tm := basic.GetMoonDownTime(jde, lon, lat, timezone, tz)
+	if tm == -2 {
+		err = errors.New("极夜")
+	}
+	if tm == -1 {
+		err = errors.New("极昼")
+	}
+	return JDE2Date(tm), err
+}
+
+/*
+月相
+jde，世界时UTC JDE
+*/
+func Phase(jde float64) float64 {
+	return basic.MoonLight(basic.TD2UT(jde, true))
+}

basic/all_test.go

@@ -0,0 +1,29 @@
+package basic
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_SunAndMoon(t *testing.T) {
+	jde := GetNowJDE() - 1
+	ra := HSunSeeRa(jde - 8.0/24.0)
+	dec := HSunSeeDec(jde - 8.0/24.0)
+	fmt.Printf("当前JDE:%.14f\n", jde)
+	fmt.Println("当前太阳黄经：", HSunSeeLo(jde-8.0/24.0))
+	fmt.Println("当前太阳赤经：", ra)
+	fmt.Println("当前太阳赤纬：", dec)
+	fmt.Println("当前太阳星座：", WhichCst(ra, dec, jde))
+	fmt.Println("当前黄赤交角：", EclipticObliquity(jde-8.0/24.0, true))
+	fmt.Println("当前日出：", JDE2Date(GetSunRiseTime(jde, 115, 32, 8, 1)))
+	fmt.Println("当前日落：", JDE2Date(GetSunDownTime(jde, 115, 32, 8, 1)))
+	fmt.Println("当前晨影 -6：", JDE2Date(GetAsaTime(jde, 115, 32, 8, -6)))
+	fmt.Println("当前晨影 -12：", JDE2Date(GetAsaTime(jde, 115, 32, 8, -12)))
+	fmt.Println("当前昏影 -6：", JDE2Date(GetBanTime(jde, 115, 32, 8, -6)))
+	fmt.Println("当前昏影 -12：", JDE2Date(GetBanTime(jde, 115, 32, 8, -12)))
+	fmt.Print("农历：")
+	fmt.Println(GetLunar(2019, 10, 23))
+	fmt.Println("当前月出：", JDE2Date(GetMoonRiseTime(jde, 115, 32, 8, 1)))
+	fmt.Println("当前月落：", JDE2Date(GetMoonDownTime(jde, 115, 32, 8, 1)))
+	fmt.Println("月相：", MoonLight(jde-8.0/24.0))
+}

basic/cal_test.go

@@ -0,0 +1,24 @@
+package basic
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func Test_JDECALC(t *testing.T) {
+	i := 10
+	for i > 0 {
+		fmt.Printf("%.18f\n", GetNowJDE())
+		time.Sleep(time.Second)
+		i--
+	}
+}
+
+func Test_TDUT(t *testing.T) {
+	fmt.Printf("%.18f\n", DeltaT(2119.5, false))
+}
+
+func Test_JDE2(t *testing.T) {
+	fmt.Println(JDE2Date(2458868.500))
+}

basic/calendar.go

@@ -0,0 +1,323 @@
+package basic
+
+import (
+	"fmt"
+	"math"
+	"strings"
+	"time"
+)
+
+/*
+ @name: 儒略日计算
+ @dec: 计算给定时间的儒略日，1582年改力后为格里高利历，之前为儒略历
+ @     请注意，传入的时间在天文计算中一般为力学时，应当注意和世界时的转化
+*/
+func JDECalc(Year, Month int, Day float64) float64 {
+	if Month == 1 || Month == 2 {
+		Year--
+		Month += 12
+	}
+	var tmpvarB int
+	tmpvar := fmt.Sprintf("%04d-%02d-%2d", Year, Month, int(math.Floor(Day)))
+	if strings.Compare(tmpvar, `1582-10-04`) != 1 {
+		tmpvarB = 0
+	} else {
+		tmpvarA := int(Year / 100)
+		tmpvarB = 2 - tmpvarA + int(tmpvarA/4)
+	}
+	return (math.Floor(365.25*(float64(Year)+4716.0)) + math.Floor(30.6001*float64(Month+1)) + Day + float64(tmpvarB) - 1524.5)
+}
+
+/*
+ @name: 获得当前儒略日时间：当地世界时，非格林尼治时间
+*/
+func GetNowJDE() (NowJDE float64) {
+	Time := float64(time.Now().Second())/3600.0/24.0 + float64(time.Now().Minute())/60.0/24.0 + float64(time.Now().Hour())/24.0
+	NowJDE = JDECalc(time.Now().Year(), int(time.Now().Month()), float64(time.Now().Day())+Time)
+	return
+}
+
+func dt_ext(y, jsd float64) float64 { // 二次曲线外推，用于数值外插
+	dy := (y - 1820) / 100.00
+	return -20 + jsd*dy*dy
+}
+func dt_cal(y float64) float64 { //传入年， 返回世界时UT与原子时（力学时 TD）之差, ΔT = TD - UT
+	dt_at := []float64{
+		-4000, 108371.7, -13036.80, 392.000, 0.0000,
+		-500, 17201.0, -627.82, 16.170, -0.3413,
+		-150, 12200.6, -346.41, 5.403, -0.1593,
+		150, 9113.8, -328.13, -1.647, 0.0377,
+		500, 5707.5, -391.41, 0.915, 0.3145,
+		900, 2203.4, -283.45, 13.034, -0.1778,
+		1300, 490.1, -57.35, 2.085, -0.0072,
+		1600, 120.0, -9.81, -1.532, 0.1403,
+		1700, 10.2, -0.91, 0.510, -0.0370,
+		1800, 13.4, -0.72, 0.202, -0.0193,
+		1830, 7.8, -1.81, 0.416, -0.0247,
+		1860, 8.3, -0.13, -0.406, 0.0292,
+		1880, -5.4, 0.32, -0.183, 0.0173,
+		1900, -2.3, 2.06, 0.169, -0.0135,
+		1920, 21.2, 1.69, -0.304, 0.0167,
+		1940, 24.2, 1.22, -0.064, 0.0031,
+		1960, 33.2, 0.51, 0.231, -0.0109,
+		1980, 51.0, 1.29, -0.026, 0.0032,
+		2000, 63.87, 0.1, 0, 0,
+		2005, 64.7, 0.4, 0, 0, //一次项记为x,则 10x=0.4秒/年*(2015-2005),解得x=0.4
+		2015, 69,
+	}
+	y0 := dt_at[len(dt_at)-2] //表中最后一年
+	t0 := dt_at[len(dt_at)-1] //表中最后一年的 deltatT
+	if y >= y0 {
+		jsd := float64(31) // sjd是y1年之后的加速度估计
+		// 瑞士星历表jsd=31, NASA网站jsd=32, skmap的jsd=29
+		if y > y0+100 {
+			return dt_ext(y, jsd)
+		}
+		v := dt_ext(y, jsd)        //二次曲线外推
+		dv := dt_ext(y0, jsd) - t0 // ye年的二次外推与te的差
+		return (v - dv*(y0+100-y)/100)
+	}
+	d := dt_at
+	var i int
+	for i = 0; i < len(d); i += 5 {
+		if float64(y) < d[i+5] {
+			break
+			// 判断年所在的区间
+		}
+	}
+	t1 := (y - d[i]) / (d[i+5] - d[i]) * 10 //////// 三次插值， 保证精确性
+	t2 := t1 * t1
+	t3 := t2 * t1
+	res := d[i+1] + d[i+2]*t1 + d[i+3]*t2 + d[i+4]*t3
+	return (res)
+}
+func DeltaT(Date float64, IsJDE bool) (Result float64) { //传入年或儒略日，传出为秒
+	var Year float64
+	if IsJDE {
+		Year = (Date-2451545.0)/365.25 + 0.1 + 2000
+	} else {
+		Year = Date
+	}
+	if Year < 2010 {
+		Result = dt_cal(Year)
+		return
+	}
+	if Year < 2100 && Year >= 2010 {
+		Result = dt_cal(Year) //-3.2-(Year-2017)*0.029915;
+		return
+	}
+	if Year >= 2100 && Year <= 2150 {
+		Result = -20 + 32*(((Year-1820.0)/100.0)*((Year-1820.0)/100.0)) - 0.5628*(2150-Year)
+		return
+	}
+	if Year > 2150 {
+		//tmp=(Year-1820)/100;
+		//Result= -20 + 32 * tmp*tmp;
+		Result = dt_cal(Year)
+		return
+	}
+	return
+}
+func TD2UT(JDE float64, UT2TD bool) float64 { // true 世界时转力学时CC，false 力学时转世界时VV
+
+	Deltat := DeltaT(JDE, true)
+	if UT2TD {
+		return JDE + Deltat/3600/24
+	} else {
+		return JDE - Deltat/3600/24
+	}
+}
+
+/*
+ * @name: JDE转日期，输出为数组
+ */
+func JDE2Date(JD float64) time.Time {
+	JD = JD + 0.5
+	Z := float64(int(JD))
+	F := JD - Z
+	var A, B, Years, Months, Days float64
+	if Z < 2299161.0 {
+		A = Z
+	} else {
+		alpha := math.Floor((Z - 1867216.25) / 36524.25)
+		A = Z + 1 + alpha - math.Floor(alpha/4)
+	}
+	B = A + 1524
+	C := math.Floor((B - 122.1) / 365.25)
+	D := math.Floor(365.25 * C)
+	E := math.Floor((B - D) / 30.6001)
+	Days = B - D - math.Floor(30.6001*E) + F
+	if E < 14 {
+		Months = E - 1
+	}
+	if E == 14 || E == 15 {
+		Months = E - 13
+	}
+	if Months > 2 {
+		Years = C - 4716
+	}
+	if Months == 1 || Months == 2 {
+		Years = C - 4715
+	}
+	tms := (Days - math.Floor(Days)) * 24 * 3600
+	Days = math.Floor(Days)
+	tz, _ := time.LoadLocation("Local")
+	dates := time.Date(int(Years), time.Month(int(Months)), int(Days), 0, 0, 0, 0, tz)
+	dates = time.Unix(dates.Unix()+int64(tms), int64((tms-math.Floor(tms))*1000000000))
+	return dates
+}
+
+func GetLunar(year, month, day int) (lmonth, lday int, leap bool, result string) {
+	jde := JDECalc(year, month, float64(day)) //计算当前JDE时间
+	if month == 11 || month == 12 {           //判断当前日期属于前一年周期还是后一年周期
+		//判断方法：当前日期与冬至日所在朔望月的关系
+		winterday := GetJQTime(year, 270) + 8.0/24.0                                        //冬至日日期（世界时，北京时间）
+		Fday := TD2UT(CalcMoonS(float64(year)+11.0/12.0+5.0/30.0/12.0, 0), true) + 8.0/24.0 //朔月（世界时，北京时间）
+		Yday := TD2UT(CalcMoonS(float64(year)+1.0, 0), true) + 8.0/24.0                     //下一朔月（世界时，北京时间）
+		if Fday-math.Floor(Fday) > 0.5 {
+			Fday = math.Floor(Fday) + 0.5
+		} else {
+			Fday = math.Floor(Fday) - 0.5
+		}
+		if Yday-math.Floor(Yday) > 0.5 {
+			Yday = math.Floor(Yday) + 0.5
+		} else {
+			Yday = math.Floor(Yday) - 0.5
+		}
+		if winterday >= Fday && winterday < Yday && jde <= Fday {
+			year--
+		}
+		if winterday >= Yday && jde < Yday {
+			year--
+		}
+	} else {
+		year--
+	}
+	jieqi := GetOneYearJQ(year)           //一年的节气
+	moon := GetOneYearMoon(float64(year)) //一年朔月日
+	winter1 := jieqi[1]                   //第一年冬至日
+	winter2 := jieqi[25]                  //第二年冬至日
+	for k, v := range moon {
+		if v-math.Floor(v) > 0.5 {
+			moon[k] = math.Floor(v) + 0.5
+		} else {
+			moon[k] = math.Floor(v) - 0.5
+		}
+	} //置闰月为0点
+	for k, v := range jieqi {
+		if v-math.Floor(v) > 0.5 {
+			jieqi[k] = math.Floor(v) + 0.5
+		} else {
+			jieqi[k] = math.Floor(v) - 0.5
+		}
+	} //置节气为0点
+	mooncount := 0           //年内朔望月计数
+	var min, max int = 20, 0 //最大最小计数
+	for i := 1; i < 16; i++ {
+		if moon[i] >= winter1 && moon[i] < winter2 {
+			if i <= min {
+				min = i
+			}
+			if i >= max {
+				max = i
+			}
+			mooncount++
+		}
+	}
+	leapmonth := 20
+	if mooncount == 13 { //存在闰月
+		j, i := 3, 1
+		for i = min; i <= max; i++ {
+			if !(moon[i] <= jieqi[j] && moon[i+1] > jieqi[j]) {
+				break
+			}
+			j += 2
+		}
+		leapmonth = i - min + 1
+	}
+	i := 0
+	for i = min - 1; i <= max; i++ {
+		if moon[i] > jde {
+			break
+		}
+	}
+	lmonth = i - min
+	var sleap bool = false
+	leap = false
+	if lmonth >= leapmonth {
+		sleap = true
+	}
+	if lmonth == leapmonth {
+		leap = true
+	}
+	if lmonth < 2 {
+		lmonth += 11
+	} else {
+		lmonth--
+	}
+	if sleap {
+		lmonth--
+	}
+	lday = int(jde-moon[i-1]) + 1
+	strmonth := []string{"十", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "冬", "腊"}
+	strday := []string{"初", "十", "廿", "三"}
+	if leap {
+		result += "闰"
+	}
+	result += strmonth[lmonth] + "月"
+	if lday == 20 {
+		result += "二十"
+	} else if lday == 10 {
+		result += "初十"
+	} else {
+		result += strday[lday/10] + strmonth[lday%10]
+	}
+	return
+}
+
+func GetSolar(year, month, day int, leap bool) float64 {
+	if month < 11 {
+		year--
+	}
+	jieqi := GetOneYearJQ(year)           //一年的节气
+	moon := GetOneYearMoon(float64(year)) //一年朔月日
+	winter1 := jieqi[1]                   //第一年冬至日
+	winter2 := jieqi[25]                  //第二年冬至日
+	for k, v := range moon {
+		if v-math.Floor(v) > 0.5 {
+			moon[k] = math.Floor(v) + 0.5
+		} else {
+			moon[k] = math.Floor(v) - 0.5
+		}
+	} //置闰月为0点
+	for k, v := range jieqi {
+		if v-math.Floor(v) > 0.5 {
+			jieqi[k] = math.Floor(v) + 0.5
+		} else {
+			jieqi[k] = math.Floor(v) - 0.5
+		}
+	} //置节气为0点
+	mooncount := 0           //年内朔望月计数
+	var min, max int = 20, 0 //最大最小计数
+	for i := 1; i < 16; i++ {
+		if moon[i] >= winter1 && moon[i] < winter2 {
+			if i <= min {
+				min = i
+			}
+			if i >= max {
+				max = i
+			}
+			mooncount++
+		}
+	}
+	if leap {
+		month++
+	}
+	if month > 10 {
+		month -= 11
+	} else {
+		month++
+	}
+	jde := moon[min-1+month] + float64(day) - 1
+	return jde
+}

basic/coordinate.go

@@ -0,0 +1,141 @@
+package basic
+
+import (
+	"math"
+
+	. "b612.me/astro/tools"
+)
+
+/*
+ * 坐标变换，黄道转赤道
+ */
+func LoToRa(lo, bo, jde float64) float64 {
+	ra := math.Atan2(Sin(lo)*Cos(Sita(jde)-Tan(bo)*Sin(Sita(jde))), Cos(lo))
+	ra = ra * 180 / math.Pi
+	if ra < 0 {
+		ra += 360
+	}
+	return ra
+}
+
+func BoToDec(lo, bo, jde float64) float64 {
+	dec := ArcSin(Sin(bo)*Cos(Sita(jde)) + Cos(bo)*Sin(Sita(jde))*Sin(lo))
+	return dec
+}
+
+/*
+ * 赤道坐标岁差变换st end 为JDE时刻
+ */
+func ZuoBiaoSuiCha(ra, dec, st, end float64) (float64, float64) {
+	t := (end - st) / 36525.0
+	l := (2306.2181*t + 0.30188*t*t + 0.017998*t*t*t) / 3600
+	z := (2306.2181*t + 1.09468*t*t + 0.018203*t*t*t) / 3600
+	o := (2004.3109*t - 0.42665*t*t + 0.041833*t*t*t) / 3600
+	A := Cos(dec) * Sin(ra+l)
+	B := Cos(o)*Cos(dec)*Cos(ra+l) - Sin(o)*Sin(dec)
+	C := Sin(o)*Cos(dec)*Cos(ra+l) + Cos(o)*Sin(dec)
+	ras := math.Atan2(A, B)
+	ras = ras * 180 / math.Pi
+	if ras < 0 {
+		ras += 360
+	}
+	ra = ras + z
+	dec = ArcSin(C)
+	return ra, dec
+}
+
+/*
+ * 地心坐标转站心坐标，参数分别为，地心赤经赤纬 纬度经度，jde，离地心位置au
+ */
+func pcosi(lat, h float64) float64 {
+	b := 6356.755
+	a := 6378.14
+	u := ArcTan(b / a * Tan(lat))
+	//psin=b/a*Sin(u)+h/6378140*Sin(lat);
+	pcos := Cos(u) + h/6378140.0*Cos(lat)
+	return pcos
+}
+func psini(lat, h float64) float64 {
+	b := 6356.755
+	a := 6378.14
+	u := ArcTan(b / a * Tan(lat))
+	psin := b/a*Sin(u) + h/6378140*Sin(lat)
+	//pcos=Cos(u)+h/6378140*Cos(lat);
+	return psin
+}
+
+func ZhanXinRaDec(ra, dec, lat, lon, jd, au, h float64) (float64, float64) {
+	sinpi := Sin(0.0024427777777) / au
+	pcosi := pcosi(lat, h)
+	psini := psini(lat, h)
+	tH := Limit360(TD2UT(SeeStarTime(jd), false)*15 + lon - ra)
+	nra := math.Atan2(-pcosi*sinpi*Sin(tH), (Cos(dec)-pcosi*sinpi*Cos(tH))) * 180 / math.Pi
+
+	ndec := math.Atan2((Sin(dec)-psini*sinpi)*Cos(nra), (Cos(dec)-pcosi*sinpi*Cos(tH))) * 180 / math.Pi
+	return ra + nra, ndec
+}
+
+func ZhanXinRa(ra, dec, lat, lon, jd, au, h float64) float64 { //jd为格林尼治标准时
+	sinpi := Sin(0.0024427777777) / au
+	pcosi := pcosi(lat, h)
+	tH := Limit360(TD2UT(SeeStarTime(jd), false)*15 + lon - ra)
+	nra := math.Atan2(-pcosi*sinpi*Sin(tH), (Cos(dec)-pcosi*sinpi*Cos(tH))) * 180 / math.Pi
+	return ra + nra
+}
+func ZhanXinDec(ra, dec, lat, lon, jd, au, h float64) float64 { //jd为格林尼治标准时
+
+	sinpi := Sin(0.0024427777777) / au
+	pcosi := pcosi(lat, h)
+	psini := psini(lat, h)
+	tH := Limit360(TD2UT(SeeStarTime(jd), false)*15 + lon - ra)
+	nra := math.Atan2(-pcosi*sinpi*Sin(tH), (Cos(dec)-pcosi*sinpi*Cos(tH))) * 180 / math.Pi
+
+	ndec := math.Atan2((Sin(dec)-psini*sinpi)*Cos(nra), (Cos(dec)-pcosi*sinpi*Cos(tH))) * 180 / math.Pi
+	return ndec
+}
+
+func ZhanXinLo(lo, bo, lat, lon, jd, au, h float64) float64 { //jd为格林尼治标准时
+	C := pcosi(lat, h)
+	S := psini(lat, h)
+	sinpi := Sin(0.0024427777777) / au
+	ra := LoToRa(lo, bo, jd)
+	tH := Limit360(TD2UT(SeeStarTime(jd), false)*15 + lon - ra)
+	N := Cos(lo)*Cos(bo) - C*sinpi*Cos(tH)
+	nlo := math.Atan2(Sin(lo)*Cos(bo)-sinpi*(S*Sin(Sita(jd))+C*Cos(Sita(jd))*Sin(tH)), N) * 180 / math.Pi
+	return nlo
+}
+
+func ZhanXinBo(lo, bo, lat, lon, jd, au, h float64) float64 { //jd为格林尼治标准时
+	C := pcosi(lat, h)
+	S := psini(lat, h)
+	sinpi := Sin(0.0024427777777) / au
+	ra := LoToRa(lo, bo, jd)
+	tH := Limit360(TD2UT(SeeStarTime(jd), false)*15 + lon - ra)
+	N := Cos(lo)*Cos(bo) - C*sinpi*Cos(tH)
+	nlo := math.Atan2(Sin(lo)*Cos(bo)-sinpi*(S*Sin(Sita(jd))+C*Cos(Sita(jd))*Sin(tH)), N) * 180 / math.Pi
+	nbo := math.Atan2(Cos(nlo)*(Sin(bo)-sinpi*(S*Cos(Sita(jd))-C*Sin(Sita(jd))*Sin(tH))), N) * 180 / math.Pi
+	return nbo
+}
+
+/*
+ func GXCLo(lo,bo,jd float64) float64{  //光行差修正
+k:=20.49552;
+sunlo:=SunTrueLo(jd);
+e:=Earthe(jd);
+epi=earth->EarthPI(jd);
+tmp=(-k*this->CosR(sunlo-lo)+e*k*this->CosR(epi-lo))/this->CosR(bo);
+return tmp;
+}
+
+public function GXCBo(lo,bo,jd)
+{
+	earth=new Earth();
+k=20.49552;
+sunlo=earth->SunTrueLo(jd);
+e=earth->Earthe(jd);
+epi=earth->EarthPI(jd);
+tmp=-k*this->SinR(bo)*(this->SinR(sunlo-lo)-e*this->SinR(epi-lo));
+return tmp;
+}
+
+*/

basic/coordinate_test.go

@@ -0,0 +1,10 @@
+package basic
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_LoBo(t *testing.T) {
+	fmt.Sprintf("%.14f", LoToRa(22, 33, 2451545.0))
+}

basic/jupiter.go

@@ -0,0 +1,147 @@
+package basic
+
+import (
+	"math"
+
+	"b612.me/astro/planet"
+	. "b612.me/astro/tools"
+)
+
+func JupiterL(JD float64) float64 {
+	return planet.WherePlanet(4, 0, JD)
+}
+
+func JupiterB(JD float64) float64 {
+	return planet.WherePlanet(4, 1, JD)
+}
+func JupiterR(JD float64) float64 {
+	return planet.WherePlanet(4, 2, JD)
+}
+func AJupiterX(JD float64) float64 {
+	l := JupiterL(JD)
+	b := JupiterB(JD)
+	r := JupiterR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	return x
+}
+
+func AJupiterY(JD float64) float64 {
+
+	l := JupiterL(JD)
+	b := JupiterB(JD)
+	r := JupiterR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	return y
+}
+func AJupiterZ(JD float64) float64 {
+	//l := JupiterL(JD)
+	b := JupiterB(JD)
+	r := JupiterR(JD)
+	//	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	z := r*Sin(b) - er*Sin(eb)
+	return z
+}
+
+func AJupiterXYZ(JD float64) (float64, float64, float64) {
+	l := JupiterL(JD)
+	b := JupiterB(JD)
+	r := JupiterR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	z := r*Sin(b) - er*Sin(eb)
+	return x, y, z
+}
+
+func JupiterSeeRa(JD float64) float64 {
+	lo, bo := JupiterSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	return Limit360(ra)
+}
+func JupiterSeeDec(JD float64) float64 {
+	lo, bo := JupiterSeeLoBo(JD)
+	sita := Sita(JD)
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return dec
+}
+
+func JupiterSeeRaDec(JD float64) (float64, float64) {
+	lo, bo := JupiterSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return Limit360(ra), dec
+}
+
+func EarthJupiterAway(JD float64) float64 {
+	x, y, z := AJupiterXYZ(JD)
+	to := math.Sqrt(x*x + y*y + z*z)
+	return to
+}
+
+func JupiterSeeLo(JD float64) float64 {
+	x, y, z := AJupiterXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AJupiterXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo
+}
+
+func JupiterSeeBo(JD float64) float64 {
+	x, y, z := AJupiterXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AJupiterXYZ(JD - to)
+	//lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	//lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	//lo+=GXCLo(lo,bo,JD);
+	//bo+=GXCBo(lo,bo,JD)/3600;
+	//lo+=HJZD(JD);
+	return bo
+}
+
+func JupiterSeeLoBo(JD float64) (float64, float64) {
+	x, y, z := AJupiterXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AJupiterXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo, bo
+}
+
+func JupiterMag(JD float64) float64 {
+	AwaySun := JupiterR(JD)
+	AwayEarth := EarthJupiterAway(JD)
+	Away := planet.WherePlanet(-1, 2, JD)
+	i := (AwaySun*AwaySun + AwayEarth*AwayEarth - Away*Away) / (2 * AwaySun * AwayEarth)
+	i = ArcCos(i)
+	Mag := -9.40 + 5*math.Log10(AwaySun*AwayEarth) + 0.0005*i
+	return FloatRound(Mag, 2)
+}

basic/mars.go

@@ -0,0 +1,147 @@
+package basic
+
+import (
+	"math"
+
+	"b612.me/astro/planet"
+	. "b612.me/astro/tools"
+)
+
+func MarsL(JD float64) float64 {
+	return planet.WherePlanet(3, 0, JD)
+}
+
+func MarsB(JD float64) float64 {
+	return planet.WherePlanet(3, 1, JD)
+}
+func MarsR(JD float64) float64 {
+	return planet.WherePlanet(3, 2, JD)
+}
+func AMarsX(JD float64) float64 {
+	l := MarsL(JD)
+	b := MarsB(JD)
+	r := MarsR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	return x
+}
+
+func AMarsY(JD float64) float64 {
+
+	l := MarsL(JD)
+	b := MarsB(JD)
+	r := MarsR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	return y
+}
+func AMarsZ(JD float64) float64 {
+	//l := MarsL(JD)
+	b := MarsB(JD)
+	r := MarsR(JD)
+	//	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	z := r*Sin(b) - er*Sin(eb)
+	return z
+}
+
+func AMarsXYZ(JD float64) (float64, float64, float64) {
+	l := MarsL(JD)
+	b := MarsB(JD)
+	r := MarsR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	z := r*Sin(b) - er*Sin(eb)
+	return x, y, z
+}
+
+func MarsSeeRa(JD float64) float64 {
+	lo, bo := MarsSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	return Limit360(ra)
+}
+func MarsSeeDec(JD float64) float64 {
+	lo, bo := MarsSeeLoBo(JD)
+	sita := Sita(JD)
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return dec
+}
+
+func MarsSeeRaDec(JD float64) (float64, float64) {
+	lo, bo := MarsSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return Limit360(ra), dec
+}
+
+func EarthMarsAway(JD float64) float64 {
+	x, y, z := AMarsXYZ(JD)
+	to := math.Sqrt(x*x + y*y + z*z)
+	return to
+}
+
+func MarsSeeLo(JD float64) float64 {
+	x, y, z := AMarsXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMarsXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo
+}
+
+func MarsSeeBo(JD float64) float64 {
+	x, y, z := AMarsXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMarsXYZ(JD - to)
+	//lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	//lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	//lo+=GXCLo(lo,bo,JD);
+	//bo+=GXCBo(lo,bo,JD)/3600;
+	//lo+=HJZD(JD);
+	return bo
+}
+
+func MarsSeeLoBo(JD float64) (float64, float64) {
+	x, y, z := AMarsXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMarsXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo, bo
+}
+
+func MarsMag(JD float64) float64 {
+	AwaySun := MarsR(JD)
+	AwayEarth := EarthMarsAway(JD)
+	Away := planet.WherePlanet(-1, 2, JD)
+	i := (AwaySun*AwaySun + AwayEarth*AwayEarth - Away*Away) / (2 * AwaySun * AwayEarth)
+	i = ArcCos(i)
+	Mag := -1.52 + 5*math.Log10(AwaySun*AwayEarth) + 0.016*i
+	return FloatRound(Mag, 2)
+}

basic/mercury.go

@@ -0,0 +1,147 @@
+package basic
+
+import (
+	"math"
+
+	"b612.me/astro/planet"
+	. "b612.me/astro/tools"
+)
+
+func MercuryL(JD float64) float64 {
+	return planet.WherePlanet(1, 0, JD)
+}
+
+func MercuryB(JD float64) float64 {
+	return planet.WherePlanet(1, 1, JD)
+}
+func MercuryR(JD float64) float64 {
+	return planet.WherePlanet(1, 2, JD)
+}
+func AMercuryX(JD float64) float64 {
+	l := MercuryL(JD)
+	b := MercuryB(JD)
+	r := MercuryR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	return x
+}
+
+func AMercuryY(JD float64) float64 {
+
+	l := MercuryL(JD)
+	b := MercuryB(JD)
+	r := MercuryR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	return y
+}
+func AMercuryZ(JD float64) float64 {
+	//l := MercuryL(JD)
+	b := MercuryB(JD)
+	r := MercuryR(JD)
+	//	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	z := r*Sin(b) - er*Sin(eb)
+	return z
+}
+
+func AMercuryXYZ(JD float64) (float64, float64, float64) {
+	l := MercuryL(JD)
+	b := MercuryB(JD)
+	r := MercuryR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	z := r*Sin(b) - er*Sin(eb)
+	return x, y, z
+}
+
+func MercurySeeRa(JD float64) float64 {
+	lo, bo := MercurySeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	return Limit360(ra)
+}
+func MercurySeeDec(JD float64) float64 {
+	lo, bo := MercurySeeLoBo(JD)
+	sita := Sita(JD)
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return dec
+}
+
+func MercurySeeRaDec(JD float64) (float64, float64) {
+	lo, bo := MercurySeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return Limit360(ra), dec
+}
+
+func EarthMercuryAway(JD float64) float64 {
+	x, y, z := AMercuryXYZ(JD)
+	to := math.Sqrt(x*x + y*y + z*z)
+	return to
+}
+
+func MercurySeeLo(JD float64) float64 {
+	x, y, z := AMercuryXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMercuryXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo
+}
+
+func MercurySeeBo(JD float64) float64 {
+	x, y, z := AMercuryXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMercuryXYZ(JD - to)
+	//lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	//lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	//lo+=GXCLo(lo,bo,JD);
+	//bo+=GXCBo(lo,bo,JD)/3600;
+	//lo+=HJZD(JD);
+	return bo
+}
+
+func MercurySeeLoBo(JD float64) (float64, float64) {
+	x, y, z := AMercuryXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = AMercuryXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo, bo
+}
+
+func MercuryMag(JD float64) float64 {
+	AwaySun := MercuryR(JD)
+	AwayEarth := EarthMercuryAway(JD)
+	Away := planet.WherePlanet(-1, 2, JD)
+	i := (AwaySun*AwaySun + AwayEarth*AwayEarth - Away*Away) / (2 * AwaySun * AwayEarth)
+	i = ArcCos(i)
+	Mag := -0.42 + 5*math.Log10(AwaySun*AwayEarth) + 0.0380*i - 0.000273*i*i + 0.000002*i*i*i
+	return FloatRound(Mag, 2)
+}

basic/moon_test.go

@@ -0,0 +1,18 @@
+package basic
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func Test_MoonS(t *testing.T) {
+	//fmt.Println(Sita(2451547))
+	//fmt.Println(MoonHeight(2451547, 115, 32, 8))
+	a := time.Now().UnixNano()
+	b := GetMoonRiseTime(GetNowJDE(), 115, 32, 8, 0)
+	fmt.Println(time.Now().UnixNano() - a)
+	fmt.Println(JDE2Date((b)))
+	fmt.Println(time.Now().UnixNano() - a)
+	//fmt.Printf("%.14f", GetMoonRiseTime(2451547, 115, 32, 8, 0))
+}

basic/neptune.go

@@ -0,0 +1,147 @@
+package basic
+
+import (
+	"math"
+
+	"b612.me/astro/planet"
+	. "b612.me/astro/tools"
+)
+
+func NeptuneL(JD float64) float64 {
+	return planet.WherePlanet(7, 0, JD)
+}
+
+func NeptuneB(JD float64) float64 {
+	return planet.WherePlanet(7, 1, JD)
+}
+func NeptuneR(JD float64) float64 {
+	return planet.WherePlanet(7, 2, JD)
+}
+func ANeptuneX(JD float64) float64 {
+	l := NeptuneL(JD)
+	b := NeptuneB(JD)
+	r := NeptuneR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	return x
+}
+
+func ANeptuneY(JD float64) float64 {
+
+	l := NeptuneL(JD)
+	b := NeptuneB(JD)
+	r := NeptuneR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	return y
+}
+func ANeptuneZ(JD float64) float64 {
+	//l := NeptuneL(JD)
+	b := NeptuneB(JD)
+	r := NeptuneR(JD)
+	//	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	z := r*Sin(b) - er*Sin(eb)
+	return z
+}
+
+func ANeptuneXYZ(JD float64) (float64, float64, float64) {
+	l := NeptuneL(JD)
+	b := NeptuneB(JD)
+	r := NeptuneR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	y := r*Cos(b)*Sin(l) - er*Cos(eb)*Sin(el)
+	z := r*Sin(b) - er*Sin(eb)
+	return x, y, z
+}
+
+func NeptuneSeeRa(JD float64) float64 {
+	lo, bo := NeptuneSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	return Limit360(ra)
+}
+func NeptuneSeeDec(JD float64) float64 {
+	lo, bo := NeptuneSeeLoBo(JD)
+	sita := Sita(JD)
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return dec
+}
+
+func NeptuneSeeRaDec(JD float64) (float64, float64) {
+	lo, bo := NeptuneSeeLoBo(JD)
+	sita := Sita(JD)
+	ra := math.Atan2((Sin(lo)*Cos(sita) - Tan(bo)*Sin(sita)), Cos(lo))
+	ra = ra * 180 / math.Pi
+	dec := ArcSin(Sin(bo)*Cos(sita) + Cos(bo)*Sin(sita)*Sin(lo))
+	return Limit360(ra), dec
+}
+
+func EarthNeptuneAway(JD float64) float64 {
+	x, y, z := ANeptuneXYZ(JD)
+	to := math.Sqrt(x*x + y*y + z*z)
+	return to
+}
+
+func NeptuneSeeLo(JD float64) float64 {
+	x, y, z := ANeptuneXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = ANeptuneXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo
+}
+
+func NeptuneSeeBo(JD float64) float64 {
+	x, y, z := ANeptuneXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = ANeptuneXYZ(JD - to)
+	//lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	//lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	//lo+=GXCLo(lo,bo,JD);
+	//bo+=GXCBo(lo,bo,JD)/3600;
+	//lo+=HJZD(JD);
+	return bo
+}
+
+func NeptuneSeeLoBo(JD float64) (float64, float64) {
+	x, y, z := ANeptuneXYZ(JD)
+	to := 0.0057755183 * math.Sqrt(x*x+y*y+z*z)
+	x, y, z = ANeptuneXYZ(JD - to)
+	lo := math.Atan2(y, x)
+	bo := math.Atan2(z, math.Sqrt(x*x+y*y))
+	lo = lo * 180 / math.Pi
+	bo = bo * 180 / math.Pi
+	lo = Limit360(lo)
+	//lo-=GXCLo(lo,bo,JD)/3600;
+	//bo+=GXCBo(lo,bo,JD);
+	lo += HJZD(JD)
+	return lo, bo
+}
+
+func NeptuneMag(JD float64) float64 {
+	AwaySun := NeptuneR(JD)
+	AwayEarth := EarthNeptuneAway(JD)
+	Away := planet.WherePlanet(-1, 2, JD)
+	i := (AwaySun*AwaySun + AwayEarth*AwayEarth - Away*Away) / (2 * AwaySun * AwayEarth)
+	i = ArcCos(i)
+	Mag := -6.87 + 5*math.Log10(AwaySun*AwayEarth)
+	return FloatRound(Mag, 2)
+}

basic/planet_test.go

@@ -0,0 +1,15 @@
+package basic
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_Ra(t *testing.T) {
+	ra, dec := UranusSeeRaDec(2456789.12345)
+	fmt.Printf("%.14f\n%.14f\n", ra, dec)
+	fmt.Println(UranusMag(2456789.12345))
+	ra, dec = NeptuneSeeRaDec(2456789.12345)
+	fmt.Printf("%.14f\n%.14f\n", ra, dec)
+	fmt.Println(NeptuneMag(2456789.12345))
+}

basic/saturn.go

@@ -0,0 +1,156 @@
+package basic
+
+import (
+	"math"
+
+	"b612.me/astro/planet"
+	. "b612.me/astro/tools"
+)
+
+func SaturnL(JD float64) float64 {
+	return planet.WherePlanet(5, 0, JD)
+}
+
+func SaturnB(JD float64) float64 {
+	return planet.WherePlanet(5, 1, JD)
+}
+func SaturnR(JD float64) float64 {
+	return planet.WherePlanet(5, 2, JD)
+}
+func ASaturnX(JD float64) float64 {
+	l := SaturnL(JD)
+	b := SaturnB(JD)
+	r := SaturnR(JD)
+	el := planet.WherePlanet(-1, 0, JD)
+	eb := planet.WherePlanet(-1, 1, JD)
+	er := planet.WherePlanet(-1, 2, JD)
+	x := r*Cos(b)*Cos(l) - er*Cos(eb)*Cos(el)
+	return x
+}
+
+func ASaturnY(JD float64) float64 {
+
+	l := SaturnL(JD)