abstract-math 0.0.0.24__tar.gz → 0.0.0.25__tar.gz

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_math
-Version: 0.0.0.24
+Version: 0.0.0.25
 Author: putkoff
 Author-email: partners@abstractendeavors.com
 Classifier: Development Status :: 3 - Alpha

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/setup.py

@@ -4,7 +4,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 setuptools.setup(
     name='abstract_math',
-    version='0.0.0.24',
+    version='0.0.0.25',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="",

abstract_math-0.0.0.25/src/abstract_math/createflask.py

@@ -0,0 +1,4 @@
+from abstract_flask.generator import *
+directory = "/home/computron/Documents/pythonTools/modules/abstract_math/src/abstract_math/solar_math"
+from_files = generate_from_files(directory=directory)
+input(from_files)

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/flask_scripts/flask_utils.py

@@ -1,7 +1,7 @@
 from abstract_flask import *  # must provide Blueprint, request, jsonify, get_request_data, get_logFile, offer_help
 from ..solar_math import *
 # Auto-generated routes
-math_data_bp = Blueprint('math_data_bp', __name__, url_prefix='/utils')
+math_data_bp = Blueprint('math_data_bp', __name__, url_prefix='/utils/')
 logger = get_logFile('math_data_bp')
 
 @math_data_bp.route("/normalized_velocity_conversioin", methods=["GET", "POST"], strict_slashes=False)

abstract_math-0.0.0.25/src/abstract_math/solar_math/main.py

@@ -0,0 +1,279 @@
+# adapt_units_api.py  (or wherever you glue this in)
+from typing import *
+from .src.constants.distance_constants import dconvert, _factor as dfactor
+from .src.constants.time_constants import seconds_per
+from .src.constants.planet_constants import planet_radius, get_body, g_at_radius
+from .src.utils.geometry_utils import visible_area_flat, visible_surface_angle
+from .src.utils import get_R_mu,get_normalized_distance,get_normalized_starting_velocity
+from .src.imports import math, mul, div, add  # your abstract_math ops
+from .src.constants import (
+    DEFAULT_UNITS,
+    DEFAULT_TIME,
+    DEFAULT_PLANET,
+    DEFAULT_START_ALTITUDE,
+    DEFAULT_AS_RADIUS
+    )
+def normalize_inputs(
+    planet: str,
+    start_altitude: float,
+    starting_velocity: float,
+    input_units: str,
+    input_time: str,
+    target_distance: float = None,
+) -> dict:
+    """Normalize input altitudes and velocities into SI (meters, seconds)."""
+    start_alt_m = get_normalized_distance(start_altitude, input_units)
+    target_alt_m = get_normalized_distance(target_distance, input_units)
+
+    v0_mps = get_normalized_starting_velocity(
+        start_altitude=start_alt_m,
+        starting_velocity=starting_velocity,
+        input_units=input_units,
+        input_time=input_time,
+        planet=planet,
+    )
+
+    return {
+        "start_alt_m": start_alt_m,
+        "target_alt_m": target_alt_m,
+        "v0_mps": v0_mps,
+    }
+# --- Analyzer (prints a scan; no blocking input) ---
+def analyze_visible_surface(
+    altitude_step: float = 200.0,
+    max_steps: int = 20,
+    fov_range: tuple[int, int] = (20, 160),
+    fov_interval: int = 10,
+    input_units: str = DEFAULT_UNITS,      # how to interpret altitude numbers
+    display_units: str = DEFAULT_UNITS,    # how to print areas/radii
+    planet: str = DEFAULT_PLANET,
+    printit: bool = False
+):
+    """
+    Scan altitudes/FOVs. Altitudes are interpreted in `input_units`.
+    Results are printed in `display_units`.
+    """
+    # Planet radius and full area (compute in meters, convert for display)
+    r_m = planet_radius(planet, DEFAULT_UNITS)
+    full_area_m2 = 4.0 * math.pi * (r_m ** 2)
+    k_disp = dfactor(DEFAULT_UNITS, display_units)      # linear meter->display factor
+    full_area_disp = full_area_m2 * (k_disp ** 2)  # convert area to display units^2
+
+    all_stats = {"output": "", "input_units": input_units,
+                 "display_units": display_units, "vars": []}
+
+    for i in range(1, max_steps + 1):
+        all_stats["vars"].append({})
+        altitude_in = altitude_step * i                       # input_units
+        altitude_m  = dconvert(altitude_in, input_units, DEFAULT_UNITS)
+
+        all_stats["vars"][-1]['altitude_input'] = altitude_in
+        all_stats["vars"][-1]['input_units']    = input_units
+        all_stats["vars"][-1]['fov']            = []
+
+        alt_pretty = dconvert(altitude_in, input_units, display_units)
+        all_stats["output"] += (
+            f"\n=== Altitude: {altitude_in} {input_units} (≈ {alt_pretty:.3f} {display_units}) ===\n"
+        )
+
+        for fov in range(fov_range[0], fov_range[1] + 1, fov_interval):
+            # Compute visible area/radius in meters, convert to display units
+            area_m2, vis_radius_m = visible_area_flat(fov, altitude_m, DEFAULT_UNITS)
+            area_disp = area_m2 * (k_disp ** 2)
+            vis_radius_disp = dconvert(vis_radius_m, DEFAULT_UNITS, display_units)
+
+            # Span uses geometry only; r_m is in meters
+            _, angle_deg = visible_surface_angle(vis_radius_m, r_m)
+
+            coverage_pct = 100.0 * (area_disp / full_area_disp)
+
+            fov_output = (
+                f"FOV: {fov:>3}° | "
+                f"Area: {area_disp:>12.2f} {display_units}² | "
+                f"Span: {angle_deg:>7.2f}° | "
+                f"Flat-visible: {coverage_pct:>6.3f}% | "
+                f"visR≈{vis_radius_disp:.3f} {display_units}"
+            )
+            all_stats["output"] += fov_output + "\n"
+
+            all_stats["vars"][-1]['fov'].append({
+                "FOV": fov,
+                "area": area_disp,
+                "angle_deg": angle_deg,
+                "coverage_pct": coverage_pct,
+                "visible_radius": vis_radius_disp,
+                "output": fov_output
+            })
+
+    if printit:
+        print(all_stats.get('output'))
+    return all_stats
+# --- core integrator step ---
+def calculate_avrt(mu, v, r, t=0.0, dt_s=1.0, steps=0):
+    """Single Euler step update for radial motion."""
+    a = - div(mu, mul(r, r))  # inward accel
+    v = add(v, mul(a, dt_s))
+    r = add(r, mul(v, dt_s))
+    t = add(t, dt_s)
+    steps += 1
+    return v, r, t, steps
+
+
+# --- tracker helper ---
+def init_tracker(r0: float) -> dict:
+    """Initialize stats tracker."""
+    return {
+        "furthest_r": r0,
+        "time_at_furthest": 0.0,
+        "furthest_step": 0,
+        "total_distance": 0.0,
+    }
+
+
+# --- SI integrator with tracking ---
+def simulate_radial_flight_si(
+    v0_mps: float,
+    start_alt_m: float,
+    planet: str,
+    dt_s: float = 1.0,
+    max_steps: int = 5_000_000,
+    target_alt_m: float = None
+) -> dict:
+    """Forward-Euler radial integrator, SI only (meters/seconds)."""
+    R, mu = get_R_mu(planet=planet)
+    r0 = add(R, start_alt_m)
+    r  = r0
+    v  = v0_mps
+    t  = 0.0
+    prev_r = r0
+    r_target = add(R, target_alt_m) if target_alt_m else float("inf")
+    traveled_m = 0.0
+
+    hit_surface, hit_target, turned_back = False, False, False
+    steps = 0
+    tracker = init_tracker(r0)
+
+    for _ in range(max_steps):
+        if r <= R:
+            hit_surface = True
+            break
+        if target_alt_m and r >= r_target:
+            hit_target = True
+            break
+
+        v, r, t, steps = calculate_avrt(mu, v, r, t, dt_s, steps)
+
+        # update traveled distance
+        traveled_step = abs(r - prev_r)
+        traveled_m += traveled_step
+        tracker["total_distance"] += traveled_step
+        prev_r = r
+
+        # update furthest distance tracker
+        if r > tracker["furthest_r"]:
+            tracker["furthest_r"] = r
+            tracker["time_at_furthest"] = t
+            tracker["furthest_step"] = steps
+
+        # detect turnaround
+        if not target_alt_m and v < 0 and r < r0:
+            turned_back = True
+            break
+
+    altitude_m = max(0.0, r - R)
+    g_end      = g_at_radius(mu, r)
+    g_surface  = g_at_radius(mu, R)
+
+    return {
+        "ok": True,
+        "planet": planet,
+        "r_m": r,
+        "altitude_m": altitude_m,
+        "vEnd_mps": v,
+        "time_s": t,
+        "g_end_mps2": g_end,
+        "g_ratio_surface": div(g_end, g_surface),
+        "steps": steps,
+        "hit_surface": hit_surface,
+        "hit_target": hit_target,
+        "turned_back": turned_back,
+        "traveled_m": traveled_m,
+        "vesc_end_mps": math.sqrt(mul(2.0, div(mu, r))),
+
+        # extended stats
+        "furthest_r": tracker["furthest_r"],
+        "furthest_altitude_m": tracker["furthest_r"] - R,
+        "time_at_furthest": tracker["time_at_furthest"],
+        "total_distance_m": tracker["total_distance"],
+    }
+
+
+# --- wrapper with unit conversions ---
+def radial_travel(
+    starting_velocity: float = None,
+    start_altitude: float = None,
+    input_units: str = DEFAULT_UNITS,
+    input_time: str = DEFAULT_TIME,
+    output_units: str = DEFAULT_UNITS,
+    output_time: str = DEFAULT_TIME,
+    *,
+    planet: str = DEFAULT_PLANET,
+    dt_s: float = 1.0,
+    max_steps: int = 5_000_000,
+    target_distance: float = None
+) -> dict:
+    """Wrapper: handles units, runs SI integrator, converts outputs."""
+    norm = normalize_inputs(
+        planet=planet, start_altitude=start_altitude, starting_velocity=starting_velocity,
+        input_units=input_units, input_time=input_time, target_distance=target_distance
+    )
+
+    sim = simulate_radial_flight_si(
+        v0_mps=norm["v0_mps"],
+        start_alt_m=norm["start_alt_m"],
+        planet=planet,
+        dt_s=dt_s,
+        max_steps=max_steps,
+        target_alt_m=norm["target_alt_m"],
+    )
+    if not sim.get("ok"):
+        return sim
+
+    # Output conversions
+    sec_per_out = seconds_per(output_time)
+    conv = lambda m: dconvert(m, DEFAULT_UNITS, output_units)
+
+    return {
+        "ok": True,
+        "planet": planet,
+        "inputs": {
+            "start_altitude": start_altitude,
+            "starting_velocity": starting_velocity,
+            "input_units": input_units,
+            "input_time": input_time,
+            "output_units": output_units,
+            "output_time": output_time,
+            "target_distance": target_distance,
+        },
+        # final state
+        "altitude": conv(sim["altitude_m"]),
+        "radius_from_center": conv(sim["r_m"]),
+        "distance_traveled": conv(sim["traveled_m"]),
+        "velocity": mul(dconvert(sim["vEnd_mps"], DEFAULT_UNITS, output_units), sec_per_out),
+        "velocity_escape_end": mul(dconvert(sim["vesc_end_mps"], DEFAULT_UNITS, output_units), sec_per_out),
+        "time": div(sim["time_s"], sec_per_out),
+        "time_unit": output_time,
+        "g_end_mps2": sim["g_end_mps2"],
+        "g_ratio_surface": sim["g_ratio_surface"],
+        "steps": sim["steps"],
+        "hit_surface": sim["hit_surface"],
+        "hit_target": sim["hit_target"],
+        "turned_back": sim["turned_back"],
+
+        # extended stats (converted)
+        "furthest_distance": conv(sim["furthest_altitude_m"]),
+        "furthest_radius": conv(sim["furthest_r"]),
+        "time_at_furthest": div(sim["time_at_furthest"], sec_per_out),
+        "total_distance": conv(sim["total_distance_m"]),
+    }
+

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/solar_math/src/constants/__init__.py

@@ -2,12 +2,12 @@
 from .distance_constants import (
     DISTANCE_CONVERSIONS, ALL_DISTANCE_UNITS,
     normalize_distance_unit, get_distance_unit_conversions,
-    _factor, convert,
+    _factor, dconvert,DEFAULT_UNITS,DEFAULT_START_ALTITUDE
 )
 from .time_constants import (
     TIME_CONVERSIONS, ALL_TIME_UNITS,
     normalize_time_unit, get_time_unit_conversions,
-    time_factor, convert_time, seconds_per,
+    time_factor, convert_time, seconds_per,DEFAULT_TIME
 )
 from .planet_constants import (
     PLANETS, G, g0, MU_MOON,
@@ -15,5 +15,5 @@ from .planet_constants import (
     full_planet_surface_area, planet_volume, planet_circumference,
     planet_mass, planet_surface_g, escape_velocity,
     earth_radius, earth_diameter, full_earth_surface_area,
-    earth_volume, earth_circumference,
+    earth_volume, earth_circumference,DEFAULT_PLANET,DEFAULT_AS_RADIUS
 )

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/solar_math/src/constants/distance_constants.py

@@ -19,6 +19,8 @@ DISTANCE_CONVERSIONS: Dict[str, Dict[str, Dict[str, float]]] = {
     "feet": FEET
 }
 ALL_DISTANCE_UNITS = ("meters", "kilometers", "miles", "feet")
+DEFAULT_UNITS="meters"
+DEFAULT_START_ALTITUDE=0.0
 # -------------------------
 # Unit helpers
 # -------------------------
@@ -41,5 +43,27 @@ def _factor(unit_from: str, unit_to: str) -> float:
     ut = get_distance_unit_conversions(unit_to)["conv"]["meters"]    # meters per 1 to-unit
     return div(uf, ut)
 
-def convert(value: float, unit_from: str, unit_to: str) -> float:
+def dconvert(value: float, unit_from: str, unit_to: str) -> float:
     return mul(value, _factor(unit_from, unit_to))
+def get_normalized_distance(
+    distance: Optional[float] = None,
+    input_units: str = DEFAULT_UNITS
+    ):
+    distance = target_alt_m = distance or 0
+    if distance is not None:
+        target_alt_m = dconvert(value=distance,
+                unit_from=input_units,
+                unit_to=DEFAULT_UNITS
+                )
+    return target_alt_m
+def get_target_distance(
+    distance: Optional[float] = None,
+    input_units: str = DEFAULT_UNITS,
+    output_units: str = DEFAULT_UNITS,
+    ):
+    distance = target_distance = distance or 0
+    if distance is not None:
+        target_distance = dconvert(value=distance,
+                              unit_from=input_units,
+                              unit_to=output_units)
+    return target_distance

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/solar_math/src/constants/planet_constants.py

@@ -28,7 +28,8 @@ PLANETS = [
     { "name":'Neptune',"m0_deg":-55.12002969,"mu":6.83653e15,"a":4.4983964e12,"e":0.00859048,"radiusPx":10,"color":'#4363d8',"radius":24764000,"escapeVel":23500,"n":8,"peri_lon_deg":44.96476227 },
     { "name":'Moon',"m0_deg":0,"mu":MU_MOON,"a":3.844e8,"e":0.0549,"radiusPx":5,"color":'lightgray',"radius":1.737e6,"escapeVel":2380,"n":9}
 ]
-
+DEFAULT_PLANET='earth'
+DEFAULT_AS_RADIUS=False
 # -------------------------
 # Body enrichment + lookup
 # -------------------------
@@ -46,7 +47,7 @@ def _enrich_body(b: Dict[str, Any]) -> Dict[str, Any]:
 
 _NAME_ALIASES = {"sol": "sun", "terra": "earth", "luna": "moon"}
 def _normalize_name(name: str) -> str:
-    n = name.strip().lower()
+    n = name.lower()
     return _NAME_ALIASES.get(n, n)
 
 _BODY_BY_NAME: Dict[str, Dict[str, Any]] = {}
@@ -154,3 +155,9 @@ def get_body(planet: str) -> Dict[str, Any]:
 
 def g_at_radius(mu: float, r_m: float) -> float:
     return div(mu, mul(r_m, r_m))
+
+def get_R_mu(planet: str = DEFAULT_PLANET):
+    body = get_body(planet)
+    mu = body.get("mu")          # m^3/s^2
+    R  = body.get("radius")      # m
+    return R,mu

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/solar_math/src/constants/time_constants.py

@@ -21,7 +21,7 @@ TIME_CONVERSIONS = {
     "days":    DAYS,
 }
 ALL_TIME_UNITS = ("seconds", "minutes", "hours", "days")
-
+DEFAULT_TIME="s"
 def normalize_time_unit(unit: str) -> str:
     u = unit.strip().lower()
     if u in TIME_CONVERSIONS:

abstract_math-0.0.0.25/src/abstract_math/solar_math/src/utils/escape_velocity.py

@@ -0,0 +1,111 @@
+# src/utils/escape_velocity.py
+from ..imports import math, mul, div, add
+from ..constants import (
+    DEFAULT_UNITS,
+    DEFAULT_TIME,
+    DEFAULT_PLANET,
+    DEFAULT_START_ALTITUDE,
+    DEFAULT_AS_RADIUS
+    )
+from ..constants.planet_constants import get_body,get_R_mu
+from ..constants.distance_constants import dconvert,get_target_distance,get_normalized_distance
+from ..constants.time_constants import get_time_unit_conversions, normalize_time_unit, seconds_per
+from .velocity_utils import normalized_velocity_conversioin
+def get_r_m(planet: str = DEFAULT_PLANET,start_altitude: float = DEFAULT_START_ALTITUDE,input_units: str = DEFAULT_UNITS,as_radius:bool = DEFAULT_AS_RADIUS):
+    R,mu = get_R_mu(planet=planet)
+    r_m = dconvert(start_altitude, input_units, DEFAULT_UNITS)
+    # Determine radius from center in meters
+    if not as_radius:
+        r_m = add(R, r_m)
+    if r_m <= 0:
+        return {"ok": False, "error": "computed radius is non-positive"}
+    return r_m
+def get_vesc_mps(
+    planet: str = DEFAULT_PLANET,
+    start_altitude: float = DEFAULT_START_ALTITUDE,
+    input_units: str = DEFAULT_UNITS,
+    as_radius:bool = DEFAULT_AS_RADIUS
+    ):
+    R,mu = get_R_mu(planet=planet)
+    r_m = get_r_m(planet=planet,start_altitude=start_altitude,input_units=input_units,as_radius=as_radius)
+    vesc_mps = math.sqrt(mul(2.0, div(mu, r_m)))
+    return vesc_mps
+
+
+
+def get_normalized_starting_velocity(
+    start_altitude: float = None, 
+    starting_velocity: float = None, 
+    input_units: str = DEFAULT_UNITS,    # distance part of starting_velocity & start_distance
+    input_time: str = DEFAULT_TIME,          # time part of starting_velocity
+    output_units: str = DEFAULT_UNITS,
+    output_time: str = DEFAULT_TIME,
+    planet: str = DEFAULT_PLANET
+    ):
+    start_altitude = start_altitude or 0
+    if starting_velocity == None:
+        starting_velocity = escape_velocity_at(planet=planet,
+                                               start_altitude=start_altitude,
+                                               input_time=input_time,
+                                               input_units=input_units,
+                                               output_time=input_time,
+                                               output_units=input_units
+                                               )
+    return normalized_velocity_conversioin(
+        velocity=starting_velocity,
+        input_time=input_time,
+        input_units=input_units
+        )
+
+def escape_velocity_at(
+    planet: str = DEFAULT_PLANET,
+    start_altitude: float = DEFAULT_START_ALTITUDE,
+    *,
+    input_time: str = DEFAULT_TIME,     # how to interpret `distance`
+    input_units: str = DEFAULT_UNITS,     # how to interpret `distance`
+    output_units: str = DEFAULT_UNITS,    # distance unit for the *speed*
+    output_time: str = DEFAULT_TIME,          # time unit for the *speed*
+    as_radius: bool = DEFAULT_AS_RADIUS          # False => `distance` is altitude above surface; True => radius from center
+) -> dict:
+    """
+    Compute v_escape at a given location around `planet`.
+
+    Args:
+        planet: body name (must exist in PLANETS)
+        start_altitude: if as_radius=False => altitude above surface; if as_radius=True => radius from center
+        input_units: units of `distance`
+        output_units: distance unit of the returned speed
+        output_time: time unit of the returned speed ('s'|'min'|'h' etc.)
+        as_radius: interpret `distance` as radius-from-center when True
+
+    Returns:
+        {
+          "ok": True,
+          "planet": str,
+          "radius_from_center": <float in output_units>,
+          "v_escape": <float in output_units/output_time>,
+          "v_escape_mps": <float in m/s>,
+          "units": {"distance": output_units, "time": output_time}
+        }
+    """
+    if not (isinstance(start_altitude, (int, float)) and math.isfinite(start_altitude) and start_altitude >= 0):
+        return {"ok": False, "error": "distance must be a non-negative number"}
+    R,mu = get_R_mu(planet=planet)
+    # v_esc (m/s)
+    r_m = get_r_m(planet=planet,start_altitude=start_altitude,input_units=input_units,as_radius=as_radius)
+    vesc_mps = get_vesc_mps(planet=planet,start_altitude=start_altitude,input_units=input_units,as_radius=as_radius)
+    # Convert speed to <output_units>/<output_time>
+    vesc_units_per_time = dconvert(vesc_mps, DEFAULT_UNITS, output_units)
+    time_per = seconds_per(output_time)         # seconds per 1 output_time
+    vesc_out = mul(vesc_units_per_time, time_per)  # <output_units>/<output_time>
+    # Also return the radius in output_units for convenience
+    r_out = dconvert(r_m, DEFAULT_UNITS, output_units)
+
+    return {
+        "ok": True,
+        "planet": planet,
+        "radius_from_center": r_out,
+        "v_escape": vesc_out,
+        "v_escape_mps": vesc_mps,
+        "units": {"distance": output_units, "time": output_time}
+    }

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math/solar_math/src/utils/velocity_utils.py

@@ -24,3 +24,29 @@ def mps_to_distance_per_time(v_mps: float, dist_units: str, time_units: str) ->
     v_units_per_sec = div(v_mps, meters_per_unit)          # [dist_units / s]
     sec_per_time = seconds_per(time_units)
     return mul(v_units_per_sec, sec_per_time)              # [dist_units / time_units]
+
+
+
+
+def get_velocity_conversioin(
+    velocity,
+    input_time: str = DEFAULT_TIME,
+    input_units: str = DEFAULT_UNITS,
+    output_units: str = DEFAULT_UNITS,
+    output_time: str = DEFAULT_TIME,
+    ):
+    v0_mps = distance_per_time_to_mps(v=velocity, dist_units=input_units, time_units=input_time)
+    v0_unit_p_time = mps_to_distance_per_time(v_mps=v0_mps, dist_units=output_units, time_units=output_time)
+    return v0_unit_p_time
+
+def normalized_velocity_conversioin(
+    velocity,
+    input_time: str = DEFAULT_TIME,
+    input_units: str = DEFAULT_UNITS
+    ):
+    v0_mps = get_velocity_conversioin(
+        velocity=velocity,
+        input_time=input_time,
+        input_units=input_units
+        )
+    return v0_mps

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstract_math
-Version: 0.0.0.24
+Version: 0.0.0.25
 Author: putkoff
 Author-email: partners@abstractendeavors.com
 Classifier: Development Status :: 3 - Alpha

{abstract_math-0.0.0.24 → abstract_math-0.0.0.25}/src/abstract_math.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ README.md
 pyproject.toml
 setup.py
 src/abstract_math/__init__.py
+src/abstract_math/createflask.py
 src/abstract_math/derive_tokens.py
 src/abstract_math/safe_math.py
 src/abstract_math.egg-info/PKG-INFO

abstract_math-0.0.0.24/src/abstract_math/solar_math/main.py

@@ -1,263 +0,0 @@
-# adapt_units_api.py  (or wherever you glue this in)
-from typing import *
-from .src.constants.distance_constants import convert as dconvert, _factor as dfactor
-from .src.constants.time_constants import seconds_per
-from .src.constants.planet_constants import planet_radius, get_body, g_at_radius
-from .src.utils.geometry_utils import visible_area_flat, visible_surface_angle
-from .src.imports import math, mul, div, add  # your abstract_math ops
-def normalized_velocity_conversioin(starting_velocity, input_time, input_units):
-    sec_per_time = seconds_per(input_time)                             # sec / timeunit
-    v_units_per_sec = div(starting_velocity, sec_per_time)             # <input_units> / s
-    v0_mps = dconvert(v_units_per_sec, input_units, "meters")          # m / s
-    return v0_mps
-
-# --- Analyzer (prints a scan; no blocking input) ---
-def analyze_visible_surface(
-    altitude_step: float = 200.0,
-    max_steps: int = 20,
-    fov_range: tuple[int, int] = (20, 160),
-    fov_interval: int = 10,
-    input_units: str = 'meters',      # how to interpret altitude numbers
-    display_units: str = 'meters',    # how to print areas/radii
-    planet: str = 'earth',
-    printit: bool = False
-):
-    """
-    Scan altitudes/FOVs. Altitudes are interpreted in `input_units`.
-    Results are printed in `display_units`.
-    """
-    # Planet radius and full area (compute in meters, convert for display)
-    r_m = planet_radius(planet, 'meters')
-    full_area_m2 = 4.0 * math.pi * (r_m ** 2)
-    k_disp = dfactor('meters', display_units)      # linear meter->display factor
-    full_area_disp = full_area_m2 * (k_disp ** 2)  # convert area to display units^2
-
-    all_stats = {"output": "", "input_units": input_units,
-                 "display_units": display_units, "vars": []}
-
-    for i in range(1, max_steps + 1):
-        all_stats["vars"].append({})
-        altitude_in = altitude_step * i                       # input_units
-        altitude_m  = dconvert(altitude_in, input_units, 'meters')
-
-        all_stats["vars"][-1]['altitude_input'] = altitude_in
-        all_stats["vars"][-1]['input_units']    = input_units
-        all_stats["vars"][-1]['fov']            = []
-
-        alt_pretty = dconvert(altitude_in, input_units, display_units)
-        all_stats["output"] += (
-            f"\n=== Altitude: {altitude_in} {input_units} (≈ {alt_pretty:.3f} {display_units}) ===\n"
-        )
-
-        for fov in range(fov_range[0], fov_range[1] + 1, fov_interval):
-            # Compute visible area/radius in meters, convert to display units
-            area_m2, vis_radius_m = visible_area_flat(fov, altitude_m, 'meters')
-            area_disp = area_m2 * (k_disp ** 2)
-            vis_radius_disp = dconvert(vis_radius_m, 'meters', display_units)
-
-            # Span uses geometry only; r_m is in meters
-            _, angle_deg = visible_surface_angle(vis_radius_m, r_m)
-
-            coverage_pct = 100.0 * (area_disp / full_area_disp)
-
-            fov_output = (
-                f"FOV: {fov:>3}° | "
-                f"Area: {area_disp:>12.2f} {display_units}² | "
-                f"Span: {angle_deg:>7.2f}° | "
-                f"Flat-visible: {coverage_pct:>6.3f}% | "
-                f"visR≈{vis_radius_disp:.3f} {display_units}"
-            )
-            all_stats["output"] += fov_output + "\n"
-
-            all_stats["vars"][-1]['fov'].append({
-                "FOV": fov,
-                "area": area_disp,
-                "angle_deg": angle_deg,
-                "coverage_pct": coverage_pct,
-                "visible_radius": vis_radius_disp,
-                "output": fov_output
-            })
-
-    if printit:
-        print(all_stats.get('output'))
-    return all_stats
-
-
-def simulate_radial_flight(
-    planet: str,
-    start_altitude: float,
-    start_units: str,
-    v0_mps: float,
-    dt_s: float = 1.0,
-    max_steps: int = 5_000_000,
-    target_altitude_m: Optional[float] = None
-) -> dict:
-    """
-    Forward-Euler radial integrator (toy model).
-    Returns a dict with SI (meters, seconds) internal results.
-    """
-    if not (isinstance(start_altitude, (int, float)) and start_altitude >= 0):
-        return {"ok": False, "error": "Invalid start_altitude", "steps": 0}
-    if not (isinstance(v0_mps, (int, float)) and math.isfinite(v0_mps)):
-        return {"ok": False, "error": "Invalid starting_velocity (after unit conversion)", "steps": 0}
-    if not (dt_s > 0):
-        return {"ok": False, "error": "dt_s must be > 0", "steps": 0}
-
-    body = get_body(planet)
-    mu = body["mu"]
-    R  = body["radius"]
-
-    r0 = add(R, dconvert(start_altitude, start_units, "meters"))
-    r  = r0
-    v  = v0_mps   # outward positive, m/s
-    t  = 0.0
-
-    has_target = target_altitude_m is not None and target_altitude_m > 0
-    r_target   = add(R, target_altitude_m if has_target else float("inf"))
-
-    hit_surface = False
-    hit_target  = False
-    turned_back_below_start = False
-
-    steps = 0
-    for _ in range(max_steps):
-        if r <= R:
-            hit_surface = True
-            break
-        if has_target and r >= r_target:
-            hit_target = True
-            break
-
-        a = - div(mu, mul(r, r))  # inward
-        v = add(v, mul(a, dt_s))
-        r = add(r, mul(v, dt_s))
-        t = add(t, dt_s)
-        steps += 1
-
-        if (not has_target) and (v < 0) and (r < r0):
-            turned_back_below_start = True
-            break
-
-    altitude_m = max(0.0, r - R)
-    g_end      = g_at_radius(mu, r)
-    g_surface  = g_at_radius(mu, R)
-    traveled_m = max(0.0, altitude_m - (r0 - R))
-
-    return {
-        "ok": True,
-        "planet": planet,
-        "rFromCenter_m": r,
-        "altitude_m": altitude_m,
-        "vEnd_mps": v,
-        "time_s": t,
-        "gAtEnd_mps2": g_end,
-        "gRatioSurface": div(g_end, g_surface),
-        "steps": steps,
-        "hitSurface": hit_surface,
-        "hitTarget": hit_target,
-        "turnedBackBelowStart": turned_back_below_start,
-        "traveled_m": traveled_m,
-        "vEsc_end_mps": math.sqrt(mul(2.0, div(mu, r))),
-    }
-
-
-def radial_travel(
-    start_distance: float,
-    starting_velocity: float,
-    input_units: str = "meters",    # distance part of starting_velocity & start_distance
-    input_time: str = "s",          # time part of starting_velocity
-    output_units: str = "meters",
-    output_time: str = "s",
-    planet: str = "earth",
-    *,
-    dt_s: float = 1.0,
-    max_steps: int = 5_000_000,
-    target_distance: Optional[float] = None  # in input_units above surface
-) -> dict:
-    """
-    Single-call wrapper:
-
-    - start_distance: altitude above surface (input_units)
-    - starting_velocity: <input_units>/<input_time>
-    """
-
-    v0_mps = normalized_velocity_conversioin(starting_velocity, input_time, input_units)
-
-    # Optional target altitude (to meters)
-    target_alt_m = None
-    if target_distance is not None:
-        target_alt_m = dconvert(target_distance, input_units, "meters")
-
-    # Integrate in SI
-    sim = simulate_radial_flight(
-        planet=planet,
-        start_altitude=start_distance,
-        start_units=input_units,
-        v0_mps=v0_mps,
-        dt_s=dt_s,
-        max_steps=max_steps,
-        target_altitude_m=target_alt_m
-    )
-
-    if not sim.get("ok", False):
-        return sim
-
-    # Distances for output
-    alt_out  = dconvert(sim["altitude_m"], "meters", output_units)
-    r_out    = dconvert(sim["rFromCenter_m"], "meters", output_units)
-    trav_out = dconvert(sim["traveled_m"], "meters", output_units)
-
-    # Velocity output: (output_units)/(output_time)
-    sec_per_out = seconds_per(output_time)                             # sec / out_timeunit
-    v_units_per_sec_out = dconvert(sim["vEnd_mps"], "meters", output_units)
-    v_out = mul(v_units_per_sec_out, sec_per_out)
-
-    # Escape velocity at end
-    vesc_units_per_sec_out = dconvert(sim["vEsc_end_mps"], "meters", output_units)
-    vesc_end_out = mul(vesc_units_per_sec_out, sec_per_out)
-
-    # Escape velocity at destination (if provided)
-    body = get_body(planet)
-    mu = body["mu"]; R = body["radius"]
-    destination_radius_m = None
-    vesc_dest_out = None
-    if target_alt_m is not None:
-        destination_radius_m = add(R, target_alt_m)
-        vesc_dest_mps = math.sqrt(mul(2.0, div(mu, destination_radius_m)))
-        vesc_dest_units_per_sec = dconvert(vesc_dest_mps, "meters", output_units)
-        vesc_dest_out = mul(vesc_dest_units_per_sec, sec_per_out)
-
-    # Time output in requested unit
-    t_out = div(sim["time_s"], sec_per_out)
-    t_label = output_time if output_time in ("s", "sec", "seconds", "m", "min", "minutes", "h", "hr", "hours") else "s"
-
-    return {
-        "ok": True,
-        "planet": planet,
-        "inputs": {
-            "start_distance": start_distance,
-            "starting_velocity": starting_velocity,
-            "input_units": input_units,
-            "input_time": input_time,
-            "output_units": output_units,
-            "output_time": output_time,
-            "target_distance": target_distance,
-        },
-        "altitude": alt_out,                      # in output_units
-        "radius_from_center": r_out,              # in output_units
-        "distance_traveled": trav_out,            # in output_units
-        "velocity": v_out,                        # in output_units / output_time
-        "velocity_escape_end": vesc_end_out,      # same units/time as velocity
-        "velocity_escape_destination": vesc_dest_out,
-        "destination_radius": (
-            dconvert(destination_radius_m, "meters", output_units) if destination_radius_m is not None else None
-        ),
-        "time": t_out,                            # in output_time units
-        "time_unit": t_label,
-        "g_end_mps2": sim["gAtEnd_mps2"],         # keep SI precise for g
-        "g_ratio_surface": sim["gRatioSurface"],
-        "steps": sim["steps"],
-        "hit_surface": sim["hitSurface"],
-        "hit_target": sim["hitTarget"],
-        "turned_back_below_start": sim["turnedBackBelowStart"],
-    }

abstract_math-0.0.0.24/src/abstract_math/solar_math/src/utils/escape_velocity.py

@@ -1,78 +0,0 @@
-# src/utils/escape_velocity.py
-from ..imports import math, mul, div, add
-from ..constants.planet_constants import get_body
-from ..constants.distance_constants import convert as dconvert
-from ..constants.time_constants import get_time_unit_conversions, normalize_time_unit
-
-def _seconds_per(unit: str) -> float:
-    """
-    Map a time unit (alias-friendly) to seconds per that unit, using your time schema.
-    """
-    return get_time_unit_conversions(normalize_time_unit(unit))["conv"]["seconds"]
-
-def escape_velocity_at(
-    planet: str = "earth",
-    distance: float = 0.0,
-    *,
-    input_units: str = "meters",     # how to interpret `distance`
-    output_units: str = "meters",    # distance unit for the *speed*
-    output_time: str = "s",          # time unit for the *speed*
-    as_radius: bool = False          # False => `distance` is altitude above surface; True => radius from center
-) -> dict:
-    """
-    Compute v_escape at a given location around `planet`.
-
-    Args:
-        planet: body name (must exist in PLANETS)
-        distance: if as_radius=False => altitude above surface; if as_radius=True => radius from center
-        input_units: units of `distance`
-        output_units: distance unit of the returned speed
-        output_time: time unit of the returned speed ('s'|'min'|'h' etc.)
-        as_radius: interpret `distance` as radius-from-center when True
-
-    Returns:
-        {
-          "ok": True,
-          "planet": str,
-          "radius_from_center": <float in output_units>,
-          "v_escape": <float in output_units/output_time>,
-          "v_escape_mps": <float in m/s>,
-          "units": {"distance": output_units, "time": output_time}
-        }
-    """
-    if not (isinstance(distance, (int, float)) and math.isfinite(distance) and distance >= 0):
-        return {"ok": False, "error": "distance must be a non-negative number"}
-
-    body = get_body(planet)
-    mu = body["mu"]          # m^3/s^2
-    R  = body["radius"]      # m
-
-    # Determine radius from center in meters
-    if as_radius:
-        r_m = dconvert(distance, input_units, "meters")
-    else:
-        alt_m = dconvert(distance, input_units, "meters")
-        r_m = add(R, alt_m)
-
-    if r_m <= 0:
-        return {"ok": False, "error": "computed radius is non-positive"}
-
-    # v_esc (m/s)
-    vesc_mps = math.sqrt(mul(2.0, div(mu, r_m)))
-
-    # Convert speed to <output_units>/<output_time>
-    vesc_units_per_sec = dconvert(vesc_mps, "meters", output_units)
-    sec_per = _seconds_per(output_time)          # seconds per 1 output_time
-    vesc_out = mul(vesc_units_per_sec, sec_per)  # <output_units>/<output_time>
-
-    # Also return the radius in output_units for convenience
-    r_out = dconvert(r_m, "meters", output_units)
-
-    return {
-        "ok": True,
-        "planet": planet,
-        "radius_from_center": r_out,
-        "v_escape": vesc_out,
-        "v_escape_mps": vesc_mps,
-        "units": {"distance": output_units, "time": output_time}
-    }