732642856
252 lines
9.7 KiB
Python
252 lines
9.7 KiB
Python
#!/usr/bin/env python3
|
|
"""Audit Vimshottari Dasha boundary drift against an external reference date.
|
|
|
|
This script is diagnostic. It does not tune or override the production Dasha
|
|
engine; it quantifies how much of a boundary difference can be explained by
|
|
birth-clock precision and year-length constants.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import math
|
|
import os
|
|
import sys
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
|
|
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
|
if SCRIPT_DIR not in sys.path:
|
|
sys.path.insert(0, SCRIPT_DIR)
|
|
|
|
import jyotish_engine as engine # noqa: E402
|
|
|
|
|
|
YEAR_LENGTHS = [365.0, 365.2422, 365.25, 365.25636, 360.0]
|
|
NAKSHATRA_SPAN = 360.0 / 27.0
|
|
|
|
|
|
def _birth_time_string(hour: int, minute: int, second: int = 0) -> str:
|
|
if second:
|
|
return f"{hour:02d}:{minute:02d}:{second:02d}"
|
|
return f"{hour:02d}:{minute:02d}:00"
|
|
|
|
|
|
def _birth_datetime(args: argparse.Namespace, *, second: int | None = None) -> datetime:
|
|
sec = args.second if second is None else second
|
|
return datetime(args.year, args.month, args.day, args.hour, args.minute, sec)
|
|
|
|
|
|
def _engine_args(args: argparse.Namespace, *, second: int | None = None) -> argparse.Namespace:
|
|
return argparse.Namespace(
|
|
moon_lon=None,
|
|
nakshatra=None,
|
|
pada=None,
|
|
birthdate=None,
|
|
today=None,
|
|
year=args.year,
|
|
month=args.month,
|
|
day=args.day,
|
|
hour=args.hour,
|
|
minute=args.minute,
|
|
second=args.second if second is None else second,
|
|
lat=args.lat,
|
|
lon=args.lon,
|
|
tz=args.tz,
|
|
node_mode=args.node_mode,
|
|
)
|
|
|
|
|
|
def _chart(args: argparse.Namespace, *, second: int | None = None) -> dict[str, Any]:
|
|
chart, _asc_idx, _jd, _ayanamsa = engine._compute_chart_from_args(_engine_args(args, second=second))
|
|
if chart is None:
|
|
raise RuntimeError("Swiss Ephemeris is required for dasha reference audit")
|
|
return chart
|
|
|
|
|
|
def _moon_context(args: argparse.Namespace, *, second: int | None = None) -> dict[str, Any]:
|
|
chart = _chart(args, second=second)
|
|
moon = chart.get("planets", {}).get("Moon", {})
|
|
moon_lon = float(moon["degree_raw"])
|
|
nak_index = int(moon_lon / NAKSHATRA_SPAN)
|
|
progress = (moon_lon % NAKSHATRA_SPAN) / NAKSHATRA_SPAN
|
|
nak_name, start_lord, start_years = engine.NAKSHATRA_LIST[nak_index % 27]
|
|
return {
|
|
"chart": chart,
|
|
"moon_lon": moon_lon,
|
|
"nakshatra_index": nak_index,
|
|
"nakshatra": nak_name,
|
|
"start_lord": start_lord,
|
|
"start_years": start_years,
|
|
"progress": progress,
|
|
"elapsed_years": progress * start_years,
|
|
"balance_years": start_years - progress * start_years,
|
|
}
|
|
|
|
|
|
def _boundary_from_context(
|
|
birth_dt: datetime,
|
|
context: dict[str, Any],
|
|
year_length: float,
|
|
) -> datetime:
|
|
elapsed_years = float(context["elapsed_years"])
|
|
return birth_dt - timedelta(days=elapsed_years * year_length)
|
|
|
|
|
|
def _boundary_snapshot(args: argparse.Namespace, *, second: int, year_length: float = 365.25) -> dict[str, Any]:
|
|
ctx = _moon_context(args, second=second)
|
|
birth_dt = _birth_datetime(args, second=second)
|
|
start_dt = _boundary_from_context(birth_dt, ctx, year_length)
|
|
return {
|
|
"birth_time": _birth_time_string(args.hour, args.minute, second),
|
|
"year_length": year_length,
|
|
"moon_lon": round(ctx["moon_lon"], 8),
|
|
"nakshatra": ctx["nakshatra"],
|
|
"start_lord": ctx["start_lord"],
|
|
"progress": round(ctx["progress"], 10),
|
|
"elapsed_years": round(ctx["elapsed_years"], 8),
|
|
"balance_years": round(ctx["balance_years"], 8),
|
|
"start_datetime": start_dt.isoformat(timespec="seconds"),
|
|
}
|
|
|
|
|
|
def _required_moon_delta_for_days(
|
|
days_delta: float,
|
|
start_years: float,
|
|
year_length: float,
|
|
) -> float:
|
|
"""Return approximate Moon longitude delta in degrees for a boundary shift."""
|
|
elapsed_year_delta = abs(days_delta) / year_length
|
|
progress_delta = elapsed_year_delta / start_years if start_years else 0.0
|
|
return progress_delta * NAKSHATRA_SPAN
|
|
|
|
|
|
def build_report(args: argparse.Namespace) -> dict[str, Any]:
|
|
production = engine.cmd_dasha(_engine_args(args))
|
|
if "error" in production:
|
|
raise RuntimeError(production["error"])
|
|
first = production["timeline"][0]
|
|
context = _moon_context(args)
|
|
birth_dt = _birth_datetime(args)
|
|
start_dt = datetime.fromisoformat(first["start_datetime"])
|
|
target_dt = datetime.strptime(args.target_start_date, "%Y-%m-%d")
|
|
date_delta_days = (start_dt.date() - target_dt.date()).days
|
|
exact_delta_days = (start_dt - target_dt).total_seconds() / 86400.0
|
|
required_moon_delta_deg = _required_moon_delta_for_days(
|
|
exact_delta_days,
|
|
float(context["start_years"]),
|
|
365.25,
|
|
)
|
|
|
|
with_seconds = _boundary_snapshot(args, second=args.second)
|
|
minute_only = _boundary_snapshot(args, second=0)
|
|
with_seconds_dt = datetime.fromisoformat(with_seconds["start_datetime"])
|
|
minute_only_dt = datetime.fromisoformat(minute_only["start_datetime"])
|
|
clock_translation_seconds = args.second
|
|
moon_recalculation_seconds = int((with_seconds_dt - minute_only_dt).total_seconds()) - clock_translation_seconds
|
|
|
|
year_sensitivity = []
|
|
for year_length in YEAR_LENGTHS:
|
|
start = _boundary_from_context(birth_dt, context, year_length)
|
|
year_sensitivity.append({
|
|
"year_length": year_length,
|
|
"start_datetime": start.isoformat(timespec="seconds"),
|
|
"delta_days_vs_target_date": (start.date() - target_dt.date()).days,
|
|
})
|
|
|
|
min_delta = min(abs(row["delta_days_vs_target_date"]) for row in year_sensitivity)
|
|
if min_delta > 0:
|
|
finding = (
|
|
"当前参考差异无法由秒级输入或年长常数单独解释；"
|
|
"下一步应对比外部 oracle 的 Moon sidereal longitude、ayanamsa 与 Vimshottari 起算口径。"
|
|
)
|
|
else:
|
|
finding = "当前参考差异可能由年长常数解释；需增加外部 oracle 样本确认。"
|
|
|
|
return {
|
|
"scope": "vimshottari_dasha_reference_boundary_audit",
|
|
"case": {
|
|
"date": f"{args.year:04d}-{args.month:02d}-{args.day:02d}",
|
|
"birth_time": _birth_time_string(args.hour, args.minute, args.second),
|
|
"lat": args.lat,
|
|
"lon": args.lon,
|
|
"tz": args.tz,
|
|
"node_mode": args.node_mode,
|
|
},
|
|
"engine": {
|
|
"moon_lon": round(context["moon_lon"], 8),
|
|
"nakshatra": context["nakshatra"],
|
|
"start_lord": context["start_lord"],
|
|
"progress": round(context["progress"], 10),
|
|
"elapsed_years": round(context["elapsed_years"], 8),
|
|
"balance_years": round(context["balance_years"], 8),
|
|
"start_datetime": first["start_datetime"],
|
|
"end_datetime": first["end_datetime"],
|
|
"start_date": first["start"],
|
|
"end_date": first["end"],
|
|
},
|
|
"target_reference": {
|
|
"source": args.target_source,
|
|
"start_date": args.target_start_date,
|
|
"date_delta_days": date_delta_days,
|
|
"exact_delta_days": round(exact_delta_days, 6),
|
|
"required_moon_delta_degrees": round(required_moon_delta_deg, 8),
|
|
"required_moon_delta_arcmin_range": {
|
|
"min": round(required_moon_delta_deg * 60 * 0.95, 6),
|
|
"max": round(required_moon_delta_deg * 60 * 1.05, 6),
|
|
},
|
|
},
|
|
"clock_precision_sensitivity": {
|
|
"with_seconds": with_seconds,
|
|
"minute_only": minute_only,
|
|
"seconds_effect": {
|
|
"start_delta_seconds": int((with_seconds_dt - minute_only_dt).total_seconds()),
|
|
"clock_translation_seconds": clock_translation_seconds,
|
|
"moon_recalculation_seconds": moon_recalculation_seconds,
|
|
"moon_delta_degrees": round(with_seconds["moon_lon"] - minute_only["moon_lon"], 8),
|
|
"note": (
|
|
"Changing birth seconds both translates the birth clock and recomputes Moon longitude; "
|
|
"near long Dasha lords this can shift the historical start boundary by more than seconds."
|
|
),
|
|
},
|
|
},
|
|
"year_length_sensitivity": year_sensitivity,
|
|
"finding": finding,
|
|
"boundary": (
|
|
"This is a calculation-boundary audit, not an event-prediction accuracy claim. "
|
|
"Do not tune production Dasha constants to one PDF without a larger oracle set."
|
|
),
|
|
}
|
|
|
|
|
|
def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
|
|
parser = argparse.ArgumentParser(description="Audit Vimshottari Dasha reference drift")
|
|
parser.add_argument("--year", type=int, required=True)
|
|
parser.add_argument("--month", type=int, required=True)
|
|
parser.add_argument("--day", type=int, required=True)
|
|
parser.add_argument("--hour", type=int, required=True)
|
|
parser.add_argument("--minute", type=int, required=True)
|
|
parser.add_argument("--second", type=int, default=0)
|
|
parser.add_argument("--lat", type=float, required=True)
|
|
parser.add_argument("--lon", type=float, required=True)
|
|
parser.add_argument("--tz", type=float, required=True)
|
|
parser.add_argument("--node-mode", choices=["mean", "true"], default="mean")
|
|
parser.add_argument("--target-start-date", required=True)
|
|
parser.add_argument("--target-source", default="external_reference")
|
|
return parser.parse_args(argv)
|
|
|
|
|
|
def main(argv: list[str] | None = None) -> int:
|
|
args = parse_args(argv)
|
|
if args.second < 0 or args.second > 59:
|
|
raise SystemExit("--second must be between 0 and 59")
|
|
report = build_report(args)
|
|
print(json.dumps(report, ensure_ascii=False, indent=2))
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|