starainrt
46b555cd49
- 修正合月、合日、留等Last/Next/Closest接口在精确命中和事件后秒级查询时仍返回当前事件的问题，避免应用侧枚举卡死 - 收紧事件边界判定，并补强水星、金星、火星近事件路径的稳定化，保证公开API的单调前进语义 - 补充公开wrapper、跨世纪样本和外部基线回归，覆盖合月邻近事件与边界场景
624 lines
17 KiB
Go
624 lines
17 KiB
Go
package basic
|
|
|
|
import (
|
|
"math"
|
|
|
|
"b612.me/astro/planet"
|
|
. "b612.me/astro/tools"
|
|
)
|
|
|
|
const (
|
|
VENUS_S_PERIOD = 1 / ((1 / 224.701) - (1 / 365.256363004))
|
|
venusEventSearchN = 16
|
|
)
|
|
|
|
func venusSunLongitudeDelta(jde float64) float64 {
|
|
sub := Limit360(VenusApparentLo(jde) - HSunApparentLo(jde))
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub
|
|
}
|
|
|
|
func venusSunLongitudeDeltaN(jde float64, n int) float64 {
|
|
sub := Limit360(VenusApparentLoN(jde, n) - HSunApparentLoN(jde, n))
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub
|
|
}
|
|
|
|
func venusConjunctionAngleDelta(diff float64) float64 {
|
|
diff = Limit360(diff)
|
|
if diff > 180 {
|
|
diff -= 360
|
|
}
|
|
if diff < -180 {
|
|
diff += 360
|
|
}
|
|
return diff
|
|
}
|
|
|
|
func venusConjunctionHeliocentricDelta(jd, targetDeg float64, n int) float64 {
|
|
planetLo := planet.WherePlanetN(2, 0, jd, n)
|
|
earthLo := planet.WherePlanetN(-1, 0, jd, n)
|
|
return venusConjunctionAngleDelta(planetLo - earthLo - targetDeg)
|
|
}
|
|
|
|
func venusSunRADelta(jde float64) float64 {
|
|
sub := Limit360(VenusApparentRa(jde) - SunApparentRa(jde))
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub
|
|
}
|
|
|
|
func venusRADerivative(jde, val float64) float64 {
|
|
sub := VenusApparentRa(jde+val) - VenusApparentRa(jde-val)
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub / (2 * val)
|
|
}
|
|
|
|
func venusRADerivativeN(jde, val float64, n int) float64 {
|
|
sub := VenusApparentRaN(jde+val, n) - VenusApparentRaN(jde-val, n)
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub / (2 * val)
|
|
}
|
|
|
|
func venusRAContinuousForMax(jde float64) float64 {
|
|
ra := VenusApparentRa(jde)
|
|
if ra < 180 {
|
|
return ra + 360
|
|
}
|
|
return ra
|
|
}
|
|
|
|
func venusRAContinuousForMaxN(jde float64, n int) float64 {
|
|
ra := VenusApparentRaN(jde, n)
|
|
if ra < 180 {
|
|
return ra + 360
|
|
}
|
|
return ra
|
|
}
|
|
|
|
func venusRAContinuousForMin(jde float64) float64 {
|
|
ra := VenusApparentRa(jde)
|
|
if ra > 180 {
|
|
return ra - 360
|
|
}
|
|
return ra
|
|
}
|
|
|
|
func venusRAContinuousForMinN(jde float64, n int) float64 {
|
|
ra := VenusApparentRaN(jde, n)
|
|
if ra > 180 {
|
|
return ra - 360
|
|
}
|
|
return ra
|
|
}
|
|
|
|
func venusRAExtremumRefine(seed, start, end, step float64, fn func(float64) float64) float64 {
|
|
centerJD := clampFloat64(seed, start, end)
|
|
halfStep := step
|
|
bestJD := centerJD
|
|
bestVal := fn(centerJD)
|
|
for i := 0; i < 8; i++ {
|
|
leftJD := clampFloat64(centerJD-halfStep, start, end)
|
|
rightJD := clampFloat64(centerJD+halfStep, start, end)
|
|
leftVal := fn(leftJD)
|
|
centerVal := fn(centerJD)
|
|
rightVal := fn(rightJD)
|
|
if leftVal > bestVal {
|
|
bestVal = leftVal
|
|
bestJD = leftJD
|
|
}
|
|
if centerVal > bestVal {
|
|
bestVal = centerVal
|
|
bestJD = centerJD
|
|
}
|
|
if rightVal > bestVal {
|
|
bestVal = rightVal
|
|
bestJD = rightJD
|
|
}
|
|
denominator := leftVal - 2*centerVal + rightVal
|
|
if denominator == 0 {
|
|
centerJD = bestJD
|
|
halfStep /= 2
|
|
continue
|
|
}
|
|
vertexJD := centerJD + 0.5*halfStep*(leftVal-rightVal)/denominator
|
|
vertexJD = clampFloat64(vertexJD, leftJD, rightJD)
|
|
vertexVal := fn(vertexJD)
|
|
if vertexVal > bestVal {
|
|
bestVal = vertexVal
|
|
bestJD = vertexJD
|
|
}
|
|
centerJD = bestJD
|
|
halfStep /= 2
|
|
}
|
|
return bestJD
|
|
}
|
|
|
|
func venusSunElongationN(jde float64, n int) float64 {
|
|
lo1, bo1 := VenusApparentLoBoN(jde, n)
|
|
lo2 := HSunApparentLoN(jde, n)
|
|
bo2 := HSunTrueBoN(jde, n)
|
|
return StarAngularSeparation(lo1, bo1, lo2, bo2)
|
|
}
|
|
|
|
func venusTrueElongationN(jde float64, n int) float64 {
|
|
earth := mercuryHelioN(-1, jde, n)
|
|
planetPos := mercuryHelioN(2, jde, n)
|
|
geo := mercuryGeocentric(planetPos, earth)
|
|
return StarAngularSeparation(geo.lo, geo.bo, HSunTrueLoN(jde, n), HSunTrueBoN(jde, n))
|
|
}
|
|
|
|
func venusElongationDerivative(jde, val float64) float64 {
|
|
sub := VenusSunElongation(jde+val) - VenusSunElongation(jde-val)
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub / (2 * val)
|
|
}
|
|
|
|
func venusElongationDerivativeN(jde, val float64, n int) float64 {
|
|
sub := venusSunElongationN(jde+val, n) - venusSunElongationN(jde-val, n)
|
|
if sub > 180 {
|
|
sub -= 360
|
|
}
|
|
if sub < -180 {
|
|
sub += 360
|
|
}
|
|
return sub / (2 * val)
|
|
}
|
|
|
|
func venusConjunction(jde float64, next uint8) float64 {
|
|
queryTT := jde
|
|
direction := -1.0
|
|
if next == 1 {
|
|
direction = 1
|
|
}
|
|
left := queryTT
|
|
leftVal := venusSunLongitudeDeltaN(left, venusEventSearchN)
|
|
if math.Abs(venusSunLongitudeDelta(queryTT)) <= 30.0/86400.0 {
|
|
exact := eventZeroRefine(left, 1.0, 0.000005, venusSunLongitudeDelta)
|
|
eventUT := TD2UT(exact, false)
|
|
if next == 0 && eventUTQueryBeforeOrEqual(eventUT, queryTT) {
|
|
return eventUT
|
|
}
|
|
if next == 1 && eventUTQueryAfterOrEqual(eventUT, queryTT) {
|
|
return eventUT
|
|
}
|
|
}
|
|
const step = 8.0
|
|
for i := 0; i < 80; i++ {
|
|
right := queryTT + direction*step*float64(i+1)
|
|
rightVal := venusSunLongitudeDeltaN(right, venusEventSearchN)
|
|
if leftVal == 0 || rightVal == 0 || leftVal*rightVal <= 0 {
|
|
center := (left + right) / 2.0
|
|
halfWindow := math.Abs(right-left) / 2.0
|
|
return TD2UT(eventZeroRefine(center, halfWindow, 0.000005, venusSunLongitudeDelta), false)
|
|
}
|
|
left = right
|
|
leftVal = rightVal
|
|
}
|
|
return TD2UT(eventZeroRefine(queryTT, VENUS_S_PERIOD, 0.000005, venusSunLongitudeDelta), false)
|
|
}
|
|
|
|
func venusConjunctionTypeAt(eventUT float64) bool {
|
|
return EarthVenusAway(eventUT) <= EarthAway(eventUT)
|
|
}
|
|
|
|
func nextVenusTypedConjunctionFromEvent(jde float64, inferior bool) float64 {
|
|
date := NextVenusConjunctionStrict(jde)
|
|
if venusConjunctionTypeAt(date) == inferior {
|
|
return date
|
|
}
|
|
return NextVenusConjunctionStrict(eventUTNextQueryTT(date))
|
|
}
|
|
|
|
func lastVenusTypedConjunctionFromEvent(jde float64, inferior bool) float64 {
|
|
date := LastVenusConjunctionStrict(jde)
|
|
if venusConjunctionTypeAt(date) == inferior {
|
|
return date
|
|
}
|
|
return LastVenusConjunctionStrict(eventUTLastQueryTT(date))
|
|
}
|
|
|
|
func LastVenusConjunction(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusConjunctionStrict, NextVenusConjunctionStrict)
|
|
}
|
|
|
|
func NextVenusConjunction(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusConjunctionStrict, NextVenusConjunctionStrict)
|
|
}
|
|
|
|
func LastVenusConjunctionStrict(jde float64) float64 {
|
|
return venusConjunction(jde, 0)
|
|
}
|
|
|
|
func NextVenusConjunctionStrict(jde float64) float64 {
|
|
return venusConjunction(jde, 1)
|
|
}
|
|
|
|
func nextVenusTypedConjunction(jde float64, inferior bool) float64 {
|
|
return nextVenusTypedConjunctionFromEvent(jde, inferior)
|
|
}
|
|
|
|
func lastVenusTypedConjunction(jde float64, inferior bool) float64 {
|
|
return lastVenusTypedConjunctionFromEvent(jde, inferior)
|
|
}
|
|
|
|
func NextVenusInferiorConjunction(jde float64) float64 {
|
|
return nextVenusTypedConjunction(jde, true)
|
|
}
|
|
|
|
func NextVenusSuperiorConjunction(jde float64) float64 {
|
|
return nextVenusTypedConjunction(jde, false)
|
|
}
|
|
|
|
func LastVenusInferiorConjunction(jde float64) float64 {
|
|
return lastVenusTypedConjunction(jde, true)
|
|
}
|
|
|
|
func LastVenusSuperiorConjunction(jde float64) float64 {
|
|
return lastVenusTypedConjunction(jde, false)
|
|
}
|
|
|
|
func venusRetrograde(jde float64) float64 {
|
|
//0=last 1=next
|
|
lastHe := LastVenusConjunctionStrict(jde)
|
|
nextHe := NextVenusConjunctionStrict(jde)
|
|
nowSub := venusSunRADelta(jde)
|
|
if nowSub > 0 {
|
|
jde = lastHe + ((nextHe - lastHe) / 5.0 * 3.5)
|
|
} else {
|
|
jde = lastHe + 10
|
|
}
|
|
for {
|
|
nowSub := venusRADerivativeN(jde, 1.0/86400.0, venusEventSearchN)
|
|
if math.Abs(nowSub) > 0.5 {
|
|
jde += 5
|
|
continue
|
|
}
|
|
break
|
|
}
|
|
JD1 := jde
|
|
for {
|
|
JD0 := JD1
|
|
stDegree := venusRADerivative(JD0, 0.5/86400.0)
|
|
stDegreep := (venusRADerivative(JD0+10.0/86400.0, 0.5/86400.0) - venusRADerivative(JD0-10.0/86400.0, 0.5/86400.0)) / (20.0 / 86400.0)
|
|
JD1 = JD0 - stDegree/stDegreep
|
|
if math.Abs(JD1-JD0) <= 20.0/86400.0 {
|
|
break
|
|
}
|
|
}
|
|
min := eventZeroRefine(JD1, 10.0/86400.0, 0.5/86400.0, func(jd float64) float64 {
|
|
return venusRADerivative(jd, 0.5/86400.0)
|
|
})
|
|
//fmt.Println((min - lastHe) / (nextHe - lastHe))
|
|
return TD2UT(min, false)
|
|
}
|
|
|
|
func NextVenusRetrograde(jde float64) float64 {
|
|
p2r := NextVenusProgradeToRetrograde(jde)
|
|
r2p := NextVenusRetrogradeToPrograde(jde)
|
|
if sameEventJD(p2r, r2p) {
|
|
return p2r
|
|
}
|
|
if p2r < r2p {
|
|
return p2r
|
|
}
|
|
return r2p
|
|
}
|
|
|
|
func LastVenusRetrograde(jde float64) float64 {
|
|
p2r := LastVenusProgradeToRetrograde(jde)
|
|
r2p := LastVenusRetrogradeToPrograde(jde)
|
|
if sameEventJD(p2r, r2p) {
|
|
return p2r
|
|
}
|
|
if p2r > r2p {
|
|
return p2r
|
|
}
|
|
return r2p
|
|
}
|
|
|
|
func venusStationInWindow(start, end float64, progradeToRetrograde bool) float64 {
|
|
var best float64
|
|
if progradeToRetrograde {
|
|
guess := scanWindowForMax(start, end, 2.0, func(jd float64) float64 {
|
|
return venusRAContinuousForMaxN(jd, venusEventSearchN)
|
|
})
|
|
best = venusRAExtremumRefine(guess, start, end, 1.0, func(jd float64) float64 {
|
|
return venusRAContinuousForMax(jd)
|
|
})
|
|
} else {
|
|
guess := scanWindowForMax(start, end, 2.0, func(jd float64) float64 {
|
|
return -venusRAContinuousForMinN(jd, venusEventSearchN)
|
|
})
|
|
best = venusRAExtremumRefine(guess, start, end, 1.0, func(jd float64) float64 {
|
|
return -venusRAContinuousForMin(jd)
|
|
})
|
|
}
|
|
return TD2UT(best, false)
|
|
}
|
|
|
|
func venusProgradeToRetrogradeAroundInferior(inferior float64) float64 {
|
|
return venusStationInWindow(inferior-30.0, inferior-14.0, true)
|
|
}
|
|
|
|
func venusRetrogradeToProgradeAroundInferior(inferior float64) float64 {
|
|
return venusStationInWindow(inferior+14.0, inferior+24.0, false)
|
|
}
|
|
|
|
func NextVenusProgradeToRetrograde(jde float64) float64 {
|
|
inferior := NextVenusInferiorConjunction(jde)
|
|
for {
|
|
date := venusProgradeToRetrogradeAroundInferior(inferior)
|
|
if eventUTQueryAfterOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
inferior = NextVenusInferiorConjunction(eventUTNextQueryTT(inferior))
|
|
}
|
|
}
|
|
|
|
func NextVenusRetrogradeToPrograde(jde float64) float64 {
|
|
inferior := LastVenusInferiorConjunction(jde)
|
|
for {
|
|
date := venusRetrogradeToProgradeAroundInferior(inferior)
|
|
if eventUTQueryAfterOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
inferior = NextVenusInferiorConjunction(eventUTNextQueryTT(inferior))
|
|
}
|
|
}
|
|
|
|
func LastVenusProgradeToRetrograde(jde float64) float64 {
|
|
inferior := NextVenusInferiorConjunction(jde)
|
|
for {
|
|
date := venusProgradeToRetrogradeAroundInferior(inferior)
|
|
if eventUTQueryBeforeOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
inferior = LastVenusInferiorConjunction(eventUTLastQueryTT(inferior))
|
|
}
|
|
}
|
|
|
|
func LastVenusRetrogradeToPrograde(jde float64) float64 {
|
|
inferior := LastVenusInferiorConjunction(jde)
|
|
for {
|
|
date := venusRetrogradeToProgradeAroundInferior(inferior)
|
|
if eventUTQueryBeforeOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
inferior = LastVenusInferiorConjunction(eventUTLastQueryTT(inferior))
|
|
}
|
|
}
|
|
|
|
func VenusSunElongation(jde float64) float64 {
|
|
lo1, bo1 := VenusApparentLoBo(jde)
|
|
lo2 := HSunApparentLo(jde)
|
|
bo2 := HSunTrueBo(jde)
|
|
return StarAngularSeparation(lo1, bo1, lo2, bo2)
|
|
}
|
|
|
|
func venusGreatestElongationInWindow(start, end float64) float64 {
|
|
best := maximizeInWindow(start, end, 5.0, func(jd float64) float64 {
|
|
return venusTrueElongationN(jd, venusEventSearchN)
|
|
}, func(jd float64) float64 {
|
|
return venusTrueElongationN(jd, -1)
|
|
})
|
|
return TD2UT(best, false)
|
|
}
|
|
|
|
func venusEastElongationWindowEndingAt(inferior float64) (float64, float64) {
|
|
lastSuperior := LastVenusSuperiorConjunction(eventUTLastQueryTT(inferior))
|
|
return lastSuperior + innerEventWindowPadding, inferior - innerEventWindowPadding
|
|
}
|
|
|
|
func venusWestElongationWindowEndingAt(superior float64) (float64, float64) {
|
|
lastInferior := LastVenusInferiorConjunction(eventUTLastQueryTT(superior))
|
|
return lastInferior + innerEventWindowPadding, superior - innerEventWindowPadding
|
|
}
|
|
|
|
func venusEastElongationWindowContaining(jde float64) (float64, float64) {
|
|
nextInferior := NextVenusInferiorConjunction(jde)
|
|
start, end := venusEastElongationWindowEndingAt(nextInferior)
|
|
if eventUTQueryBeforeOrEqual(start, jde) && eventUTQueryAfterOrEqual(end, jde) {
|
|
return start, end
|
|
}
|
|
currentInferior := LastVenusInferiorConjunction(jde)
|
|
return venusEastElongationWindowEndingAt(currentInferior)
|
|
}
|
|
|
|
func venusWestElongationWindowContaining(jde float64) (float64, float64) {
|
|
nextSuperior := NextVenusSuperiorConjunction(jde)
|
|
start, end := venusWestElongationWindowEndingAt(nextSuperior)
|
|
if eventUTQueryBeforeOrEqual(start, jde) && eventUTQueryAfterOrEqual(end, jde) {
|
|
return start, end
|
|
}
|
|
currentSuperior := LastVenusSuperiorConjunction(jde)
|
|
return venusWestElongationWindowEndingAt(currentSuperior)
|
|
}
|
|
|
|
func nextVenusGreatestElongationTyped(jde float64, east bool) float64 {
|
|
if east {
|
|
start, windowEnd := venusEastElongationWindowContaining(jde)
|
|
for {
|
|
date := venusGreatestElongationInWindow(start, windowEnd)
|
|
if eventUTQueryAfterOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
nextInferior := NextVenusInferiorConjunction(eventUTNextQueryTT(windowEnd))
|
|
start, windowEnd = venusEastElongationWindowEndingAt(nextInferior)
|
|
}
|
|
}
|
|
start, windowEnd := venusWestElongationWindowContaining(jde)
|
|
for {
|
|
date := venusGreatestElongationInWindow(start, windowEnd)
|
|
if eventUTQueryAfterOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
nextSuperior := NextVenusSuperiorConjunction(eventUTNextQueryTT(windowEnd))
|
|
start, windowEnd = venusWestElongationWindowEndingAt(nextSuperior)
|
|
}
|
|
}
|
|
|
|
func lastVenusGreatestElongationTyped(jde float64, east bool) float64 {
|
|
if east {
|
|
start, windowEnd := venusEastElongationWindowContaining(jde)
|
|
for {
|
|
date := venusGreatestElongationInWindow(start, windowEnd)
|
|
if eventUTQueryBeforeOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
prevInferior := LastVenusInferiorConjunction(eventUTLastQueryTT(start))
|
|
start, windowEnd = venusEastElongationWindowEndingAt(prevInferior)
|
|
}
|
|
}
|
|
start, windowEnd := venusWestElongationWindowContaining(jde)
|
|
for {
|
|
date := venusGreatestElongationInWindow(start, windowEnd)
|
|
if eventUTQueryBeforeOrEqual(date, jde) {
|
|
return date
|
|
}
|
|
prevSuperior := LastVenusSuperiorConjunction(eventUTLastQueryTT(start))
|
|
start, windowEnd = venusWestElongationWindowEndingAt(prevSuperior)
|
|
}
|
|
}
|
|
|
|
func venusGreatestElongation(jde float64) float64 {
|
|
east := venusSunRADelta(jde) > 0
|
|
if east {
|
|
return nextVenusGreatestElongationTyped(jde, true)
|
|
}
|
|
return nextVenusGreatestElongationTyped(jde, false)
|
|
}
|
|
|
|
func NextVenusGreatestElongation(jde float64) float64 {
|
|
east := NextVenusGreatestElongationEast(jde)
|
|
west := NextVenusGreatestElongationWest(jde)
|
|
if sameEventJD(east, west) {
|
|
return east
|
|
}
|
|
if east < west {
|
|
return east
|
|
}
|
|
return west
|
|
}
|
|
|
|
func LastVenusGreatestElongation(jde float64) float64 {
|
|
east := LastVenusGreatestElongationEast(jde)
|
|
west := LastVenusGreatestElongationWest(jde)
|
|
if sameEventJD(east, west) {
|
|
return east
|
|
}
|
|
if east > west {
|
|
return east
|
|
}
|
|
return west
|
|
}
|
|
|
|
func LastVenusInferiorConjunctionInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusInferiorConjunction, NextVenusInferiorConjunction)
|
|
}
|
|
|
|
func NextVenusInferiorConjunctionInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusInferiorConjunction, NextVenusInferiorConjunction)
|
|
}
|
|
|
|
func LastVenusSuperiorConjunctionInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusSuperiorConjunction, NextVenusSuperiorConjunction)
|
|
}
|
|
|
|
func NextVenusSuperiorConjunctionInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusSuperiorConjunction, NextVenusSuperiorConjunction)
|
|
}
|
|
|
|
func LastVenusRetrogradeInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusRetrograde, NextVenusRetrograde)
|
|
}
|
|
|
|
func NextVenusRetrogradeInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusRetrograde, NextVenusRetrograde)
|
|
}
|
|
|
|
func LastVenusProgradeToRetrogradeInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusProgradeToRetrograde, NextVenusProgradeToRetrograde)
|
|
}
|
|
|
|
func NextVenusProgradeToRetrogradeInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusProgradeToRetrograde, NextVenusProgradeToRetrograde)
|
|
}
|
|
|
|
func LastVenusRetrogradeToProgradeInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusRetrogradeToPrograde, NextVenusRetrogradeToPrograde)
|
|
}
|
|
|
|
func NextVenusRetrogradeToProgradeInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusRetrogradeToPrograde, NextVenusRetrogradeToPrograde)
|
|
}
|
|
|
|
func LastVenusGreatestElongationInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusGreatestElongation, NextVenusGreatestElongation)
|
|
}
|
|
|
|
func NextVenusGreatestElongationInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusGreatestElongation, NextVenusGreatestElongation)
|
|
}
|
|
|
|
func LastVenusGreatestElongationEastInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusGreatestElongationEast, NextVenusGreatestElongationEast)
|
|
}
|
|
|
|
func NextVenusGreatestElongationEastInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusGreatestElongationEast, NextVenusGreatestElongationEast)
|
|
}
|
|
|
|
func LastVenusGreatestElongationWestInclusive(jde float64) float64 {
|
|
return inclusiveLastSimpleEvent(jde, LastVenusGreatestElongationWest, NextVenusGreatestElongationWest)
|
|
}
|
|
|
|
func NextVenusGreatestElongationWestInclusive(jde float64) float64 {
|
|
return inclusiveNextSimpleEvent(jde, LastVenusGreatestElongationWest, NextVenusGreatestElongationWest)
|
|
}
|
|
|
|
func NextVenusGreatestElongationEast(jde float64) float64 {
|
|
return nextVenusGreatestElongationTyped(jde, true)
|
|
}
|
|
|
|
func NextVenusGreatestElongationWest(jde float64) float64 {
|
|
return nextVenusGreatestElongationTyped(jde, false)
|
|
}
|
|
|
|
func LastVenusGreatestElongationEast(jde float64) float64 {
|
|
return lastVenusGreatestElongationTyped(jde, true)
|
|
}
|
|
|
|
func LastVenusGreatestElongationWest(jde float64) float64 {
|
|
return lastVenusGreatestElongationTyped(jde, false)
|
|
}
|