abstract-math 0.0.0.24__py3-none-any.whl → 0.0.0.26__py3-none-any.whl

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/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/solar_math/main.py

@@ -1,25 +1,52 @@
 # 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.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
-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
+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 = 'meters',      # how to interpret altitude numbers
-    display_units: str = 'meters',    # how to print areas/radii
-    planet: str = 'earth',
+    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
 ):
     """
@@ -27,9 +54,9 @@ def analyze_visible_surface(
     Results are printed in `display_units`.
     """
     # Planet radius and full area (compute in meters, convert for display)
-    r_m = planet_radius(planet, 'meters')
+    r_m = planet_radius(planet, DEFAULT_UNITS)
     full_area_m2 = 4.0 * math.pi * (r_m ** 2)
-    k_disp = dfactor('meters', display_units)      # linear meter->display factor
+    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,
@@ -38,7 +65,7 @@ def analyze_visible_surface(
     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')
+        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
@@ -51,9 +78,9 @@ def analyze_visible_surface(
 
         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_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, 'meters', display_units)
+            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)
@@ -81,161 +108,146 @@ def analyze_visible_surface(
     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,
+    }
 
 
-def simulate_radial_flight(
-    planet: str,
-    start_altitude: float,
-    start_units: str,
+# --- 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_altitude_m: Optional[float] = None
+    target_alt_m: 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"))
+    """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   # outward positive, m/s
+    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
 
-    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
-
+    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 has_target and r >= r_target:
+        if target_alt_m 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
+        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
 
-        if (not has_target) and (v < 0) and (r < r0):
-            turned_back_below_start = True
+        # 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)
-    traveled_m = max(0.0, altitude_m - (r0 - R))
 
     return {
         "ok": True,
         "planet": planet,
-        "rFromCenter_m": r,
+        "r_m": r,
         "altitude_m": altitude_m,
         "vEnd_mps": v,
         "time_s": t,
-        "gAtEnd_mps2": g_end,
-        "gRatioSurface": div(g_end, g_surface),
+        "g_end_mps2": g_end,
+        "g_ratio_surface": div(g_end, g_surface),
         "steps": steps,
-        "hitSurface": hit_surface,
-        "hitTarget": hit_target,
-        "turnedBackBelowStart": turned_back_below_start,
+        "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))),
+        "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(
-    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",
+    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: Optional[float] = None  # in input_units above surface
+    target_distance: float = None
 ) -> 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")
+    """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
+    )
 
-    # Integrate in SI
-    sim = simulate_radial_flight(
+    sim = simulate_radial_flight_si(
+        v0_mps=norm["v0_mps"],
+        start_alt_m=norm["start_alt_m"],
         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
+        target_alt_m=norm["target_alt_m"],
     )
-
-    if not sim.get("ok", False):
+    if not sim.get("ok"):
         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"
+    # 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_distance": start_distance,
+            "start_altitude": start_altitude,
             "starting_velocity": starting_velocity,
             "input_units": input_units,
             "input_time": input_time,
@@ -243,21 +255,25 @@ def radial_travel(
             "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"],
+        # 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["hitSurface"],
-        "hit_target": sim["hitTarget"],
-        "turned_back_below_start": sim["turnedBackBelowStart"],
+        "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/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/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/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]] = {}
@@ -71,8 +72,8 @@ def get_planet_vars(name: str, units: str = "meters") -> Dict[str, Any]:
     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"] = dconvert(r_m, "meters", units_norm)
+    out["diameter"] = dconvert(d_m, "meters", units_norm)
     out["radius_units"] = units_norm
     out["diameter_units"] = units_norm
     return out
@@ -108,7 +109,7 @@ def escape_velocity(name: str = "earth", altitude: float = 0.0, units: str = "me
     """
     mu = _BODY_BY_NAME[_normalize_name(name)]["mu"]
     r  = _BODY_BY_NAME[_normalize_name(name)]["radius"]  # meters
-    h_m = convert(altitude, units, "meters")
+    h_m = dconvert(altitude, units, "meters")
     R = add(r, h_m)
     return math.sqrt(mul(2.0, div(mu, R)))
 
@@ -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/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/solar_math/src/utils/escape_velocity.py

@@ -1,30 +1,78 @@
 # 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
+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 _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 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 = "earth",
-    distance: float = 0.0,
+    planet: str = DEFAULT_PLANET,
+    start_altitude: float = DEFAULT_START_ALTITUDE,
     *,
-    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
+    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)
-        distance: if as_radius=False => altitude above surface; if as_radius=True => radius from center
+        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.)
@@ -40,33 +88,18 @@ def escape_velocity_at(
           "units": {"distance": output_units, "time": output_time}
         }
     """
-    if not (isinstance(distance, (int, float)) and math.isfinite(distance) and distance >= 0):
+    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"}
-
-    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"}
-
+    R,mu = get_R_mu(planet=planet)
     # v_esc (m/s)
-    vesc_mps = math.sqrt(mul(2.0, div(mu, r_m)))
-
+    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_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>
-
+    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, "meters", output_units)
+    r_out = dconvert(r_m, DEFAULT_UNITS, output_units)
 
     return {
         "ok": True,

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.dist-info → abstract_math-0.0.0.26.dist-info}/METADATA

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

{abstract_math-0.0.0.24.dist-info → abstract_math-0.0.0.26.dist-info}/RECORD

@@ -1,22 +1,23 @@
 abstract_math/__init__.py,sha256=wr-kwaB8micSsR1nCHuDXRlsL59DWlqZQFN7M_rfZys,80
+abstract_math/createflask.py,sha256=M66B9Da9m2aQmZRaEtKf9sH3UH1ARd6_OdJPzw17sNM,214
 abstract_math/derive_tokens.py,sha256=mVzwkLv1Jo76R-SGR0hZbO5MPOr7vZpDC44eyxUvfzU,4585
 abstract_math/safe_math.py,sha256=9T1-n6dcMYzJtem8xEIGEKOLR5X4DOIj_h9aotvyzdE,7347
 abstract_math/flask_scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-abstract_math/flask_scripts/flask_utils.py,sha256=boJqK3XfflETwe8TKFBtPJ6vHNKGkC8JAsXI0Q04e7E,28510
+abstract_math/flask_scripts/flask_utils.py,sha256=bXF4PS1qJ1SDA2w6ecNHK1A3FmN4P-F2U6l6wPwhZgE,28511
 abstract_math/solar_math/__init__.py,sha256=FfPkmWi3cQ3BLvUUUf6k22rGBE8scDL1EoM5l24biVo,39
 abstract_math/solar_math/flask_utils.py,sha256=c82LrZ0dKC3Y8LxqOs1zDR6gRy8oXSx9balBD18gNB0,459
-abstract_math/solar_math/main.py,sha256=EtcUmUWj27c7mcnm-hlfeCeYFuPytPevXx5vClVu6Q8,10000
+abstract_math/solar_math/main.py,sha256=Dbwt0MKO8o5SwnkT9ejdIjf7e7PpzXTH7H9PrWAz3L0,9610
 abstract_math/solar_math/src/__init__.py,sha256=qeal73F-NLu6sO_YSmD_komVpe17f0OFy2IfBR2QU_s,70
 abstract_math/solar_math/src/imports.py,sha256=UZp2SkF8INamFVwLOIca6w9K-YKXsqhiqcf6bkWuLVo,181
-abstract_math/solar_math/src/constants/__init__.py,sha256=HpRa4MWkJZu3Wcx6KchB8__RL4FfkVqRw78TAnjRRwo,691
-abstract_math/solar_math/src/constants/distance_constants.py,sha256=stM3nWxpANQEtoxFcbxpO0ly_UM4JJ2aH0VK42fHw6s,1985
-abstract_math/solar_math/src/constants/planet_constants.py,sha256=tt2nbFtRtYhUU9D918WK91D-S5Cv0HEJ-1j7f9Yb50w,6602
-abstract_math/solar_math/src/constants/time_constants.py,sha256=uVDMldwjJqKwXzHcAb-Z8QM20JrxSwLXlogjD_SXwRo,1874
+abstract_math/solar_math/src/constants/__init__.py,sha256=OmUwgtbnjcFC2NBLTIypQ6v-DwdOEmSu1u4h-WgifAQ,772
+abstract_math/solar_math/src/constants/distance_constants.py,sha256=1TM_dzo0semwZkk5kveRljzPYN0ry5yNCmwORks4yUs,2793
+abstract_math/solar_math/src/constants/planet_constants.py,sha256=oN7JPrDGoz-ZDK1ukNSnvWuq3a179gskfdXBLYz3xo0,6812
+abstract_math/solar_math/src/constants/time_constants.py,sha256=i1gMbymsAkF23YwF4KGwEPpNuwNp1n5MCb4ALHdjxnU,1890
 abstract_math/solar_math/src/utils/__init__.py,sha256=Vb2bfx1p9YSmhnbqXBjGVPt1OQZ9I7PG_fMQdFqj-3k,91
-abstract_math/solar_math/src/utils/escape_velocity.py,sha256=9oixNxWyY4pxa7e1INwbreD8GJEw2BZIgV_IqXiDd9Y,2971
+abstract_math/solar_math/src/utils/escape_velocity.py,sha256=nngwySzxqB7JOV1RLRHKj6O3v4O45yOIkV3lVchPdGg,4926
 abstract_math/solar_math/src/utils/geometry_utils.py,sha256=Ij4mASNFp2-CWy425fxMTEuMPuAZHs-E0qvi3BjaNkk,4169
-abstract_math/solar_math/src/utils/velocity_utils.py,sha256=_SyOscVvYsvbm1T1Rh4uqegXdf61mHll5s3UfQcdUnU,1162
-abstract_math-0.0.0.24.dist-info/METADATA,sha256=yDZwdi8whLWg21FqDF3ib1DkNc6wUOK51rJBVEvI12g,3081
-abstract_math-0.0.0.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-abstract_math-0.0.0.24.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
-abstract_math-0.0.0.24.dist-info/RECORD,,
+abstract_math/solar_math/src/utils/velocity_utils.py,sha256=eiXstQ3PF0KAUamSFOHFIL1chyWweygdTyvBjQB_DXo,1888
+abstract_math-0.0.0.26.dist-info/METADATA,sha256=caQ-fCouVO-mjF4SWzBRrZj13NHMyMJ4jsp2BXbTfEk,3081
+abstract_math-0.0.0.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_math-0.0.0.26.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
+abstract_math-0.0.0.26.dist-info/RECORD,,