astroceleste-engine 0.0.3__tar.gz → 0.0.4__tar.gz

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "astroceleste-engine"
-version = "0.0.3"
+version = "0.0.4"
 dependencies = [
  "serde",
  "serde_json",
@@ -12,7 +12,7 @@ dependencies = [
 
 [[package]]
 name = "astroceleste-engine-py"
-version = "0.0.3"
+version = "0.0.4"
 dependencies = [
  "astroceleste-engine",
  "pyo3",
@@ -22,7 +22,7 @@ dependencies = [
 
 [[package]]
 name = "astroceleste-engine-wasm"
-version = "0.0.3"
+version = "0.0.4"
 dependencies = [
  "astroceleste-engine",
  "js-sys",

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/astroceleste-engine", "crates/astroceleste-engine-py"]
 
 [workspace.package]
-version = "0.0.3"
+version = "0.0.4"
 edition = "2021"
 rust-version = "1.85"
 license = "MIT OR Apache-2.0"

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astroceleste-engine
-Version: 0.0.3
+Version: 0.0.4
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/crates/astroceleste-engine/README.md

@@ -39,14 +39,15 @@ println!("{}", serde_json::to_string_pretty(&chart)?);
 ```
 
 Charts serialize to the same JSON as the Astroceleste API. Other entry points:
-`calculate_horary_chart`, `calculate_transit_chart`, `calculate_synastry` and
-`calculate_derived_chart`. In the browser or on mobile, load the kernel from memory with
+`calculate_horary_chart`, `calculate_transit_chart`, `calculate_synastry`,
+`calculate_derived_chart`, and for electional astrology `calculate_election_chart` and
+`search_elections` (the best moments over a span of time). In the browser or on mobile, load the kernel from memory with
 `Spk::from_bytes`.
 
 ## Bindings
 
 - **Python** (`pip install astroceleste-engine`, CPython ≥ 3.12): `Engine([kernel paths])`
-  with `.chart()`, `.horary()`, `.transit()`, plus `synastry()` and `derived_chart()`,
+  with `.chart()`, `.horary()`, `.transit()`, `.election()`, `.elections()`, plus `synastry()` and `derived_chart()`,
   returning plain dicts. See [crates/astroceleste-engine-py](https://github.com/ffalcinelli/astroceleste-engine/tree/main/crates/astroceleste-engine-py).
 - **JavaScript / WebAssembly** (`npm install astroceleste-engine`): the same API over
   kernels loaded from memory, for browsers and Node. See

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/crates/astroceleste-engine/src/almanac.rs

@@ -155,7 +155,55 @@ pub fn rise_set(
     let t_start = Time::from_ut1(jd_utc - 1.5);
     let t_end = Time::from_ut1(jd_utc + 1.5);
     let events = find_transitions(kernel, &site, t_start.tt(), t_end.tt())?;
+    Ok(select_rise_set(&events, jd_utc))
+}
+
+/// Sunrises and sunsets over a span, found once for all the days in it.
+pub(crate) struct SunEvents {
+    /// (TT Julian date, whether it is a sunrise), in time order.
+    events: Vec<(f64, bool)>,
+    /// TT span searched.
+    span: (f64, f64),
+}
+
+impl SunEvents {
+    /// Every sunrise and sunset from UT1 Julian date `jd0` to `jd1`, when a single kernel
+    /// covers the whole span (`None` otherwise).
+    pub fn find(
+        kernels: &KernelSet,
+        jd0: f64,
+        jd1: f64,
+        latitude: f64,
+        longitude: f64,
+    ) -> Result<Option<Self>, EngineError> {
+        let kernel = require_kernel(kernels, jd0)?;
+        if !(kernel.start_jd..=kernel.end_jd).contains(&jd1) {
+            return Ok(None);
+        }
+        let site = Site::new(latitude, longitude);
+        let span = (Time::from_ut1(jd0).tt(), Time::from_ut1(jd1).tt());
+        let events = find_transitions(kernel, &site, span.0, span.1)?;
+        Ok(Some(SunEvents { events, span }))
+    }
+
+    /// [`rise_set`] for `jd_utc`, from the events of its ±1.5 day window; `None` when
+    /// the window is not inside the span searched.
+    pub fn rise_set(&self, jd_utc: f64) -> Option<(f64, f64, f64)> {
+        let (t0, t1) = (
+            Time::from_ut1(jd_utc - 1.5).tt(),
+            Time::from_ut1(jd_utc + 1.5).tt(),
+        );
+        if t0 < self.span.0 || t1 > self.span.1 {
+            return None;
+        }
+        let from = self.events.partition_point(|e| e.0 < t0);
+        let to = self.events.partition_point(|e| e.0 <= t1);
+        Some(select_rise_set(&self.events[from..to], jd_utc))
+    }
+}
 
+/// The day's sunrise, sunset and next sunrise among the events around `jd_utc`.
+fn select_rise_set(events: &[(f64, bool)], jd_utc: f64) -> (f64, f64, f64) {
     let ut1 = |jd_tt: f64| Time::from_tt_jd(jd_tt).ut1();
     let sunrises: Vec<f64> = events.iter().filter(|e| e.1).map(|e| ut1(e.0)).collect();
     let sunsets: Vec<f64> = events.iter().filter(|e| !e.1).map(|e| ut1(e.0)).collect();
@@ -176,5 +224,5 @@ pub fn rise_set(
         .copied()
         .find(|&s| s > rise + 0.1)
         .unwrap_or(rise + 1.0);
-    Ok((rise, set, next_rise))
+    (rise, set, next_rise)
 }

{astroceleste_engine-0.0.3 → astroceleste_engine-0.0.4}/crates/astroceleste-engine/src/chart.rs

@@ -8,7 +8,7 @@ use crate::aspects::{natal_aspects, Aspect, OrbSettings, Point};
 use crate::ephemeris::KernelSet;
 use crate::error::EngineError;
 use crate::fixed_stars::{fixed_stars, FixedStarPosition};
-use crate::houses::{calculate_houses, HouseSystem};
+use crate::houses::{calculate_houses, HouseSystem, Houses};
 use crate::instant::UtcInstant;
 use crate::lots::{arabic_parts, Lot};
 use crate::lunar::{lunar_status, LunarStatus};
@@ -16,7 +16,7 @@ use crate::planets::calculate_planets;
 use crate::symbolic::symbolic_degree_number;
 use crate::temperament::{temperament, Temperament};
 use crate::zodiac::{
-    ayanamsa, ayanamsa_info, determine_house, longitude_to_zodiac, DEFAULT_AYANAMSA,
+    ayanamsa, ayanamsa_info, determine_house, longitude_to_zodiac, AyanamsaInfo, DEFAULT_AYANAMSA,
 };
 
 /// Every body a complete chart carries; missing ones are reported in
@@ -200,15 +200,28 @@ fn symbol_of(name: &str) -> &'static str {
     }
 }
 
-/// Compute a chart (`calculate_chart_data`).
-pub fn calculate_chart(kernels: &KernelSet, req: &ChartRequest) -> Result<Chart, EngineError> {
+/// The positions part of a chart: placements and house cusps, without aspects, fixed
+/// stars, lots or temperament. Electional searches evaluate thousands of these.
+pub(crate) struct Sky {
+    pub zodiac_type: &'static str,
+    pub is_sidereal: bool,
+    pub ayanamsa_code: &'static str,
+    pub info: AyanamsaInfo,
+    pub jd: f64,
+    /// Cusps 1-12, degrees.
+    pub cusps: Vec<f64>,
+    pub house_cusps: Vec<HouseCusp>,
+    pub planets: Vec<Placement>,
+}
+
+/// Placements and houses of a request (the first half of [`calculate_chart`]).
+pub(crate) fn sky(kernels: &KernelSet, req: &ChartRequest) -> Result<Sky, EngineError> {
     let zodiac_type = match req.zodiac_type.trim().to_lowercase().as_str() {
         "sidereal" => "sidereal",
         _ => "tropical",
     };
     let is_sidereal = zodiac_type == "sidereal";
     let ayanamsa_code = ayanamsa(req.ayanamsa).code;
-    let orbs = OrbSettings::merge(req.orb_settings)?;
 
     let jd = req.instant.julian_day();
     let info = ayanamsa_info(jd, ayanamsa_code);
@@ -242,16 +255,34 @@ pub fn calculate_chart(kernels: &KernelSet, req: &ChartRequest) -> Result<Chart,
         })
         .collect();
 
-    let mut raw: Vec<(&'static str, f64, f64, bool)> = engine
+    let raw: Vec<(&'static str, f64, f64, bool)> = engine
         .bodies
         .iter()
         .map(|b| (b.name, b.longitude, b.speed, b.is_retrograde))
         .collect();
+    let planets = placements(raw, &houses);
+
+    Ok(Sky {
+        zodiac_type,
+        is_sidereal,
+        ayanamsa_code,
+        info,
+        jd,
+        cusps,
+        house_cusps,
+        planets,
+    })
+}
+
+/// Placements of bodies given as (name, longitude, speed, retrograde), followed by the
+/// Ascendant and the Midheaven, with their houses.
+pub(crate) fn placements(
+    mut raw: Vec<(&'static str, f64, f64, bool)>,
+    houses: &Houses,
+) -> Vec<Placement> {
     raw.push(("Ascendant", houses.ascendant, 0.0, false));
     raw.push(("Midheaven", houses.midheaven, 0.0, false));
-
-    let planets: Vec<Placement> = raw
-        .iter()
+    raw.iter()
         .map(|&(name, lon, speed, is_retrograde)| {
             let z = longitude_to_zodiac(lon);
             Placement {
@@ -262,13 +293,28 @@ pub fn calculate_chart(kernels: &KernelSet, req: &ChartRequest) -> Result<Chart,
                 degree: z.degree,
                 minute: z.minute,
                 ecliptic_longitude: lon,
-                house: determine_house(lon, &cusps),
+                house: determine_house(lon, &houses.cusps),
                 speed,
                 is_retrograde,
                 symbolic_degree: symbolic_degree_number(z.degree, z.minute),
             }
         })
-        .collect();
+        .collect()
+}
+
+/// Compute a chart (`calculate_chart_data`).
+pub fn calculate_chart(kernels: &KernelSet, req: &ChartRequest) -> Result<Chart, EngineError> {
+    let orbs = OrbSettings::merge(req.orb_settings)?;
+    let Sky {
+        zodiac_type,
+        is_sidereal,
+        ayanamsa_code,
+        info,
+        jd,
+        cusps,
+        house_cusps,
+        planets,
+    } = sky(kernels, req)?;
     let points: Vec<Point> = planets
         .iter()
         .map(|p| Point {