abstract-math 0.0.0.17__py3-none-any.whl → 0.0.0.18__py3-none-any.whl

abstract_math/solar_math/flask_utils.py

@@ -0,0 +1,11 @@
+from abstract_flask import *
+from abstract_utilities import write_to_file
+directory='/home/computron/Documents/pythonTools/modules/abstract_math/src/abstract_math/solar_math'
+output_file='/home/computron/Documents/pythonTools/modules/abstract_math/src/abstract_math/flask_scripts/flask_utils.py'
+output = generate_from_files(
+		directory=directory,
+    		bp_name='math_data_bp',
+    		url_prefix='api'
+	)
+write_to_file(contents=output,file_path=output_file)
+

abstract_math/solar_math/main.py

@@ -0,0 +1,263 @@
+# 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/solar_math/src/__init__.py

@@ -0,0 +1,4 @@
+from .imports import *
+from .constants import *
+from .utils import *
+

abstract_math/solar_math/src/constants/__init__.py

@@ -0,0 +1,19 @@
+# src/constants/__init__.py
+from .distance_constants import (
+    DISTANCE_CONVERSIONS, ALL_DISTANCE_UNITS,
+    normalize_distance_unit, get_distance_unit_conversions,
+    _factor, convert,
+)
+from .time_constants import (
+    TIME_CONVERSIONS, ALL_TIME_UNITS,
+    normalize_time_unit, get_time_unit_conversions,
+    time_factor, convert_time, seconds_per,
+)
+from .planet_constants import (
+    PLANETS, G, g0, MU_MOON,
+    get_planet_vars, planet_radius, planet_diameter,
+    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,
+)

abstract_math/solar_math/src/constants/distance_constants.py

@@ -0,0 +1,45 @@
+#src/constants/distaance_constants.py
+from ..imports import *
+# -------------------------
+# distance Unit schema
+# -------------------------
+MILES = {"strings": ['mi', 'mile', 'miles'],
+         "conv": {"miles": 1.0, "meters": 1609.34, "kilometers": 1.60934, 'feet': 5280.0}}
+METER = {"strings": ['m', 'meter', 'meters'],
+         "conv": {"miles": 0.00621371, "meters": 1.0, "kilometers": 0.001, 'feet': 3.28084}}
+KILOMETER = {"strings": ['km', 'kilo', 'kilometer', 'kilometers'],
+             "conv": {"miles": 0.621371, "meters": 1000.0, "kilometers": 1.0, 'feet': 3280.84}}
+FEET = {"strings": ['ft', 'foot', 'feet', 'foots', 'feets'],
+        "conv": {"miles": 0.000189394, "meters": 0.3048, "kilometers": 0.0003048, 'feet': 1.0}}
+
+DISTANCE_CONVERSIONS: Dict[str, Dict[str, Dict[str, float]]] = {
+    "miles": MILES,
+    "meters": METER,
+    "kilometers": KILOMETER,
+    "feet": FEET
+}
+ALL_DISTANCE_UNITS = ("meters", "kilometers", "miles", "feet")
+# -------------------------
+# Unit helpers
+# -------------------------
+def normalize_distance_unit(unit: str) -> str:
+    u = unit.strip().lower()
+    if u in DISTANCE_CONVERSIONS:
+        return u
+    for key, values in DISTANCE_CONVERSIONS.items():
+        if u in values.get("strings", []):
+            return key
+    # was: CONVERSIONS
+    raise ValueError(f"Unknown unit '{unit}'. Supported: {list(DISTANCE_CONVERSIONS.keys())}")
+
+def get_distance_unit_conversions(unit: str) -> Dict[str, Dict[str, float]]:
+    return DISTANCE_CONVERSIONS[normalize_distance_unit(unit)]
+
+def _factor(unit_from: str, unit_to: str) -> float:
+    """Multiplicative factor s.t. value_in_to = value_in_from * factor."""
+    uf = get_distance_unit_conversions(unit_from)["conv"]["meters"]  # meters per 1 from-unit
+    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:
+    return mul(value, _factor(unit_from, unit_to))

abstract_math/solar_math/src/constants/planet_constants.py

@@ -0,0 +1,156 @@
+# src/constants/planet_constants.py
+from ..imports import *               # <-- add this line
+from .distance_constants import *
+from .time_constants import *
+# -------------------------
+# Physical constants (SI)
+# -------------------------
+G = 6.67430e-11  # m^3 kg^-1 s^-2
+g0 = 9.80665     # m/s^2
+
+try:
+    MU_MOON
+except NameError:
+    MU_MOON = 4.9048695e12  # m^3/s^2
+
+# -------------------------
+# Bodies (your data)
+# -------------------------
+PLANETS = [
+    { "name":'Sun',"m0_deg":0,"mu":1.32712440018e20,"a":0,"e":0,"radiusPx":20,"color":'yellow',"radius":696000000,"escapeVel":61770,"n":0,"peri_lon_deg":0 },
+    { "name":'Mercury',"m0_deg":252.25032350,"mu":2.20320e13,"a":5.7909927e10,"e":0.20563593,"radiusPx":4,"color":'#a6a6a6',"radius":2440000,"escapeVel":4300,"n":1,"peri_lon_deg":77.45779628 },
+    { "name":'Venus',"m0_deg":181.97909950,"mu":3.24859e14,"a":1.0820948e11,"e":0.00677672,"radiusPx":7,"color":'#e0c16b',"radius":6052000,"escapeVel":10400,"n":2,"peri_lon_deg":131.60246718 },
+    { "name":'Earth',"m0_deg":100.46457166,"mu":3.98600e14,"a":1.49598261e11,"e":0.01671123,"radiusPx":8,"color":'#4e6ef2',"radius":6371000,"escapeVel":11200,"n":3,"peri_lon_deg":102.93768193 },
+    { "name":'Mars',"m0_deg":-4.55343205,"mu":4.28284e13,"a":2.2793664e11,"e":0.09339410,"radiusPx":6,"color":'#c1440e',"radius":3390000,"escapeVel":5030,"n":4,"peri_lon_deg":-23.94362959 },
+    { "name":'Jupiter',"m0_deg":34.39644051,"mu":1.26687e17,"a":7.7841200e11,"e":0.04838624,"radiusPx":14,"color":'#d2a679',"radius":71492000,"escapeVel":59500,"n":5,"peri_lon_deg":14.72847983 },
+    { "name":'Saturn',"m0_deg":49.95424423,"mu":3.79312e16,"a":1.4267254e12,"e":0.05386179,"radiusPx":12,"color":'#e3c168',"radius":60268000,"escapeVel":35500,"n":6,"peri_lon_deg":92.59887831 },
+    { "name":'Uranus',"m0_deg":313.23810451,"mu":5.79394e15,"a":2.8706582e12,"e":0.04725744,"radiusPx":10,"color":'#7fbde8',"radius":25559000,"escapeVel":21300,"n":7,"peri_lon_deg":170.95427630 },
+    { "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}
+]
+
+# -------------------------
+# Body enrichment + lookup
+# -------------------------
+def _enrich_body(b: Dict[str, Any]) -> Dict[str, Any]:
+    """Add derived diameter, mass, surface g."""
+    mu = b["mu"]
+    r  = b["radius"]
+    if "diameter" not in b or not b["diameter"]:
+        b["diameter"] = mul(2.0, r)
+    b["mass"] = div(mu, G)
+    surf_g = div(mu, mul(r, r))
+    b["surface_g"] = surf_g
+    b["surface_g_g0"] = div(surf_g, g0)
+    return b
+
+_NAME_ALIASES = {"sol": "sun", "terra": "earth", "luna": "moon"}
+def _normalize_name(name: str) -> str:
+    n = name.strip().lower()
+    return _NAME_ALIASES.get(n, n)
+
+_BODY_BY_NAME: Dict[str, Dict[str, Any]] = {}
+for entry in PLANETS:
+    _BODY_BY_NAME[entry["name"].lower()] = _enrich_body(dict(entry))
+
+# -------------------------
+# Public API
+# -------------------------
+def get_planet_vars(name: str, units: str = "meters") -> Dict[str, Any]:
+    """
+    Return body properties with radius/diameter in `units`.
+    Mass in kg; mu in m^3/s^2; surface_g in m/s^2.
+    """
+    key = _normalize_name(name)
+    body = _BODY_BY_NAME.get(key)
+    if body is None:
+        raise KeyError(f"Unknown body '{name}'. Available: {sorted(_BODY_BY_NAME.keys())}")
+
+    units_norm = normalize_distance_unit(units)
+    r_m = body["radius"]
+    d_m = body["diameter"]
+    
+    out = dict(body)
+    out["radius"] = convert(r_m, "meters", units_norm)
+    out["diameter"] = convert(d_m, "meters", units_norm)
+    out["radius_units"] = units_norm
+    out["diameter_units"] = units_norm
+    return out
+
+def planet_radius(name: str = "earth", units: str = "meters") -> float:
+    return get_planet_vars(name, units)["radius"]
+
+def planet_diameter(name: str = "earth", units: str = "meters") -> float:
+    return get_planet_vars(name, units)["diameter"]
+
+def full_planet_surface_area(name: str = "earth", units: str = 'meters') -> float:
+    r = planet_radius(name,units)
+    return mul(4 * pi(), exp(r, 2))
+
+def planet_volume(name: str = "earth", units: str = 'meters') -> float:
+    r = planet_radius(name,units)
+    return mul((4.0/3.0) * pi(), exp(r, 3))
+
+def planet_circumference(name: str = "earth", units: str = 'meters') -> float:
+    r = planet_radius(name,units)
+    return mul(2 * pi(), r)
+
+def planet_mass(name: str = "earth") -> float:
+    return get_planet_vars(name)["mass"]
+
+def planet_surface_g(name: str = "earth", as_g0: bool = False) -> float:
+    v = get_planet_vars(name)["surface_g"]
+    return div(v, g0) if as_g0 else v
+
+def escape_velocity(name: str = "earth", altitude: float = 0.0, units: str = "meters") -> float:
+    """
+    Escape velocity (m/s) from altitude above surface.
+    """
+    mu = _BODY_BY_NAME[_normalize_name(name)]["mu"]
+    r  = _BODY_BY_NAME[_normalize_name(name)]["radius"]  # meters
+    h_m = convert(altitude, units, "meters")
+    R = add(r, h_m)
+    return math.sqrt(mul(2.0, div(mu, R)))
+
+# -------------------------
+# Earth-centric geometry utils (unit-consistent)
+# -------------------------
+def pi() -> float:
+    return math.pi
+
+def earth_radius(units: str = 'meters') -> float:
+    return planet_radius('earth', units)
+
+def earth_diameter(units: str = 'meters') -> float:
+    return planet_diameter('earth', units)
+
+def full_earth_surface_area(units: str = 'meters') -> float:
+    r = earth_radius(units)
+    return mul(4 * pi(), exp(r, 2))
+
+def earth_volume(units: str = 'meters') -> float:
+    r = earth_radius(units)
+    return mul((4.0/3.0) * pi(), exp(r, 3))
+
+def earth_circumference(units: str = 'meters') -> float:
+    r = earth_radius(units)
+    return mul(2 * pi(), r)
+
+# =========================
+# Radial toy + single-call wrapper
+# =========================
+def distance_per_sec_to_mps(v_per_sec: float, units: str) -> float:
+    """Convert a speed given in `units`/s into m/s using your convert()."""
+    # v [units/s] * (meters per 1 units) => [m/s]
+    return mul(v_per_sec, get_distance_unit_conversions(_normalize_unit(units))["conv"]["meters"])
+
+
+def get_body(planet: str) -> Dict[str, Any]:
+    key = _normalize_name(planet)
+    body = _BODY_BY_NAME.get(key)
+    if not body:
+        raise KeyError(f"Unknown body '{planet}'. Available: {sorted(_BODY_BY_NAME.keys())}")
+    return body
+
+def g_at_radius(mu: float, r_m: float) -> float:
+    return div(mu, mul(r_m, r_m))

abstract_math/solar_math/src/constants/time_constants.py

@@ -0,0 +1,56 @@
+#src/constants/time_constants.py
+# --- Time unit schema (seconds-per-unit) ---
+second = 1.0
+minute = 60.0 * second
+hour   = 60.0 * minute
+day    = 24.0 * hour
+
+SECONDS = {"strings": ['s', 'sec', 'secs', 'second', 'seconds'],
+           "conv": {"seconds": 1.0}}
+MINUTES = {"strings": ['min', 'mins', 'minute', 'minutes'],
+           "conv": {"seconds": minute}}
+HOURS   = {"strings": ['h', 'hr', 'hrs', 'hour', 'hours'],
+           "conv": {"seconds": hour}}
+DAYS    = {"strings": ['d', 'day', 'days'],
+           "conv": {"seconds": day}}
+
+TIME_CONVERSIONS = {
+    "seconds": SECONDS,
+    "minutes": MINUTES,
+    "hours":   HOURS,
+    "days":    DAYS,
+}
+ALL_TIME_UNITS = ("seconds", "minutes", "hours", "days")
+
+def normalize_time_unit(unit: str) -> str:
+    u = unit.strip().lower()
+    if u in TIME_CONVERSIONS:
+        return u
+    for key, values in TIME_CONVERSIONS.items():
+        if u in values.get("strings", []):
+            return key
+    raise ValueError(f"Unknown time unit '{unit}'. Supported: {list(TIME_CONVERSIONS.keys())}")
+
+def get_time_unit_conversions(unit: str) -> dict:
+    return TIME_CONVERSIONS[normalize_time_unit(unit)]
+
+def time_factor(unit_from: str, unit_to: str) -> float:
+    """
+    multiplicative factor s.t.
+      value_in_to = value_in_from * _time_factor(unit_from, unit_to)
+
+    seconds per 1 unit_from  /  seconds per 1 unit_to
+    """
+    sf = get_time_unit_conversions(unit_from)["conv"]["seconds"]  # sec / unit_from
+    st = get_time_unit_conversions(unit_to)["conv"]["seconds"]    # sec / unit_to
+    return sf / st
+
+def convert_time(value: float, unit_from: str, unit_to: str) -> float:
+    return value * time_factor(unit_from, unit_to)
+
+def seconds_per(unit: str) -> float:
+    """Return seconds in one <unit> (unit aliases supported)."""
+    return get_time_unit_conversions(normalize_time_unit(unit))["conv"]["seconds"]
+
+
+

abstract_math/solar_math/src/imports.py

@@ -0,0 +1,5 @@
+import math
+from typing import Dict, Callable, Optional, Any
+from abstract_math import (
+    multiply_it as mul, divide_it as div, add_it as add, subtract_it as sub, exp_it as exp
+)

abstract_math/solar_math/src/utils/__init__.py

@@ -0,0 +1,3 @@
+from .geometry_utils import *
+from .velocity_utils import *
+from .escape_velocity import *

abstract_math/solar_math/src/utils/escape_velocity.py

@@ -0,0 +1,79 @@
+# 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}
+    }