astro/planet/spk/spk.go

package spk

import (
	"encoding/binary"
	"errors"
	"fmt"
	"math"
	"os"
	"sync"

	"b612.me/astro/internal/ephem"
)

const (
	dafRecordBytes  = 1024
	dafFileHeadSize = 1024
	dafND           = 2
	dafNI           = 6
	dafSummaryWords = dafND + (dafNI+1)/2
	dafSummaryBytes = dafSummaryWords * 8
	dafHeaderWords  = 3
	dafWordBytes    = 8
	spkJ2000        = 2451545.0
	spkSecondsDay   = 86400.0
	spkCacheRecords = 16
)

var (
	// ErrInvalidFile 无效 SPK 文件 / invalid SPK file.
	ErrInvalidFile = errors.New("spk: invalid DAF/SPK file")
	// ErrUnsupportedFrame 不支持的参考框架 / unsupported reference frame.
	ErrUnsupportedFrame = errors.New("spk: unsupported reference frame")
	// ErrUnsupportedType 不支持的段类型 / unsupported segment type.
	ErrUnsupportedType = errors.New("spk: unsupported SPK data type")
	// ErrClosed 文件已关闭 / file is closed.
	ErrClosed     = errors.New("spk: file is closed")
	errInvalidDAF = ErrInvalidFile
	errClosed     = ErrClosed
)

// Body NAIF 天体编号 / NAIF body identifier.
type Body = ephem.Body

const (
	// SSB 太阳系质心 / solar-system barycenter.
	SSB = ephem.SSB
	// Mercury 水星 / Mercury.
	Mercury = ephem.Mercury
	// Venus 金星 / Venus.
	Venus = ephem.Venus
	// EMB 地月质心 / Earth-Moon barycenter.
	EMB = ephem.EMB
	// Mars 火星 / Mars.
	Mars = ephem.Mars
	// Jupiter 木星 / Jupiter.
	Jupiter = ephem.Jupiter
	// Saturn 土星 / Saturn.
	Saturn = ephem.Saturn
	// Uranus 天王星 / Uranus.
	Uranus = ephem.Uranus
	// Neptune 海王星 / Neptune.
	Neptune = ephem.Neptune
	// Sun 太阳 / the Sun.
	Sun = ephem.Sun
	// Moon 月球 / the Moon.
	Moon = ephem.Moon
	// Earth 地球 / Earth.
	Earth = ephem.Earth
)

// Segment 描述一个支持的 SPK 段 / describes a supported SPK segment.
type Segment struct {
	Target Body
	Center Body
	Frame  int
	Type   int
	Start  float64
	End    float64
}

type summarySegment struct {
	target         Body
	center         Body
	frame          int
	dataType       int
	startET        float64
	endET          float64
	startWord      int64
	endWord        int64
	initET         float64
	interval       float64
	recordSize     int
	records        int
	maxDim         int
	distanceScale  float64
	timeScale      float64
	initJD         float64
	initFR         float64
	epochStartWord int64
	directoryCount int
	cacheMu        sync.Mutex
	cache          map[int][]float64
	cacheOrder     []int
	owner          *File
}

// File 只读 SPK 文件 / read-only SPK file.
type File struct {
	mu       sync.RWMutex
	file     *os.File
	order    binary.ByteOrder
	segments []*summarySegment
	known    map[Body]bool
	closed   bool
	size     int64
}

// Open 打开并解析 SPK 文件 / opens and indexes an SPK file.
func Open(path string) (*File, error) {
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	spk := &File{file: f, known: make(map[Body]bool)}
	stat, err := f.Stat()
	if err != nil {
		_ = f.Close()
		return nil, err
	}
	spk.size = stat.Size()
	if err := spk.index(); err != nil {
		_ = f.Close()
		return nil, err
	}
	return spk, nil
}

// Load Open 的别名 / alias for Open.
func Load(path string) (*File, error) { return Open(path) }

// Close 关闭文件 / closes the file.
func (s *File) Close() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	if s.closed {
		return nil
	}
	s.closed = true
	return s.file.Close()
}

// Segments 返回支持段的快照 / returns a snapshot of supported segments.
func (s *File) Segments() []Segment {
	s.mu.RLock()
	defer s.mu.RUnlock()
	result := make([]Segment, 0, len(s.segments))
	for _, segment := range s.segments {
		result = append(result, Segment{
			Target: segment.target,
			Center: segment.center,
			Frame:  segment.frame,
			Type:   segment.dataType,
			Start:  spkJ2000 + segment.startET/spkSecondsDay,
			End:    spkJ2000 + segment.endET/spkSecondsDay,
		})
	}
	return result
}

// Coverage 返回天体覆盖的 TDB 儒略日范围 / returns the body's TDB Julian-date coverage.
func (s *File) Coverage(target Body) (start, end float64, ok bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	if s.closed {
		return 0, 0, false
	}
	for _, segment := range s.segments {
		if segment.target != target || segment.frame != 1 {
			continue
		}
		segmentStart := spkJ2000 + segment.startET/spkSecondsDay
		segmentEnd := spkJ2000 + segment.endET/spkSecondsDay
		if !ok || segmentStart < start {
			start = segmentStart
		}
		if !ok || segmentEnd > end {
			end = segmentEnd
		}
		ok = true
	}
	return start, end, ok
}

// Bodies 返回文件中出现的天体编号 / returns body identifiers present in the file.
func (s *File) Bodies() []Body {
	s.mu.RLock()
	defer s.mu.RUnlock()
	if s.closed {
		return nil
	}
	result := make([]Body, 0, len(s.known))
	for body := range s.known {
		result = append(result, body)
	}
	return result
}

// State 返回目标相对中心的 ICRF 状态，速度为 km/日 / returns an ICRF state, with velocity in km/day.
func (s *File) State(target, center Body, jdTDB float64) (pos, vel [3]float64, err error) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	if s.closed {
		return pos, vel, errClosed
	}
	if math.IsNaN(jdTDB) || math.IsInf(jdTDB, 0) {
		return pos, vel, ephem.ErrOutOfRange
	}
	if target == center {
		return pos, vel, nil
	}
	return s.composeState(target, center, jdTDB)
}

func (s *File) index() error {
	header := make([]byte, dafFileHeadSize)
	if _, err := s.file.ReadAt(header, 0); err != nil {
		return err
	}
	if string(header[:8]) != "DAF/SPK " {
		return errInvalidDAF
	}
	order, err := byteOrderFor(string(header[88:96]))
	if err != nil {
		return err
	}
	s.order = order
	if int32Value(s.order, header, 8) != dafND || int32Value(s.order, header, 12) != dafNI {
		return fmt.Errorf("%w: ND/NI must be 2/6", errInvalidDAF)
	}
	first := int(int32Value(s.order, header, 76))
	last := int(int32Value(s.order, header, 80))
	if first < 2 || last < 2 || int64(first)*dafRecordBytes > s.size || int64(last)*dafRecordBytes > s.size {
		return fmt.Errorf("%w: invalid summary record range", errInvalidDAF)
	}
	seen := make(map[int]bool)
	previous := 0
	supported := 0
	for record := first; record != 0; {
		if seen[record] {
			return fmt.Errorf("%w: cyclic summary record chain", errInvalidDAF)
		}
		seen[record] = true
		data, err := s.readRecord(record)
		if err != nil {
			return err
		}
		nextValue := float64Value(s.order, data[0:8])
		previousValue := float64Value(s.order, data[8:16])
		countValue := float64Value(s.order, data[16:24])
		if !validInteger(nextValue, 0, s.size/dafRecordBytes) || previousValue != float64(previous) || !validInteger(countValue, 0, (dafRecordBytes-24)/dafSummaryBytes) {
			return fmt.Errorf("%w: invalid summary controls", errInvalidDAF)
		}
		next, count := int(nextValue), int(countValue)
		if next == 0 && record != last {
			return fmt.Errorf("%w: final summary disagrees with backward pointer", errInvalidDAF)
		}
		for index := 0; index < count; index++ {
			base := dafHeaderWords*8 + index*dafSummaryBytes
			segment, err := s.parseSummary(data[base : base+dafSummaryBytes])
			if err != nil {
				return err
			}
			if segment.frame == 1 && (segment.dataType == 2 || segment.dataType == 3 || segment.dataType == 20 || segment.dataType == 21) {
				if err := segment.loadMeta(s); err != nil {
					return err
				}
				supported++
			} else {
				continue
			}
			s.segments = append(s.segments, segment)
			s.known[segment.target] = true
			s.known[segment.center] = true
		}
		previous, record = record, next
	}
	if supported == 0 {
		return fmt.Errorf("%w: no supported J2000 segments", errInvalidDAF)
	}
	return nil
}

func (s *File) parseSummary(data []byte) (*summarySegment, error) {
	if len(data) != dafSummaryBytes {
		return nil, errInvalidDAF
	}
	segment := &summarySegment{
		startET:   float64Value(s.order, data[0:8]),
		endET:     float64Value(s.order, data[8:16]),
		target:    Body(int32Value(s.order, data, 16)),
		center:    Body(int32Value(s.order, data, 20)),
		frame:     int(int32Value(s.order, data, 24)),
		dataType:  int(int32Value(s.order, data, 28)),
		startWord: int64(int32Value(s.order, data, 32)),
		endWord:   int64(int32Value(s.order, data, 36)),
		cache:     make(map[int][]float64),
		owner:     s,
	}
	if !finite(segment.startET) || !finite(segment.endET) || segment.endET < segment.startET || segment.startWord < 1 || segment.endWord < segment.startWord || segment.endWord > s.size/dafWordBytes {
		return nil, fmt.Errorf("%w: invalid segment summary", errInvalidDAF)
	}
	return segment, nil
}

func (segment *summarySegment) loadMeta(s *File) error {
	if segment.endWord-segment.startWord+1 < 4 {
		return fmt.Errorf("%w: segment trailer is missing", errInvalidDAF)
	}
	if segment.dataType == 20 {
		trailer, err := s.readWords(segment.endWord-6, 7)
		if err != nil {
			return err
		}
		if !finitePositive(trailer[0]) || !finitePositive(trailer[1]) || !finite(trailer[2]) || math.Abs(trailer[3]) >= 1 || !finitePositive(trailer[4]) || !validInteger(trailer[5], 6, segment.endWord-segment.startWord) || !validInteger(trailer[6], 1, segment.endWord-segment.startWord) {
			return fmt.Errorf("%w: invalid type 20 trailer", errInvalidDAF)
		}
		segment.distanceScale = trailer[0]
		segment.timeScale = trailer[1]
		segment.initJD = trailer[2]
		segment.initFR = trailer[3]
		segment.interval = trailer[4]
		segment.recordSize = int(trailer[5])
		segment.records = int(trailer[6])
		wordCount := segment.endWord - segment.startWord - 6
		if int64(segment.recordSize)*int64(segment.records) != wordCount || segment.recordSize < 6 || segment.recordSize%3 != 0 {
			return fmt.Errorf("%w: invalid type 20 record size", errInvalidDAF)
		}
		return nil
	}
	if segment.dataType == 21 {
		trailer, err := s.readWords(segment.endWord-1, 2)
		if err != nil {
			return err
		}
		if !validInteger(trailer[0], 1, 25) || !validInteger(trailer[1], 1, segment.endWord-segment.startWord) {
			return fmt.Errorf("%w: invalid type 21 trailer", errInvalidDAF)
		}
		segment.maxDim = int(trailer[0])
		segment.recordSize = 4*segment.maxDim + 11
		segment.records = int(trailer[1])
		segment.epochStartWord = segment.startWord + int64(segment.recordSize*segment.records)
		segment.directoryCount = segment.records / 100
		wordCount := segment.endWord - segment.startWord + 1
		want := int64(segment.recordSize*segment.records + segment.records + segment.directoryCount + 2)
		if want != wordCount {
			return fmt.Errorf("%w: invalid type 21 segment size", errInvalidDAF)
		}
		return nil
	}
	trailerWords := segment.endWord - 3
	trailer, err := s.readWords(trailerWords, 4)
	if err != nil {
		return err
	}
	segment.initET = trailer[0]
	segment.interval = trailer[1]
	wordCount := segment.endWord - segment.startWord - 3
	if !finite(segment.initET) || !finitePositive(segment.interval) || !validInteger(trailer[2], 5, wordCount) || !validInteger(trailer[3], 1, wordCount) {
		return fmt.Errorf("%w: invalid type %d trailer", errInvalidDAF, segment.dataType)
	}
	segment.recordSize = int(trailer[2])
	segment.records = int(trailer[3])
	if int64(segment.recordSize)*int64(segment.records) != wordCount {
		return fmt.Errorf("%w: invalid type %d trailer", errInvalidDAF, segment.dataType)
	}
	components := 3
	if segment.dataType == 3 {
		components = 6
	}
	if (segment.recordSize-2)%components != 0 || (segment.recordSize-2)/components < 1 {
		return fmt.Errorf("%w: invalid type %d record size %d", errInvalidDAF, segment.dataType, segment.recordSize)
	}
	return nil
}

func chosenSegment(segment *summarySegment) (*summarySegment, error) {
	if segment == nil {
		return nil, ephem.ErrOutOfRange
	}
	if segment.frame != 1 {
		return nil, ErrUnsupportedFrame
	}
	if segment.dataType != 2 && segment.dataType != 3 && segment.dataType != 20 && segment.dataType != 21 {
		return nil, ErrUnsupportedType
	}
	return segment, nil
}

type stateEdge struct {
	to      Body
	segment *summarySegment
	reverse bool
}

func (s *File) composeState(target, center Body, jdTDB float64) (pos, vel [3]float64, err error) {
	if !s.known[target] || !s.known[center] {
		return pos, vel, ephem.ErrUnsupportedBody
	}
	// 一次倒序扫描求出每个目标在 jdTDB 处覆盖它的最后一段，后加载的段优先。
	chosen := make(map[Body]*summarySegment)
	for index := len(s.segments) - 1; index >= 0; index-- {
		segment := s.segments[index]
		if _, ok := chosen[segment.target]; ok {
			continue
		}
		if jdTDB >= spkJ2000+segment.startET/spkSecondsDay && jdTDB <= spkJ2000+segment.endET/spkSecondsDay {
			chosen[segment.target] = segment
		}
	}
	graph := make(map[Body][]stateEdge)
	selected := make(map[Body]bool)
	for index := len(s.segments) - 1; index >= 0; index-- {
		segment := s.segments[index]
		if selected[segment.target] {
			continue
		}
		current, selectErr := chosenSegment(chosen[segment.target])
		if selectErr != nil {
			// 覆盖缺口留到 BFS 结束再报：别的路径仍可能连通。
			if selectErr != ephem.ErrOutOfRange && (segment.target == target || segment.target == center) {
				return pos, vel, selectErr
			}
			continue
		}
		segment = current
		selected[segment.target] = true
		graph[segment.target] = append(graph[segment.target], stateEdge{to: segment.center, segment: segment})
		graph[segment.center] = append(graph[segment.center], stateEdge{to: segment.target, segment: segment, reverse: true})
	}
	type node struct {
		body Body
		pos  [3]float64
		vel  [3]float64
	}
	queue := []node{{body: target}}
	visited := map[Body]bool{target: true}
	for head := 0; head < len(queue); head++ {
		current := queue[head]
		if current.body == center {
			return current.pos, current.vel, nil
		}
		for _, edge := range graph[current.body] {
			if visited[edge.to] {
				continue
			}
			edgePos, edgeVel, edgeErr := edge.segment.state(jdTDB)
			if edgeErr != nil {
				return pos, vel, edgeErr
			}
			if edge.reverse {
				negateVector(&edgePos)
				negateVector(&edgeVel)
			}
			addVector(&edgePos, current.pos)
			addVector(&edgeVel, current.vel)
			visited[edge.to] = true
			queue = append(queue, node{body: edge.to, pos: edgePos, vel: edgeVel})
		}
	}
	return pos, vel, ephem.ErrOutOfRange
}

func (segment *summarySegment) state(jdTDB float64) (pos, vel [3]float64, err error) {
	if segment.dataType == 20 {
		return segment.stateType20(jdTDB)
	}
	if segment.dataType == 21 {
		return segment.stateType21(jdTDB)
	}
	et := (jdTDB - spkJ2000) * spkSecondsDay
	index := int(math.Floor((et - segment.initET) / segment.interval))
	if index < 0 {
		index = 0
	}
	if index >= segment.records {
		index = segment.records - 1
	}
	if jdTDB < spkJ2000+segment.startET/spkSecondsDay || jdTDB > spkJ2000+segment.endET/spkSecondsDay {
		return pos, vel, ephem.ErrOutOfRange
	}
	record, err := segment.readRecord(index)
	if err != nil {
		return pos, vel, err
	}
	if !finite(record[0]) || !finitePositive(record[1]) || !finiteAll(record[2:]) {
		return pos, vel, errInvalidDAF
	}
	x := (et - record[0]) / record[1]
	tolerance := math.Abs(math.Nextafter(jdTDB, math.Inf(1))-jdTDB) * spkSecondsDay / record[1]
	if x < -1-tolerance || x > 1+tolerance {
		return pos, vel, ephem.ErrOutOfRange
	}
	x = math.Max(-1, math.Min(1, x))
	components := 3
	if segment.dataType == 3 {
		components = 6
	}
	coefficientCount := (segment.recordSize - 2) / components
	for component := 0; component < 3; component++ {
		value, derivative := chebyshev(record[2+component*coefficientCount:2+(component+1)*coefficientCount], x)
		pos[component] = value
		if segment.dataType == 2 {
			vel[component] = derivative / record[1] * spkSecondsDay
		} else {
			velocityStart := 2 + (component+3)*coefficientCount
			vel[component], _ = chebyshev(record[velocityStart:velocityStart+coefficientCount], x)
			vel[component] *= spkSecondsDay
		}
	}
	return pos, vel, nil
}

func (segment *summarySegment) stateType20(jdTDB float64) (pos, vel [3]float64, err error) {
	if jdTDB < spkJ2000+segment.startET/spkSecondsDay || jdTDB > spkJ2000+segment.endET/spkSecondsDay {
		return pos, vel, ephem.ErrOutOfRange
	}
	et := (jdTDB - spkJ2000) * spkSecondsDay
	init := (segment.initJD - spkJ2000 + segment.initFR) * spkSecondsDay
	interval := segment.interval * spkSecondsDay
	if !finitePositive(interval) {
		return pos, vel, errInvalidDAF
	}
	index := int(math.Floor((et - init) / interval))
	if index < 0 {
		index = 0
	}
	if index >= segment.records {
		index = segment.records - 1
	}
	record, err := segment.readRecord(index)
	if err != nil {
		return pos, vel, err
	}
	nterms := segment.recordSize / 3
	coefficientCount := nterms - 1
	if len(record) != segment.recordSize || coefficientCount < 1 || !finiteAll(record) {
		return pos, vel, errInvalidDAF
	}
	recbeg := (segment.initJD - spkJ2000 + float64(index)*segment.interval) * spkSecondsDay
	radius := interval / 2
	mid := recbeg + segment.initFR*spkSecondsDay + radius
	x := (et - mid) / radius
	if !finite(x) || x < -1-1e-12 || x > 1+1e-12 {
		return pos, vel, ephem.ErrOutOfRange
	}
	x = math.Max(-1, math.Min(1, x))
	velocityScale := segment.distanceScale / segment.timeScale
	for component := 0; component < 3; component++ {
		base := component * nterms
		coefficients := record[base : base+coefficientCount]
		value, _ := chebyshev(coefficients, x)
		integral := chebyshevIntegral(coefficients, x)
		pos[component] = record[base+coefficientCount]*segment.distanceScale + radius*integral*velocityScale
		vel[component] = value * velocityScale * spkSecondsDay
	}
	return pos, vel, nil
}

func (segment *summarySegment) stateType21(jdTDB float64) (pos, vel [3]float64, err error) {
	if jdTDB < spkJ2000+segment.startET/spkSecondsDay || jdTDB > spkJ2000+segment.endET/spkSecondsDay {
		return pos, vel, ephem.ErrOutOfRange
	}
	et := (jdTDB - spkJ2000) * spkSecondsDay
	epochs, err := segment.owner.readWords(segment.epochStartWord, segment.records)
	if err != nil {
		return pos, vel, err
	}
	index := 0
	for index < len(epochs) && epochs[index] < et {
		index++
	}
	if index >= len(epochs) {
		index = len(epochs) - 1
	}
	record, err := segment.readRecord(index)
	if err != nil {
		return pos, vel, err
	}
	maxdim := segment.maxDim
	record = append([]float64{float64(maxdim)}, record...)
	pos, vel, err = evaluateType21(et, record)
	for component := range vel {
		vel[component] *= spkSecondsDay
	}
	return pos, vel, err
}

func evaluateType21(et float64, record []float64) (statePos, stateVel [3]float64, err error) {
	if len(record) < 72 {
		return statePos, stateVel, errInvalidDAF
	}
	maxdim := int(math.Round(record[0]))
	if maxdim < 15 || maxdim > 25 || len(record) != 4*maxdim+12 || !finiteAll(record) {
		return statePos, stateVel, errInvalidDAF
	}
	tl := record[1]
	g := record[2 : 2+maxdim]
	refPos := [3]float64{record[maxdim+2], record[maxdim+4], record[maxdim+6]}
	refVel := [3]float64{record[maxdim+3], record[maxdim+5], record[maxdim+7]}
	kqmax1 := int(math.Round(record[4*maxdim+8]))
	kq := [3]int{int(math.Round(record[4*maxdim+9])), int(math.Round(record[4*maxdim+10])), int(math.Round(record[4*maxdim+11]))}
	// 差分表与步长表各只有 MAXDIM 项，权重表只有 KQMAX1+1 项。
	if kqmax1 < 3 || kqmax1 > maxdim+1 {
		return statePos, stateVel, errInvalidDAF
	}
	for _, value := range g[:kqmax1-2] {
		if !finite(value) || value == 0 {
			return statePos, stateVel, errInvalidDAF
		}
	}
	for _, value := range kq {
		if value < 1 || value > kqmax1-1 {
			return statePos, stateVel, errInvalidDAF
		}
	}
	delta := et - tl
	tp := delta
	mq2 := kqmax1 - 2
	ks := kqmax1 - 1
	fc := make([]float64, kqmax1+1)
	wc := make([]float64, kqmax1)
	weights := make([]float64, kqmax1+2)
	for j := 1; j <= mq2; j++ {
		fc[j] = tp / g[j-1]
		wc[j-1] = delta / g[j-1]
		tp = delta + g[j-1]
	}
	for j := 1; j <= kqmax1; j++ {
		weights[j-1] = 1 / float64(j)
	}
	jx := 0
	ks1 := ks - 1
	for ks >= 2 {
		jx++
		for j := 1; j <= jx; j++ {
			weights[j+ks-1] = fc[j]*weights[j+ks1-1] - wc[j-1]*weights[j+ks-1]
		}
		ks = ks1
		ks1--
	}
	for component := 0; component < 3; component++ {
		sum := 0.0
		for j := kq[component]; j >= 1; j-- {
			sum += record[8+(component+1)*maxdim+j-1] * weights[j+ks-1]
		}
		statePos[component] = refPos[component] + delta*(refVel[component]+delta*sum)
	}
	for j := 1; j <= jx; j++ {
		weights[j+ks-1] = fc[j]*weights[j+ks1-1] - wc[j-1]*weights[j+ks-1]
	}
	ks--
	for component := 0; component < 3; component++ {
		sum := 0.0
		for j := kq[component]; j >= 1; j-- {
			sum += record[8+(component+1)*maxdim+j-1] * weights[j+ks-1]
		}
		stateVel[component] = refVel[component] + delta*sum
	}
	return statePos, stateVel, nil
}

func chebyshevIntegral(coefficients []float64, x float64) float64 {
	degree := len(coefficients) - 1
	if degree < 0 {
		return 0
	}
	s2 := 2 * x
	a2 := coefficients[0]
	if len(coefficients) >= 3 {
		a2 -= coefficients[2] * 0.5
	}
	adegree1, adegree2 := 0.0, 0.0
	if degree >= 2 {
		adegree1 = coefficients[degree-1] * 0.5 / float64(degree)
	}
	if degree >= 1 {
		adegree2 = coefficients[degree] * 0.5 / float64(degree+1)
	}
	f2, f1 := 0.0, 0.0
	f0 := a2
	if degree > 0 {
		f0 = adegree2
	}
	z2, z1, z0 := 0.0, 0.0, f0
	w2, w1, w0 := 0.0, 0.0, 0.0
	for index := len(coefficients); index > 1; index-- {
		var coefficient float64
		switch {
		case index == 2:
			coefficient = a2
		case index < len(coefficients):
			coefficient = (coefficients[index-2] - coefficients[index]) * 0.5 / float64(index-1)
		default:
			coefficient = adegree1
		}
		f2, f1 = f1, f0
		f0 = coefficient + (s2*f1 - f2)
		z2, z1 = z1, z0
		z0 = coefficient - z2
		w2, w1 = w1, w0
		w0 = coefficients[index-1] + (s2*w1 - w2)
	}
	c0 := z1
	return c0 + x*f0 - f1
}

func (segment *summarySegment) readRecord(index int) ([]float64, error) {
	if index < 0 || index >= segment.records {
		return nil, ephem.ErrOutOfRange
	}
	segment.cacheMu.Lock()
	if record, ok := segment.cache[index]; ok {
		copyRecord := append([]float64(nil), record...)
		segment.cacheMu.Unlock()
		return copyRecord, nil
	}
	segment.cacheMu.Unlock()
	record, err := segment.owner.readWords(segment.startWord+int64(index*segment.recordSize), segment.recordSize)
	if err != nil {
		return nil, err
	}
	segment.cacheMu.Lock()
	defer segment.cacheMu.Unlock()
	if previous, ok := segment.cache[index]; ok {
		return append([]float64(nil), previous...), nil
	}
	if len(segment.cacheOrder) >= spkCacheRecords {
		delete(segment.cache, segment.cacheOrder[0])
		segment.cacheOrder = segment.cacheOrder[1:]
	}
	segment.cache[index] = record
	segment.cacheOrder = append(segment.cacheOrder, index)
	return append([]float64(nil), record...), nil
}

func chebyshev(coefficients []float64, x float64) (value, derivative float64) {
	t0, t1 := 1.0, x
	d0, d1 := 0.0, 1.0
	for index, coefficient := range coefficients {
		switch index {
		case 0:
			value += coefficient
		case 1:
			value += coefficient * t1
			derivative += coefficient
		default:
			t2 := 2*x*t1 - t0
			d2 := 2*t1 + 2*x*d1 - d0
			value += coefficient * t2
			derivative += coefficient * d2
			t0, t1 = t1, t2
			d0, d1 = d1, d2
		}
	}
	return value, derivative
}

func (s *File) readRecord(record int) ([]byte, error) {
	if record < 1 || int64(record)*dafRecordBytes > s.size {
		return nil, errInvalidDAF
	}
	data := make([]byte, dafRecordBytes)
	if _, err := s.file.ReadAt(data, int64(record-1)*dafRecordBytes); err != nil {
		return nil, err
	}
	return data, nil
}

func (s *File) readWords(startWord int64, count int) ([]float64, error) {
	if startWord < 1 || count < 1 || int64(count) > s.size/dafWordBytes || startWord > s.size/dafWordBytes-int64(count)+1 {
		return nil, errInvalidDAF
	}
	data := make([]byte, count*dafWordBytes)
	if _, err := s.file.ReadAt(data, (startWord-1)*dafWordBytes); err != nil {
		return nil, err
	}
	words := make([]float64, count)
	for index := range words {
		words[index] = float64Value(s.order, data[index*dafWordBytes:(index+1)*dafWordBytes])
	}
	return words, nil
}

func byteOrderFor(format string) (binary.ByteOrder, error) {
	switch format {
	case "LTL-IEEE":
		return binary.LittleEndian, nil
	case "BIG-IEEE":
		return binary.BigEndian, nil
	default:
		return nil, fmt.Errorf("%w: binary format %q", errInvalidDAF, format)
	}
}

func int32Value(order binary.ByteOrder, data []byte, offset int) int32 {
	return int32(order.Uint32(data[offset : offset+4]))
}

func float64Value(order binary.ByteOrder, data []byte) float64 {
	return math.Float64frombits(order.Uint64(data))
}

func finitePositive(value float64) bool {
	return value > 0 && finite(value)
}

func finite(value float64) bool { return !math.IsNaN(value) && !math.IsInf(value, 0) }

func finiteAll(values []float64) bool {
	for _, value := range values {
		if !finite(value) {
			return false
		}
	}
	return true
}

func validInteger(value float64, minimum, maximum int64) bool {
	return finite(value) && value >= float64(minimum) && value <= float64(maximum) && value == math.Trunc(value)
}

func addVector(dst *[3]float64, src [3]float64) {
	for index := range dst {
		dst[index] += src[index]
	}
}

func negateVector(value *[3]float64) {
	for index := range value {
		value[index] = -value[index]
	}
}

var _ ephem.Engine = (*File)(nil)