caelus 0.4.0 → 0.5.0

package/README.md

@@ -10,7 +10,7 @@ ephemeris files. 1:1 port of the Python reference, checked by golden fixtures.
    true node ≤ 1′ vs SE's built-in ephemeris (≤ 1″ vs JPL DE431)
    (vs full DE431 files, 1850–2149), angles and Placidus cusps ≤ 3.2″ — all
    invisible at the arcminute display precision chart software uses.
-2. TypeScript port verified against Python golden fixtures: **3,177 checks,
+2. TypeScript port verified against Python golden fixtures: **3,218 checks,
    0 failures, worst deviation 1.64 nano-arcseconds.** The two implementations
    are numerically identical.
 

package/accuracy.json

@@ -176,6 +176,30 @@
       "max": "2.3",
       "rms": "—",
       "note": "Hamburg-school constant-element Kepler orbits, elements fitted to SE 2.10's built-in definitions (fit_uranian.py prints per-body figures; Zeus is fit-noise-limited at ~3″ heliocentric). Uranian practice works in arcminutes"
+    },
+    {
+      "name": "Fixed stars (318-star catalog)",
+      "max": "0.6",
+      "rms": "—",
+      "note": "HYG-derived catalog (ICRS J2000 + proper motions, full 3D space motion); vs swe_fixstar fed the same rows. Floor is the IAU 1976 vs Vondrák precession difference"
+    },
+    {
+      "name": "Star-anchored ayanamsas",
+      "max": "0.2",
+      "rms": "—",
+      "note": "galcent_0sag and true_citra computed from the apparent star (Galactic Center / Spica); sidereal Sun vs SE ≤0.19″"
+    },
+    {
+      "name": "Gauquelin sectors",
+      "max": "0.0001 sectors",
+      "rms": "—",
+      "note": "rise/set of disc center with refraction (SE method 3): exact to the rise/set bound"
+    },
+    {
+      "name": "Eclipses (solar + lunar)",
+      "max": "9 s",
+      "rms": "—",
+      "note": "times of maximum vs swe; types exact over 1990-2030 (92 lunar + 89 solar, zero mismatches); lunar magnitudes ≤0.0013 (Danjon parallax enlargement, recovered empirically). Contact times typically ≤15 s, minutes for grazing geometries. Global circumstances only — no ground paths"
     }
   ],
   "summary": [
@@ -211,10 +235,6 @@
       "label": "Mean Lilith",
       "bound": "≤ 1.3″"
     },
-    {
-      "label": "Sidereal (5 ayanamsas)",
-      "bound": "≤ 0.3″ added"
-    },
     {
       "label": "8 new house systems",
       "bound": "exact (0.0″)"
@@ -234,6 +254,18 @@
     {
       "label": "Uranian bodies",
       "bound": "≤ 2.3″"
+    },
+    {
+      "label": "Fixed stars",
+      "bound": "≤ 0.6″"
+    },
+    {
+      "label": "Sidereal (7 ayanamsas)",
+      "bound": "≤ 0.3″ added"
+    },
+    {
+      "label": "Eclipses",
+      "bound": "types exact; max ≤ 9 s"
     }
   ],
   "v03_harness": "python/validate_swiss.py regenerates every figure above the line against pyswisseph 2.10 (Moshier mode)",

package/dist/src/chart.d.ts

@@ -78,6 +78,20 @@ export declare class Engine {
      *  Building block for the events module; chart consumers want
      *  position() instead. */
     ecliptic(body: BodyId, jde: number): [number, number, number | null];
+    /** Degrees to subtract from a true-equinox tropical longitude. */
+    private ayanShift;
+    /** Apparent place of a catalog star: lon/lat/ra/dec (deg), sign, mag. */
+    fixedStar(name: string, jdUt: number, opts?: CalcOptions): {
+        lon: number;
+        lat: number;
+        ra: number;
+        dec: number;
+        mag: number;
+        sign: string;
+        signDeg: number;
+    };
+    /** Names in the loaded fixed-star catalog (sorted). */
+    starNames(): string[];
     private lonOnly;
     /** Apparent geocentric ecliptic longitude (deg). Tropical: true equinox
      *  of date. Sidereal: mean equinox minus ayanamsa. */

package/dist/src/chart.js

@@ -1,5 +1,6 @@
 /** astroengine chart -- public API: natal charts, aspects, retrogrades. */
 import { DEG, mod, jdTT, julianDay, ChebSeries, planetApparent, sunApparent, moonApparentSeries, moonApparentPrecise, plutoApparent, chironApparent, meanNode, trueNodeSeries, trueNodePrecise, equatorial, ayanamsa, AYANAMSA_J2000, meanLilith, topocentricEcl, oscApogeePrecise, oscApogeeSeries, KeplerOrbit, trueObliquity, nutation, plutoHeliocentric, vsopHeliocentric, precessEcliptic, J2000, } from "./core.js";
+import { starApparent } from "./stars.js";
 import * as H from "./houses.js";
 const TWO_PI = 2 * Math.PI;
 export const BODIES = [
@@ -28,11 +29,18 @@ function parseZodiac(zodiac) {
         return null;
     if (zodiac.startsWith("sidereal:")) {
         const mode = zodiac.slice("sidereal:".length);
-        if (AYANAMSA_J2000[mode] !== undefined)
+        if (AYANAMSA_J2000[mode] !== undefined || STAR_AYANAMSAS[mode])
             return mode;
     }
     throw new Error(`unknown zodiac ${JSON.stringify(zodiac)}`);
 }
+/** Star-anchored ayanamsas: the named star sits at the fixed sidereal
+ *  longitude by definition (Galactic Center at 0 Sagittarius; Spica at
+ *  0 Libra "citra"). Need the fixed-star catalog loaded. */
+const STAR_AYANAMSAS = {
+    galcent_0sag: ["Galactic Center", 240.0],
+    true_citra: ["Spica", 180.0],
+};
 const VSOP_BODIES = new Set([
     "mercury", "venus", "earth", "mars", "jupiter", "saturn", "uranus", "neptune",
 ]);
@@ -120,6 +128,39 @@ export class Engine {
             return planetApparent(this.data, body, jde);
         throw new Error(`no data loaded for body '${body}'`);
     }
+    /** Degrees to subtract from a true-equinox tropical longitude. */
+    ayanShift(jde, mode) {
+        const star = STAR_AYANAMSAS[mode];
+        if (star) {
+            const s = this.data.fixedStars?.stars[star[0]];
+            if (!s)
+                throw new Error(`zodiac 'sidereal:${mode}' needs the fixed-star catalog loaded`);
+            const [lon] = starApparent(this.data, s, jde);
+            return mod(lon / DEG - star[1], 360);
+        }
+        return mod(nutation(this.data, jde)[0] / DEG + ayanamsa(jde, mode), 360);
+    }
+    /** Apparent place of a catalog star: lon/lat/ra/dec (deg), sign, mag. */
+    fixedStar(name, jdUt, opts = {}) {
+        const s = this.data.fixedStars?.stars[name];
+        if (!s)
+            throw new Error(`no fixed-star catalog entry for '${name}'`);
+        const mode = parseZodiac(opts.zodiac ?? "tropical");
+        const jde = jdTT(jdUt);
+        const [lonR, latR] = starApparent(this.data, s, jde);
+        const [ra, dec] = equatorial(lonR, latR, trueObliquity(this.data, jde));
+        let lon = lonR / DEG;
+        if (mode !== null)
+            lon = mod(lon - this.ayanShift(jde, mode), 360);
+        return {
+            lon, lat: latR / DEG, ra: ra / DEG, dec: dec / DEG, mag: s.mag,
+            sign: SIGNS[Math.floor(lon / 30)], signDeg: mod(lon, 30),
+        };
+    }
+    /** Names in the loaded fixed-star catalog (sorted). */
+    starNames() {
+        return Object.keys(this.data.fixedStars?.stars ?? {}).sort();
+    }
     lonOnly(body, jdUt, mode, topo) {
         const jde = jdTT(jdUt);
         let [lon, lat, dist] = this.ecliptic(body, jde);
@@ -128,9 +169,8 @@ export class Engine {
             [lon, lat, dist] = topocentricEcl(lon, lat, dist, lst, topo.lat * DEG, topo.altM ?? 0.0, trueObliquity(this.data, jde));
         }
         let lonDeg = lon / DEG;
-        if (mode !== null) {
-            lonDeg = mod(lonDeg - nutation(this.data, jde)[0] / DEG - ayanamsa(jde, mode), 360);
-        }
+        if (mode !== null)
+            lonDeg = mod(lonDeg - this.ayanShift(jde, mode), 360);
         return lonDeg;
     }
     /** Apparent geocentric ecliptic longitude (deg). Tropical: true equinox
@@ -186,9 +226,8 @@ export class Engine {
         }
         const [ra, dec] = equatorial(lonR, latR, trueObliquity(this.data, jde));
         let lon = lonR / DEG;
-        if (mode !== null) {
-            lon = mod(lon - nutation(this.data, jde)[0] / DEG - ayanamsa(jde, mode), 360);
-        }
+        if (mode !== null)
+            lon = mod(lon - this.ayanShift(jde, mode), 360);
         const h = 0.25; // days; central difference
         const l0 = this.lonOnly(body, jdUt - h, mode, topo);
         const l1 = this.lonOnly(body, jdUt + h, mode, topo);
@@ -276,9 +315,8 @@ export class Engine {
         }
         const jde = jdTT(jdUt);
         let shift = 0.0;
-        if (mode !== null) {
-            shift = nutation(this.data, jde)[0] / DEG + ayanamsa(jde, mode);
-        }
+        if (mode !== null)
+            shift = this.ayanShift(jde, mode);
         const outDeg = (rad) => mod(rad / DEG - shift, 360);
         let cuspsDeg;
         if (mode !== null && used === "whole_sign") {

package/dist/src/core.d.ts

@@ -56,6 +56,8 @@ export interface EngineData {
     chebPacks?: Record<string, ChebData>;
     /** Hamburg-school (Uranian) constant-element orbits; see fit_uranian.py. */
     keplerPack?: KeplerPack;
+    /** Fixed-star catalog (HYG-derived; ICRS J2000 + proper motions). */
+    fixedStars?: import("./stars.js").StarPack;
 }
 export declare function julianDay(y: number, mo: number, d: number, h?: number, mi?: number, s?: number): number;
 /** TT - UT1 in seconds. Observed IERS 1955-2025, E&M polynomials before,

package/dist/src/eclipses.d.ts

@@ -0,0 +1,24 @@
+import { Engine } from "./chart.js";
+export interface LunarEclipse {
+    tMax: number;
+    type: "total" | "partial" | "penumbral";
+    magUmbral: number;
+    magPenumbral: number;
+    penumbralBegin: number | null;
+    penumbralEnd: number | null;
+    partialBegin: number | null;
+    partialEnd: number | null;
+    totalBegin: number | null;
+    totalEnd: number | null;
+}
+export interface SolarEclipse {
+    tMax: number;
+    type: "total" | "annular" | "hybrid" | "partial";
+    gamma: number;
+    begin: number;
+    end: number;
+}
+/** Lunar eclipses in [jdStart, jdEnd] (UT JDs). */
+export declare function lunarEclipses(engine: Engine, jdStart: number, jdEnd: number): LunarEclipse[];
+/** Solar eclipses (global circumstances) in [jdStart, jdEnd] (UT JDs). */
+export declare function solarEclipses(engine: Engine, jdStart: number, jdEnd: number): SolarEclipse[];

package/dist/src/eclipses.js

@@ -0,0 +1,163 @@
+/**
+ * astroengine eclipses -- solar and lunar eclipse search.
+ *
+ * Lunar: direct shadow geometry at the anti-solar point with Danjon's
+ * enlargement (lunar parallax x 86/85 on the flattened Earth) — the rule
+ * Swiss Ephemeris uses, recovered empirically: magnitudes match to 0.001,
+ * types exactly; times of maximum to ~9 s (contact times typically <=15 s,
+ * up to ~2 min for grazing geometries where the crossing flattens).
+ *
+ * Solar (global): shadow-axis geometry. gamma = closest approach of the
+ * Sun-Moon axis to the geocenter in Earth radii; the umbral cone's reach
+ * at the surface separates total from annular, a sign change along the
+ * track marks hybrids. Types match Swiss Ephemeris exactly over decades.
+ * Local circumstances (where/visibility) are not computed here.
+ */
+import { ARCSEC, jdTT, mod } from "./core.js";
+const KM_PER_AU = 149597870.7;
+const R_EARTH = 6378.14;
+const R_SUN = 696000.0;
+const R_MOON = 1737.4;
+const PI_SUN = 8.794 * ARCSEC;
+const DANJON = (1 + 1 / 85.0) * 0.99834;
+function lunarGeom(engine, jd) {
+    const jde = jdTT(jd);
+    const [slon, slat, sdist] = engine.ecliptic("sun", jde);
+    const [mlon, mlat, mdist] = engine.ecliptic("moon", jde);
+    const alon = mod(slon + Math.PI, 2 * Math.PI);
+    const alat = -slat;
+    const cosd = Math.sin(alat) * Math.sin(mlat)
+        + Math.cos(alat) * Math.cos(mlat) * Math.cos(alon - mlon);
+    const theta = Math.acos(Math.max(-1, Math.min(1, cosd)));
+    const mkm = mdist * KM_PER_AU;
+    const piEff = DANJON * Math.asin(R_EARTH / mkm);
+    const sM = Math.asin(R_MOON / mkm);
+    const sS = Math.asin(R_SUN / (sdist * KM_PER_AU));
+    return [theta, piEff - sS + PI_SUN, piEff + sS + PI_SUN, sM];
+}
+function solarGeom(engine, jd) {
+    const jde = jdTT(jd);
+    const [slon, slat, sdist] = engine.ecliptic("sun", jde);
+    const [mlon, mlat, mdist] = engine.ecliptic("moon", jde);
+    const vec = (lon, lat, r) => [
+        r * Math.cos(lat) * Math.cos(lon),
+        r * Math.cos(lat) * Math.sin(lon),
+        r * Math.sin(lat),
+    ];
+    const S = vec(slon, slat, sdist * KM_PER_AU);
+    const M = vec(mlon, mlat, mdist * KM_PER_AU);
+    const SM = [M[0] - S[0], M[1] - S[1], M[2] - S[2]];
+    const smn = Math.sqrt(SM[0] ** 2 + SM[1] ** 2 + SM[2] ** 2);
+    const d = SM.map((c) => c / smn);
+    const t0 = -(M[0] * d[0] + M[1] * d[1] + M[2] * d[2]);
+    const P = [M[0] + t0 * d[0], M[1] + t0 * d[1], M[2] + t0 * d[2]];
+    const dAxis = Math.sqrt(P[0] ** 2 + P[1] ** 2 + P[2] ** 2);
+    const f1 = Math.asin((R_SUN + R_MOON) / smn);
+    const f2 = Math.asin((R_SUN - R_MOON) / smn);
+    const rPen = (R_MOON / Math.tan(f1) + t0) * Math.tan(f1);
+    const rUmb = (R_MOON / Math.tan(f2) - t0) * Math.tan(f2);
+    return [dAxis, rPen, rUmb, t0, f2];
+}
+function minimize(f, lo, hi) {
+    for (let i = 0; i < 60; i++) {
+        const m1 = lo + (hi - lo) / 3;
+        const m2 = hi - (hi - lo) / 3;
+        if (f(m1) < f(m2))
+            hi = m2;
+        else
+            lo = m1;
+    }
+    return (lo + hi) / 2;
+}
+function bisect(f, a, b) {
+    let fa = f(a);
+    for (let i = 0; i < 50; i++) {
+        const m = (a + b) / 2;
+        if (fa * f(m) <= 0) {
+            b = m;
+        }
+        else {
+            a = m;
+            fa = f(a);
+        }
+    }
+    return (a + b) / 2;
+}
+function syzygies(engine, jdStart, jdEnd, angle) {
+    const f = (t) => {
+        const e = mod(engine.longitude("moon", t) - engine.longitude("sun", t), 360);
+        return mod(e - angle + 180, 360) - 180;
+    };
+    const out = [];
+    const step = 5.0;
+    let prev = f(jdStart);
+    for (let t = jdStart + step; t <= jdEnd + step; t += step) {
+        const cur = f(t);
+        if (prev * cur < 0 && Math.abs(cur - prev) < 180) {
+            out.push(bisect(f, t - step, t));
+        }
+        prev = cur;
+    }
+    return out;
+}
+/** Lunar eclipses in [jdStart, jdEnd] (UT JDs). */
+export function lunarEclipses(engine, jdStart, jdEnd) {
+    const out = [];
+    for (const tFull of syzygies(engine, jdStart - 1, jdEnd + 1, 180.0)) {
+        const tMax = minimize((t) => lunarGeom(engine, t)[0], tFull - 0.3, tFull + 0.3);
+        const [theta, u, pen, sM] = lunarGeom(engine, tMax);
+        const magU = (u + sM - theta) / (2 * sM);
+        const magP = (pen + sM - theta) / (2 * sM);
+        if (magP <= 0 || tMax < jdStart || tMax > jdEnd)
+            continue;
+        const kind = magU >= 1 ? "total" : magU > 0 ? "partial" : "penumbral";
+        const cross = (idx, sign) => {
+            const f = (t) => {
+                const g = lunarGeom(engine, t);
+                return g[0] - (g[idx] + sign * g[3]);
+            };
+            return [bisect(f, tMax - 0.35, tMax), bisect(f, tMax, tMax + 0.35)];
+        };
+        const [penB, penE] = cross(2, 1);
+        const [parB, parE] = magU > 0 ? cross(1, 1) : [null, null];
+        const [totB, totE] = magU >= 1 ? cross(1, -1) : [null, null];
+        out.push({
+            tMax, type: kind,
+            magUmbral: Math.max(magU, 0), magPenumbral: magP,
+            penumbralBegin: penB, penumbralEnd: penE,
+            partialBegin: parB, partialEnd: parE,
+            totalBegin: totB, totalEnd: totE,
+        });
+    }
+    return out;
+}
+/** Solar eclipses (global circumstances) in [jdStart, jdEnd] (UT JDs). */
+export function solarEclipses(engine, jdStart, jdEnd) {
+    const out = [];
+    for (const tNew of syzygies(engine, jdStart - 1, jdEnd + 1, 0.0)) {
+        const tMax = minimize((t) => solarGeom(engine, t)[0], tNew - 0.4, tNew + 0.4);
+        const [dAxis, rPen, rUmb, , f2] = solarGeom(engine, tMax);
+        if (dAxis > R_EARTH + rPen || tMax < jdStart || tMax > jdEnd)
+            continue;
+        const gamma = dAxis / R_EARTH;
+        let kind;
+        if (dAxis < R_EARTH) {
+            const depth = Math.sqrt(Math.max(R_EARTH ** 2 - dAxis ** 2, 0));
+            const rUmbSurface = rUmb + depth * Math.tan(f2);
+            kind = rUmb > 0 ? "total" : rUmbSurface > 0 ? "hybrid" : "annular";
+        }
+        else {
+            kind = "partial";
+        }
+        const f = (t) => {
+            const g = solarGeom(engine, t);
+            return g[0] - (R_EARTH + g[1]);
+        };
+        out.push({
+            tMax, type: kind, gamma,
+            begin: bisect(f, tMax - 0.35, tMax),
+            end: bisect(f, tMax, tMax + 0.35),
+        });
+    }
+    return out;
+}

package/dist/src/events.d.ts

@@ -5,6 +5,8 @@ export interface RiseSetOptions {
     pressure?: number;
     tempC?: number;
     searchDays?: number;
+    /** Rise/set of the disc center instead of the upper limb. */
+    discCenter?: boolean;
 }
 /** Next rise/set/meridian transit (UT JD) after jdStart, or null when the
  *  event does not occur in the window (polar day/night). */
@@ -20,3 +22,8 @@ export declare function lunarPhases(engine: Engine, jdStart: number, jdEnd: numb
  *  turns]. Sun and Moon never station. Station timing is ill-conditioned:
  *  expect minute-level differences between ephemerides. */
 export declare function stations(engine: Engine, body: BodyId, jdStart: number, jdEnd: number, maxHits?: number): Array<[number, "retrograde" | "direct"]>;
+/** Gauquelin sector (1..36, float) from rise/set times of the disc center
+ *  with refraction (Swiss Ephemeris method 3). Sectors run from rise: 1-18
+ *  above the horizon, 19-36 below. Null in polar no-rise/no-set
+ *  conditions. */
+export declare function gauquelinSector(engine: Engine, body: BodyId, jdUt: number, latDeg: number, lonDeg: number): number | null;

package/dist/src/events.js

@@ -73,7 +73,7 @@ export function riseSet(engine, body, jdStart, latDeg, lonDeg, kind = "rise", op
         const [alt, , dist] = topoAltHa(engine, body, t, latDeg, lonDeg, altM);
         let sd = 0.0;
         const diam = DIAMETER_KM[body];
-        if (diam !== undefined && dist !== null) {
+        if (!opts.discCenter && diam !== undefined && dist !== null) {
             sd = Math.asin(diam / (2 * dist * KM_PER_AU));
         }
         const h0 = -((R0_ARCMIN / 60.0) * scale * DEG + sd);
@@ -154,3 +154,31 @@ export function stations(engine, body, jdStart, jdEnd, maxHits = 30) {
     }
     return out;
 }
+/** Gauquelin sector (1..36, float) from rise/set times of the disc center
+ *  with refraction (Swiss Ephemeris method 3). Sectors run from rise: 1-18
+ *  above the horizon, 19-36 below. Null in polar no-rise/no-set
+ *  conditions. */
+export function gauquelinSector(engine, body, jdUt, latDeg, lonDeg) {
+    const surrounding = (kind) => {
+        let t = riseSet(engine, body, jdUt - 1.3, latDeg, lonDeg, kind, { discCenter: true });
+        let prev = null;
+        while (t !== null && t <= jdUt) {
+            prev = t;
+            t = riseSet(engine, body, t + 1e-4, latDeg, lonDeg, kind, { discCenter: true });
+        }
+        return [prev, t];
+    };
+    const [prevRise] = surrounding("rise");
+    const [prevSet, nextSetA] = surrounding("set");
+    if (prevRise === null || prevSet === null)
+        return null;
+    if (prevRise > prevSet) {
+        if (nextSetA === null)
+            return null;
+        return 1 + (18 * (jdUt - prevRise)) / (nextSetA - prevRise);
+    }
+    const [, nextRise] = surrounding("rise");
+    if (nextRise === null)
+        return null;
+    return 19 + (18 * (jdUt - prevSet)) / (nextRise - prevSet);
+}

package/dist/src/index.d.ts

@@ -3,3 +3,5 @@ export * from "./houses.js";
 export * from "./chart.js";
 export * from "./pheno.js";
 export * from "./events.js";
+export * from "./stars.js";
+export * from "./eclipses.js";

package/dist/src/index.js

@@ -3,3 +3,5 @@ export * from "./houses.js";
 export * from "./chart.js";
 export * from "./pheno.js";
 export * from "./events.js";
+export * from "./stars.js";
+export * from "./eclipses.js";

package/dist/src/node-loader.js

@@ -31,6 +31,9 @@ export function loadNodeData(dir, level = "embedded", moonTier = "full") {
     if (existsSync(join(dir, "uranian_kepler.json"))) {
         data.keplerPack = j("uranian_kepler.json");
     }
+    if (existsSync(join(dir, "fixed_stars.json"))) {
+        data.fixedStars = j("fixed_stars.json");
+    }
     // asteroid packs (Horizons fits): loaded when present, ~380 KB total
     for (const b of ["ceres", "pallas", "juno", "vesta", "pholus"]) {
         if (existsSync(join(dir, `${b}_cheb.json`))) {

package/dist/src/stars.d.ts

@@ -0,0 +1,29 @@
+/**
+ * astroengine stars -- fixed stars: apparent places from the HYG-derived
+ * catalog (data/fixed_stars.json; ICRS J2000 with proper motions).
+ *
+ * Chain: full 3D space motion (proper motion + radial velocity at the
+ * parallax distance) -> ICRS equatorial -> ecliptic J2000 -> IAU 1976
+ * precession to date -> annual aberration (classic elliptic form, as for
+ * Pluto/Chiron) -> nutation. Validated against swe_fixstar fed the same
+ * catalog rows: <=0.6 arcsec over 1900-2099 (the floor is the IAU 1976 vs
+ * Vondrak precession difference, shared with the rest of the engine).
+ */
+import { EngineData } from "./core.js";
+export interface StarEntry {
+    ra: number;
+    dec: number;
+    pmra: number;
+    pmdec: number;
+    rv: number;
+    plx: number;
+    mag: number;
+    bayer: string;
+}
+export interface StarPack {
+    provenance: string;
+    frame: string;
+    stars: Record<string, StarEntry>;
+}
+/** Apparent ecliptic [lon, lat] of date (rad) for a catalog entry. */
+export declare function starApparent(data: EngineData, s: StarEntry, jde: number): [number, number];

package/dist/src/stars.js

@@ -0,0 +1,53 @@
+/**
+ * astroengine stars -- fixed stars: apparent places from the HYG-derived
+ * catalog (data/fixed_stars.json; ICRS J2000 with proper motions).
+ *
+ * Chain: full 3D space motion (proper motion + radial velocity at the
+ * parallax distance) -> ICRS equatorial -> ecliptic J2000 -> IAU 1976
+ * precession to date -> annual aberration (classic elliptic form, as for
+ * Pluto/Chiron) -> nutation. Validated against swe_fixstar fed the same
+ * catalog rows: <=0.6 arcsec over 1900-2099 (the floor is the IAU 1976 vs
+ * Vondrak precession difference, shared with the rest of the engine).
+ */
+import { DEG, ARCSEC, J2000, mod, nutation, precessEcliptic, vsopHeliocentric, } from "./core.js";
+const TWO_PI = 2 * Math.PI;
+const KM_PER_AU = 149597870.7;
+const AU_PER_PC = 206264.806;
+/** Apparent ecliptic [lon, lat] of date (rad) for a catalog entry. */
+export function starApparent(data, s, jde) {
+    const t = (jde - J2000) / 365.25;
+    const ra = s.ra * DEG;
+    const dec = s.dec * DEG;
+    const rAu = s.plx > 0 ? AU_PER_PC / (s.plx * 1e-3) : 1e9 * AU_PER_PC;
+    const cd = Math.cos(dec);
+    const sd = Math.sin(dec);
+    const cr = Math.cos(ra);
+    const sr = Math.sin(ra);
+    const p = [cd * cr, cd * sr, sd];
+    const east = [-sr, cr, 0.0];
+    const north = [-sd * cr, -sd * sr, cd];
+    const pmra = s.pmra * 1e-3 * ARCSEC;
+    const pmdec = s.pmdec * 1e-3 * ARCSEC;
+    const rv = (s.rv * 86400 * 365.25) / KM_PER_AU;
+    const pos = [0, 1, 2].map((i) => p[i] * rAu + (east[i] * pmra * rAu + north[i] * pmdec * rAu + p[i] * rv) * t);
+    const rn = Math.sqrt(pos[0] ** 2 + pos[1] ** 2 + pos[2] ** 2);
+    const x = pos[0] / rn;
+    const y = pos[1] / rn;
+    const z = pos[2] / rn;
+    const ra2 = Math.atan2(y, x);
+    const dec2 = Math.asin(z);
+    const e0 = 84381.448 * ARCSEC;
+    let lat = Math.asin(Math.sin(dec2) * Math.cos(e0) - Math.cos(dec2) * Math.sin(e0) * Math.sin(ra2));
+    let lon = mod(Math.atan2(Math.sin(ra2) * Math.cos(e0) + Math.tan(dec2) * Math.sin(e0), Math.cos(ra2)), TWO_PI);
+    [lon, lat] = precessEcliptic(lon, lat, J2000, jde);
+    const [L0] = vsopHeliocentric(data.vsop.earth, jde);
+    const sunLon = mod(L0 + Math.PI, TWO_PI);
+    const T = (jde - J2000) / 36525.0;
+    const k = 20.4898 * ARCSEC;
+    const e = 0.016708634 - 0.000042037 * T;
+    const piPer = (102.93735 + 1.71946 * T) * DEG;
+    lon += (-k * Math.cos(sunLon - lon) + e * k * Math.cos(piPer - lon)) / Math.cos(lat);
+    lat += -k * Math.sin(lat) * (Math.sin(sunLon - lon) - e * Math.sin(piPer - lon));
+    lon = mod(lon + nutation(data, jde)[0], TWO_PI);
+    return [lon, lat];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "caelus",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Astrological ephemeris engine. MIT, no AGPL, no ephemeris files. Checked against Swiss Ephemeris.",
   "type": "module",
   "main": "dist/src/index.js",