b612
72460fa228
- 将星表名称数据收敛为 TSV/GZIP 单一数据源，补充中文名、别名、英文常用名及宿/垣区域字段 - 增加星表名称表加载校验、旧详情字段一致性校验和 GZIP 漂移检查 - 新增 StarDataByName、StarDataByNameAll、StarDataByNameIn ，统一中英文查询与重名消歧 - 优化日月食半影带、升落曲线和可见性回归测试，补充极区、拓扑及低精度场景覆盖 - 增加 Go 1.16/386 兼容门禁和测试案例，处理旧工具链的分配、拓扑、SVG字节及 ULP 差异 - 补充星表、坐标、日月食和低精度回归用例，完善测试文件与缓存忽略规则
181 lines
9.4 KiB
Go
181 lines
9.4 KiB
Go
// 低精度日月基线与高精度派生量的 n 截断收敛契约。
|
|
package astro_test
|
|
|
|
import (
|
|
"encoding/json"
|
|
"math"
|
|
"os"
|
|
"testing"
|
|
|
|
"b612.me/astro/basic"
|
|
"b612.me/astro/planet"
|
|
|
|
"b612.me/astro/internal/ephemtest"
|
|
)
|
|
|
|
type lowPrecisionSunSnapshot struct {
|
|
LoBits uint64 `json:"lo_bits"`
|
|
MBits uint64 `json:"m_bits"`
|
|
EccBits uint64 `json:"ecc_bits"`
|
|
PeriBits uint64 `json:"peri_bits"`
|
|
MidBits uint64 `json:"mid_bits"`
|
|
TrueLoBits uint64 `json:"true_lo_bits"`
|
|
ApparentLoBits uint64 `json:"apparent_lo_bits"`
|
|
ApparentRaBits uint64 `json:"apparent_ra_bits"`
|
|
ApparentDecBits uint64 `json:"apparent_dec_bits"`
|
|
TrueRaBits uint64 `json:"true_ra_bits"`
|
|
TrueDecBits uint64 `json:"true_dec_bits"`
|
|
DistanceBits uint64 `json:"distance_bits"`
|
|
}
|
|
|
|
type lowPrecisionMoonSnapshot struct {
|
|
LoBits uint64 `json:"lo_bits"`
|
|
SunAngleBits uint64 `json:"sun_angle_bits"`
|
|
MBits uint64 `json:"m_bits"`
|
|
LonXBits uint64 `json:"lonx_bits"`
|
|
IBits uint64 `json:"i_bits"`
|
|
RBits uint64 `json:"r_bits"`
|
|
BBits uint64 `json:"b_bits"`
|
|
TrueLoBits uint64 `json:"true_lo_bits"`
|
|
TrueBoBits uint64 `json:"true_bo_bits"`
|
|
AwayBits uint64 `json:"away_bits"`
|
|
ApparentLoBits uint64 `json:"apparent_lo_bits"`
|
|
TrueRaBits uint64 `json:"true_ra_bits"`
|
|
TrueDecBits uint64 `json:"true_dec_bits"`
|
|
}
|
|
|
|
type lowPrecisionSample struct {
|
|
UTC string `json:"utc"`
|
|
TTJD float64 `json:"tt_jd"`
|
|
Sun lowPrecisionSunSnapshot `json:"sun"`
|
|
Moon lowPrecisionMoonSnapshot `json:"moon"`
|
|
}
|
|
|
|
func loadLowPrecisionSamples(t *testing.T) []lowPrecisionSample {
|
|
t.Helper()
|
|
|
|
data, err := os.ReadFile("testdata/low_precision_sun_moon_baseline.json")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
var samples []lowPrecisionSample
|
|
if err := json.Unmarshal(data, &samples); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(samples) == 0 {
|
|
t.Fatal("empty low precision baseline samples")
|
|
}
|
|
return samples
|
|
}
|
|
|
|
func TestLowPrecisionSunMoonBaselineRegression(t *testing.T) {
|
|
samples := loadLowPrecisionSamples(t)
|
|
|
|
assertBits := func(t *testing.T, name, utc string, got float64, want uint64) {
|
|
t.Helper()
|
|
if math.Float64bits(got) == want {
|
|
return
|
|
}
|
|
// Go 1.16/386 的超越函数可能差 1 ULP；该组合按 1e-12 度放行。
|
|
if go116386() && math.Abs(got-math.Float64frombits(want)) <= 1e-12 {
|
|
return
|
|
}
|
|
t.Fatalf("%s regression at %s", name, utc)
|
|
}
|
|
|
|
for _, sample := range samples {
|
|
jd := sample.TTJD
|
|
|
|
assertBits(t, "planet.SunLo", sample.UTC, planet.SunLo(jd), sample.Sun.LoBits)
|
|
assertBits(t, "basic.SunLo", sample.UTC, basic.SunLo(jd), sample.Sun.LoBits)
|
|
assertBits(t, "planet.SunM", sample.UTC, planet.SunM(jd), sample.Sun.MBits)
|
|
assertBits(t, "basic.SunM", sample.UTC, basic.SunM(jd), sample.Sun.MBits)
|
|
assertBits(t, "planet.Earthe", sample.UTC, planet.Earthe(jd), sample.Sun.EccBits)
|
|
assertBits(t, "basic.Earthe", sample.UTC, basic.Earthe(jd), sample.Sun.EccBits)
|
|
assertBits(t, "planet.EarthPI", sample.UTC, planet.EarthPI(jd), sample.Sun.PeriBits)
|
|
assertBits(t, "basic.EarthPI", sample.UTC, basic.EarthPI(jd), sample.Sun.PeriBits)
|
|
assertBits(t, "planet.SunMidFun", sample.UTC, planet.SunMidFun(jd), sample.Sun.MidBits)
|
|
assertBits(t, "basic.SunMidFun", sample.UTC, basic.SunMidFun(jd), sample.Sun.MidBits)
|
|
assertBits(t, "planet.SunTrueLo", sample.UTC, planet.SunTrueLo(jd), sample.Sun.TrueLoBits)
|
|
assertBits(t, "basic.SunTrueLo", sample.UTC, basic.SunTrueLo(jd), sample.Sun.TrueLoBits)
|
|
assertBits(t, "planet.SunApparentLo", sample.UTC, planet.SunApparentLo(jd), sample.Sun.ApparentLoBits)
|
|
assertBits(t, "basic.SunApparentLo", sample.UTC, basic.SunApparentLo(jd), sample.Sun.ApparentLoBits)
|
|
assertBits(t, "basic.SunApparentRa", sample.UTC, basic.SunApparentRa(jd), sample.Sun.ApparentRaBits)
|
|
assertBits(t, "basic.SunApparentDec", sample.UTC, basic.SunApparentDec(jd), sample.Sun.ApparentDecBits)
|
|
assertBits(t, "basic.SunTrueRa", sample.UTC, basic.SunTrueRa(jd), sample.Sun.TrueRaBits)
|
|
assertBits(t, "basic.SunTrueDec", sample.UTC, basic.SunTrueDec(jd), sample.Sun.TrueDecBits)
|
|
assertBits(t, "planet.Distance", sample.UTC, planet.Distance(jd), sample.Sun.DistanceBits)
|
|
assertBits(t, "basic.Distance", sample.UTC, basic.Distance(jd), sample.Sun.DistanceBits)
|
|
assertBits(t, "planet.MoonLo", sample.UTC, planet.MoonLo(jd), sample.Moon.LoBits)
|
|
assertBits(t, "basic.MoonLo", sample.UTC, basic.MoonLo(jd), sample.Moon.LoBits)
|
|
assertBits(t, "planet.SunMoonAngle", sample.UTC, planet.SunMoonAngle(jd), sample.Moon.SunAngleBits)
|
|
assertBits(t, "basic.SunMoonAngle", sample.UTC, basic.SunMoonAngle(jd), sample.Moon.SunAngleBits)
|
|
assertBits(t, "planet.MoonM", sample.UTC, planet.MoonM(jd), sample.Moon.MBits)
|
|
assertBits(t, "basic.MoonM", sample.UTC, basic.MoonM(jd), sample.Moon.MBits)
|
|
assertBits(t, "planet.MoonLonX", sample.UTC, planet.MoonLonX(jd), sample.Moon.LonXBits)
|
|
assertBits(t, "basic.MoonLonX", sample.UTC, basic.MoonLonX(jd), sample.Moon.LonXBits)
|
|
assertBits(t, "planet.MoonI", sample.UTC, planet.MoonI(jd), sample.Moon.IBits)
|
|
assertBits(t, "basic.MoonI", sample.UTC, basic.MoonI(jd), sample.Moon.IBits)
|
|
assertBits(t, "planet.MoonR", sample.UTC, planet.MoonR(jd), sample.Moon.RBits)
|
|
assertBits(t, "basic.MoonR", sample.UTC, basic.MoonR(jd), sample.Moon.RBits)
|
|
assertBits(t, "planet.MoonB", sample.UTC, planet.MoonB(jd), sample.Moon.BBits)
|
|
assertBits(t, "basic.MoonB", sample.UTC, basic.MoonB(jd), sample.Moon.BBits)
|
|
assertBits(t, "planet.MoonTrueLo", sample.UTC, planet.MoonTrueLo(jd), sample.Moon.TrueLoBits)
|
|
assertBits(t, "basic.MoonTrueLo", sample.UTC, basic.MoonTrueLo(jd), sample.Moon.TrueLoBits)
|
|
assertBits(t, "planet.MoonTrueBo", sample.UTC, planet.MoonTrueBo(jd), sample.Moon.TrueBoBits)
|
|
assertBits(t, "basic.MoonTrueBo", sample.UTC, basic.MoonTrueBo(jd), sample.Moon.TrueBoBits)
|
|
assertBits(t, "planet.MoonAway", sample.UTC, planet.MoonAway(jd), sample.Moon.AwayBits)
|
|
assertBits(t, "basic.MoonAway", sample.UTC, basic.MoonAway(jd), sample.Moon.AwayBits)
|
|
assertBits(t, "basic.MoonApparentLo", sample.UTC, basic.MoonApparentLo(jd), sample.Moon.ApparentLoBits)
|
|
assertBits(t, "basic.MoonTrueRa", sample.UTC, basic.MoonTrueRa(jd), sample.Moon.TrueRaBits)
|
|
assertBits(t, "basic.MoonTrueDec", sample.UTC, basic.MoonTrueDec(jd), sample.Moon.TrueDecBits)
|
|
}
|
|
}
|
|
|
|
func derivedTruncationCases(samples []lowPrecisionSample) []truncationCase {
|
|
jdOf := func(index int) float64 { return samples[index].TTJD }
|
|
lon := 116.391
|
|
lat := 39.907
|
|
tz := 8.0
|
|
// withSite 把带观测点经纬度与时区的入口适配成 jd 探针。
|
|
withSite := func(f func(jd, lon, lat, tz float64, n int) float64) func(float64, int) float64 {
|
|
return func(jd float64, n int) float64 { return f(jd, lon, lat, tz, n) }
|
|
}
|
|
withSiteRaDec := func(f func(jd, lon, lat, tz float64, n int) (float64, float64)) func(float64, int) (float64, float64) {
|
|
return func(jd float64, n int) (float64, float64) { return f(jd, lon, lat, tz, n) }
|
|
}
|
|
|
|
// 上限按 48 个采样点实测最坏值放宽 5 倍以上给出，随 n 递减。
|
|
return []truncationCase{
|
|
scalarTruncation("HSunTrueLoN", jdOf, basic.HSunTrueLoN, true, []float64{0.15, 0.05, 0.02, 0.006}),
|
|
scalarTruncation("HSunTrueBoN", jdOf, basic.HSunTrueBoN, true, []float64{1e-3, 5e-4, 3e-4, 1.5e-4}),
|
|
scalarTruncation("HSunApparentLoN", jdOf, basic.HSunApparentLoN, true, []float64{0.15, 0.05, 0.02, 0.006}),
|
|
scalarTruncation("SunLoGXCN", jdOf, basic.SunLoGXCN, true, []float64{1e-5, 2e-6, 1e-6, 3e-7}),
|
|
scalarTruncation("EarthAwayN", jdOf, basic.EarthAwayN, false, []float64{1e-3, 3e-4, 1e-4, 3e-5}),
|
|
scalarTruncation("HSunApparentRaN", jdOf, basic.HSunApparentRaN, true, []float64{0.15, 0.05, 0.02, 0.006}),
|
|
scalarTruncation("HSunTrueRaN", jdOf, basic.HSunTrueRaN, true, []float64{0.15, 0.05, 0.02, 0.006}),
|
|
scalarTruncation("HSunApparentDecN", jdOf, basic.HSunApparentDecN, true, []float64{0.05, 0.02, 0.008, 0.003}),
|
|
scalarTruncation("HSunTrueDecN", jdOf, basic.HSunTrueDecN, true, []float64{0.05, 0.02, 0.008, 0.003}),
|
|
pairTruncation("HSunApparentRaDecN", jdOf, basic.HSunApparentRaDecN, []float64{0.15, 0.05, 0.02, 0.006}),
|
|
scalarTruncation("HMoonTrueLoN", jdOf, basic.HMoonTrueLoN, true, []float64{5, 2.5, 1, 0.25}),
|
|
scalarTruncation("HMoonTrueBoN", jdOf, basic.HMoonTrueBoN, true, []float64{3, 0.75, 0.15, 0.06}),
|
|
scalarTruncation("HMoonAwayN", jdOf, basic.HMoonAwayN, false, []float64{40000, 7000, 2500, 400}),
|
|
scalarTruncation("HMoonApparentLoN", jdOf, basic.HMoonApparentLoN, true, []float64{5, 2.5, 1, 0.25}),
|
|
scalarTruncation("HMoonTrueRaN", jdOf, basic.HMoonTrueRaN, true, []float64{5, 2.5, 1, 0.3}),
|
|
scalarTruncation("HMoonTrueDecN", jdOf, basic.HMoonTrueDecN, true, []float64{3, 1, 0.4, 0.1}),
|
|
pairTruncation("HMoonTrueRaDecN", jdOf, basic.HMoonTrueRaDecN, []float64{5, 2.5, 1, 0.3}),
|
|
scalarTruncation("HMoonApparentRaN", jdOf, withSite(basic.HMoonApparentRaN), true, []float64{5, 2.5, 1, 0.3}),
|
|
scalarTruncation("HMoonApparentDecN", jdOf, withSite(basic.HMoonApparentDecN), true, []float64{4, 1, 0.3, 0.1}),
|
|
pairTruncation("HMoonApparentRaDecN", jdOf, withSiteRaDec(basic.HMoonApparentRaDecN), []float64{5, 2.5, 1, 0.3}),
|
|
scalarTruncation("HMoonAzimuthN", jdOf, withSite(basic.HMoonAzimuthN), true, []float64{9, 4, 2, 0.9}),
|
|
scalarTruncation("HMoonHeightN", jdOf, withSite(basic.HMoonHeightN), true, []float64{4, 2, 0.7, 0.15}),
|
|
}
|
|
}
|
|
|
|
func TestDerivedHighPrecisionTruncationConverges(t *testing.T) {
|
|
ephemtest.PinLegacy(t)
|
|
samples := loadLowPrecisionSamples(t)
|
|
assertTruncationConverges(t, derivedTruncationCases(samples), len(samples))
|
|
}
|