abstract-math 0.0.0.30__py3-none-any.whl → 0.0.0.32__py3-none-any.whl

abstract_math/solar_math/main.py

@@ -7,8 +7,8 @@ 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, exp  # your abstract_math ops
 from .src.constants import (
-    DEFAULT_UNITS,
-    DEFAULT_TIME,
+    DEFAULT_DIST_UNIT,
+    DEFAULT_TIME_UNIT,
     DEFAULT_PLANET,
     DEFAULT_START_ALTITUDE,
     DEFAULT_AS_RADIUS
@@ -18,19 +18,19 @@ def normalize_inputs(
     planet: str,
     start_altitude: float,
     starting_velocity: float,
-    input_units: str,
-    input_time: str,
+    input_dist_unit: str,
+    input_time_unit: 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)
+    start_alt_m = get_normalized_distance(start_altitude, input_dist_unit)
+    target_alt_m = get_normalized_distance(target_distance, input_dist_unit)
 
     v0_mps = get_normalized_starting_velocity(
         start_altitude=start_alt_m,
         starting_velocity=starting_velocity,
-        input_units=input_units,
-        input_time=input_time,
+        input_dist_unit=input_dist_unit,
+        input_time_unit=input_time_unit,
         planet=planet,
     )
 
@@ -45,43 +45,43 @@ def analyze_visible_surface(
     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
+    input_dist_unit: str = DEFAULT_DIST_UNIT,      # how to interpret altitude numbers
+    display_units: str = DEFAULT_DIST_UNIT,    # how to print areas/radii
     planet: str = DEFAULT_PLANET,
     printit: bool = False
 ):
     """
-    Scan altitudes/FOVs. Altitudes are interpreted in `input_units`.
+    Scan altitudes/FOVs. Altitudes are interpreted in `input_dist_unit`.
     Results are printed in `display_units`.
     """
     # Planet radius and full area (compute in meters, convert for display)
-    r_m = planet_radius(planet, DEFAULT_UNITS)
+    r_m = planet_radius(planet, DEFAULT_DIST_UNIT)
     full_area_m2 = 4.0 * math.pi * (r_m ** 2)
-    k_disp = dfactor(DEFAULT_UNITS, display_units)      # linear meter->display factor
+    k_disp = dfactor(DEFAULT_DIST_UNIT, 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,
+    all_stats = {"output": "", "input_dist_unit": input_dist_unit,
                  "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)
+        altitude_in = altitude_step * i                       # input_dist_unit
+        altitude_m  = dconvert(altitude_in, input_dist_unit, DEFAULT_DIST_UNIT)
 
         all_stats["vars"][-1]['altitude_input'] = altitude_in
-        all_stats["vars"][-1]['input_units']    = input_units
+        all_stats["vars"][-1]['input_dist_unit']    = input_dist_unit
         all_stats["vars"][-1]['fov']            = []
 
-        alt_pretty = dconvert(altitude_in, input_units, display_units)
+        alt_pretty = dconvert(altitude_in, input_dist_unit, display_units)
         all_stats["output"] += (
-            f"\n=== Altitude: {altitude_in} {input_units} (≈ {alt_pretty:.3f} {display_units}) ===\n"
+            f"\n=== Altitude: {altitude_in} {input_dist_unit} (≈ {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_m2, vis_radius_m = visible_area_flat(fov, altitude_m, DEFAULT_DIST_UNIT)
             area_disp = area_m2 * (k_disp ** 2)
-            vis_radius_disp = dconvert(vis_radius_m, DEFAULT_UNITS, display_units)
+            vis_radius_disp = dconvert(vis_radius_m, DEFAULT_DIST_UNIT, display_units)
 
             # Span uses geometry only; r_m is in meters
             _, angle_deg = visible_surface_angle(vis_radius_m, r_m)
@@ -213,10 +213,10 @@ def simulate_radial_flight_si(
 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,
+    input_dist_unit: str = DEFAULT_DIST_UNIT,
+    input_time_unit: str = DEFAULT_TIME_UNIT,
+    output_dist_unit: str = DEFAULT_DIST_UNIT,
+    output_time_unit: str = DEFAULT_TIME_UNIT,
     *,
     planet: str = DEFAULT_PLANET,
     dt_s: float = 1.0,
@@ -226,7 +226,7 @@ def radial_travel(
     """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
+        input_dist_unit=input_dist_unit, input_time_unit=input_time_unit, target_distance=target_distance
     )
 
     sim = simulate_radial_flight_si(
@@ -241,8 +241,8 @@ def radial_travel(
         return sim
 
     # Output conversions
-    sec_per_out = seconds_per(output_time)
-    conv = lambda m: dconvert(m, DEFAULT_UNITS, output_units)
+    sec_per_out = seconds_per(output_time_unit)
+    conv = lambda m: dconvert(m, DEFAULT_DIST_UNIT, output_dist_unit)
 
     return {
         "ok": True,
@@ -250,20 +250,20 @@ def radial_travel(
         "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,
+            "input_dist_unit": input_dist_unit,
+            "input_time_unit": input_time_unit,
+            "output_dist_unit": output_dist_unit,
+            "output_time_unit": output_time_unit,
             "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),
+        "velocity": mul(dconvert(sim["vEnd_mps"], DEFAULT_DIST_UNIT, output_dist_unit), sec_per_out),
+        "velocity_escape_end": mul(dconvert(sim["vesc_end_mps"], DEFAULT_DIST_UNIT, output_dist_unit), sec_per_out),
         "time": div(sim["time_s"], sec_per_out),
-        "time_unit": output_time,
+        "time_unit": output_time_unit,
         "g_end_mps2": sim["g_end_mps2"],
         "g_ratio_surface": sim["g_ratio_surface"],
         "steps": sim["steps"],

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, dconvert,DEFAULT_UNITS,DEFAULT_START_ALTITUDE
+    _factor, dconvert,DEFAULT_DIST_UNIT,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,DEFAULT_TIME
+    time_factor, convert_time, seconds_per,DEFAULT_TIME_UNIT
 )
 from .planet_constants import (
     PLANETS, G, g0, MU_MOON,

abstract_math/solar_math/src/constants/distance_constants.py

@@ -19,7 +19,7 @@ DISTANCE_CONVERSIONS: Dict[str, Dict[str, Dict[str, float]]] = {
     "feet": FEET
 }
 ALL_DISTANCE_UNITS = ("meters", "kilometers", "miles", "feet")
-DEFAULT_UNITS="meters"
+DEFAULT_DIST_UNIT="meters"
 DEFAULT_START_ALTITUDE=0.0
 # -------------------------
 # Unit helpers
@@ -34,36 +34,36 @@ def normalize_distance_unit(unit: str) -> str:
     # 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 get_distance_unit_conversions(dist_unit: str) -> Dict[str, Dict[str, float]]:
+    return DISTANCE_CONVERSIONS[normalize_distance_unit(dist_unit)]
 
-def _factor(unit_from: str, unit_to: str) -> float:
+def _factor(dist_unit_from: str, dist_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
+    uf = get_distance_unit_conversions(dist_unit_from)["conv"]["meters"]  # meters per 1 from-unit
+    ut = get_distance_unit_conversions(dist_unit_to)["conv"]["meters"]    # meters per 1 to-unit
     return div(uf, ut)
 
-def dconvert(value: float, unit_from: str, unit_to: str) -> float:
-    return mul(value, _factor(unit_from, unit_to))
+def dconvert(value: float, dist_unit_from: str, dist_unit_to: str) -> float:
+    return mul(value, _factor(dist_unit_from, dist_unit_to))
 def get_normalized_distance(
     distance: Optional[float] = None,
-    input_units: str = DEFAULT_UNITS
+    input_dist_units: str = DEFAULT_DIST_UNIT
     ):
     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
+                unit_from=input_dist_units,
+                unit_to=DEFAULT_DIST_UNIT
                 )
     return target_alt_m
 def get_target_distance(
     distance: Optional[float] = None,
-    input_units: str = DEFAULT_UNITS,
-    output_units: str = DEFAULT_UNITS,
+    input_dist_units: str = DEFAULT_DIST_UNIT,
+    output_dist_units: str = DEFAULT_DIST_UNIT,
     ):
     distance = target_distance = distance or 0
     if distance is not None:
         target_distance = dconvert(value=distance,
-                              unit_from=input_units,
-                              unit_to=output_units)
+                              unit_from=input_dist_units,
+                              unit_to=output_dist_units)
     return target_distance

abstract_math/solar_math/src/constants/planet_constants.py

@@ -57,7 +57,7 @@ for entry in PLANETS:
 # -------------------------
 # Public API
 # -------------------------
-def get_planet_vars(name: str, units: str = "meters") -> Dict[str, Any]:
+def get_planet_vars(name: str, dist_unit: 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.
@@ -67,49 +67,49 @@ def get_planet_vars(name: str, units: str = "meters") -> Dict[str, Any]:
     if body is None:
         raise KeyError(f"Unknown body '{name}'. Available: {sorted(_BODY_BY_NAME.keys())}")
 
-    units_norm = normalize_distance_unit(units)
+    dist_unit_norm = normalize_distance_unit(units)
     r_m = body["radius"]
     d_m = body["diameter"]
     
     out = dict(body)
-    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
+    out["radius"] = dconvert(r_m, "meters", dist_unit_norm)
+    out["diameter"] = dconvert(d_m, "meters", dist_unit_norm)
+    out["radius_unit"] = dist_unit_norm
+    out["diameter_unit"] = dist_unit_norm
     return out
 
-def planet_radius(name: str = "earth", units: str = "meters") -> float:
-    return get_planet_vars(name, units)["radius"]
+def planet_radius(name: str = "earth", dist_unit: str = "meters") -> float:
+    return get_planet_vars(name, dist_unit)["radius"]
 
-def planet_diameter(name: str = "earth", units: str = "meters") -> float:
-    return get_planet_vars(name, units)["diameter"]
+def planet_diameter(name: str = "earth", dist_unit: str = "meters") -> float:
+    return get_planet_vars(name, dist_unit)["diameter"]
 
-def full_planet_surface_area(name: str = "earth", units: str = 'meters') -> float:
-    r = planet_radius(name,units)
+def full_planet_surface_area(name: str = "earth", dist_unit: str = 'meters') -> float:
+    r = planet_radius(name,dist_unit)
     return mul(4 * pi(), exp(r, 2))
 
-def planet_volume(name: str = "earth", units: str = 'meters') -> float:
-    r = planet_radius(name,units)
+def planet_volume(name: str = "earth", dist_unit: str = 'meters') -> float:
+    r = planet_radius(name,dist_unit)
     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)
+def planet_circumference(name: str = "earth", dist_unit: str = 'meters') -> float:
+    r = planet_radius(name,dist_unit)
     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, units: str = "meters") -> float:
-    v = get_planet_vars(name, units)["surface_g"]
+def planet_surface_g(name: str = "earth", as_g0: bool = False, dist_unit: str = "meters") -> float:
+    v = get_planet_vars(name, dist_unit)["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:
+def escape_velocity(name: str = "earth", altitude: float = 0.0, dist_unit: 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 = dconvert(altitude, units, "meters")
+    h_m = dconvert(altitude, dist_unit, "meters")
     R = add(r, h_m)
     return math.sqrt(mul(2.0, div(mu, R)))
 
@@ -119,31 +119,31 @@ def escape_velocity(name: str = "earth", altitude: float = 0.0, units: str = "me
 def pi() -> float:
     return math.pi
 
-def earth_radius(units: str = 'meters') -> float:
+def earth_radius(dist_unit: str = 'meters') -> float:
     return planet_radius('earth', units)
 
-def earth_diameter(units: str = 'meters') -> float:
-    return planet_diameter('earth', units)
+def earth_diameter(dist_unit: str = 'meters') -> float:
+    return planet_diameter('earth', dist_unit)
 
-def full_earth_surface_area(units: str = 'meters') -> float:
-    r = earth_radius(units)
+def full_earth_surface_area(dist_unit: str = 'meters') -> float:
+    r = earth_radius(dist_unit)
     return mul(4 * pi(), exp(r, 2))
 
-def earth_volume(units: str = 'meters') -> float:
-    r = earth_radius(units)
+def earth_volume(dist_unit: str = 'meters') -> float:
+    r = earth_radius(dist_unit)
     return mul((4.0/3.0) * pi(), exp(r, 3))
 
-def earth_circumference(units: str = 'meters') -> float:
-    r = earth_radius(units)
+def earth_circumference(dist_unit: str = 'meters') -> float:
+    r = earth_radius(dist_unit)
     return mul(2 * pi(), r)
 
 # =========================
 # Radial toy + single-call wrapper
 # =========================
-def distance_per_sec_to_mps(v_per_sec: float, units: str) -> float:
+def distance_per_sec_to_mps(v_per_sec: float, dist_unit: 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"])
+    return mul(v_per_sec, get_distance_unit_conversions(_normalize_unit(dist_unit))["conv"]["meters"])
 
 
 def get_body(planet: str) -> Dict[str, Any]:

abstract_math/solar_math/src/constants/time_constants.py

@@ -21,32 +21,32 @@ 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()
+DEFAULT_TIME_UNIT="s"
+def normalize_time_unit(time_unit: str) -> str:
+    u = time_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())}")
+    raise ValueError(f"Unknown time unit '{time_unit}'. Supported: {list(TIME_CONVERSIONS.keys())}")
 
-def get_time_unit_conversions(unit: str) -> dict:
-    return TIME_CONVERSIONS[normalize_time_unit(unit)]
+def get_time_unit_conversions(time_unit: str) -> dict:
+    return TIME_CONVERSIONS[normalize_time_unit(time_unit)]
 
-def time_factor(unit_from: str, unit_to: str) -> float:
+def time_factor(time_unit_from: str, time_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
+    sf = get_time_unit_conversions(time_unit_from)["conv"]["seconds"]  # sec / unit_from
+    st = get_time_unit_conversions(time_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 convert_time(value: float, time_unit_from: str, time_unit_to: str) -> float:
+    return value * time_factor(time_unit_from, time_unit_to)
 
 def seconds_per(unit: str) -> float:
     """Return seconds in one <unit> (unit aliases supported)."""

abstract_math/solar_math/src/utils/escape_velocity.py

@@ -1,8 +1,8 @@
 # src/utils/escape_velocity.py
 from ..imports import math, mul, div, add
 from ..constants import (
-    DEFAULT_UNITS,
-    DEFAULT_TIME,
+    DEFAULT_DIST_UNIT,
+    DEFAULT_TIME_UNIT,
     DEFAULT_PLANET,
     DEFAULT_START_ALTITUDE,
     DEFAULT_AS_RADIUS
@@ -11,9 +11,9 @@ 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):
+def get_r_m(planet: str = DEFAULT_PLANET,start_altitude: float = DEFAULT_START_ALTITUDE,input_units: str = DEFAULT_DIST_UNIT,as_radius:bool = DEFAULT_AS_RADIUS):
     R,mu = get_R_mu(planet=planet)
-    r_m = dconvert(start_altitude, input_units, DEFAULT_UNITS)
+    r_m = dconvert(start_altitude, input_units, DEFAULT_DIST_UNIT)
     # Determine radius from center in meters
     if not as_radius:
         r_m = add(R, r_m)
@@ -23,7 +23,7 @@ def get_r_m(planet: str = DEFAULT_PLANET,start_altitude: float = DEFAULT_START_A
 def get_vesc_mps(
     planet: str = DEFAULT_PLANET,
     start_altitude: float = DEFAULT_START_ALTITUDE,
-    input_units: str = DEFAULT_UNITS,
+    input_dist_unit: str = DEFAULT_DIST_UNIT,
     as_radius:bool = DEFAULT_AS_RADIUS
     ):
     R,mu = get_R_mu(planet=planet)
@@ -36,35 +36,35 @@ def get_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,
+    input_dist_unit: str = DEFAULT_DIST_UNIT,    # distance part of starting_velocity & start_distance
+    input_time_unit: str = DEFAULT_TIME_UNIT,         # time part of starting_velocity
+    output_dist_unit: str = DEFAULT_DIST_UNIT,
+    output_time_unit: str = DEFAULT_TIME_UNIT,
     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
+                                               input_time_unit=input_time_unit,
+                                               input_dist_unit=input_dist_unit,
+                                               output_time_unit=output_time_unit,
+                                               output_dist_unit=output_dist_unit
                                                )
     return normalized_velocity_conversioin(
         velocity=starting_velocity,
-        input_time=input_time,
-        input_units=input_units
+        input_time_unit=input_time_unit,
+        input_dist_unit=input_dist_unit
         )
 
 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*
+    input_time_unit: str = DEFAULT_TIME_UNIT,     # how to interpret `distance`
+    input_dist_unit: str = DEFAULT_DIST_UNIT,     # how to interpret `distance`
+    output_dist_unit: str = DEFAULT_DIST_UNIT,    # distance unit for the *speed*
+    output_time_unit: str = DEFAULT_TIME_UNIT,          # time unit for the *speed*
     as_radius: bool = DEFAULT_AS_RADIUS          # False => `distance` is altitude above surface; True => radius from center
 ) -> dict:
     """
@@ -92,14 +92,23 @@ def escape_velocity_at(
         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)
+    r_m = get_r_m(planet=planet,
+                  start_altitude=start_altitude,
+                  input_dist_unit=input_dist_unit,
+                  as_radius=as_radius
+                  )
+    vesc_mps = get_vesc_mps(
+        planet=planet,
+        start_altitude=start_altitude,
+        input_dist_unit=input_dist_unit,
+        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_units_per_time = dconvert(vesc_mps, DEFAULT_DIST_UNIT, output_dist_unit)
+    time_per = seconds_per(output_time_unit)         # 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)
+    r_out = dconvert(r_m, DEFAULT_DIST_UNIT, output_dist_unit)
 
     return {
         "ok": True,
@@ -107,5 +116,5 @@ def escape_velocity_at(
         "radius_from_center": r_out,
         "v_escape": vesc_out,
         "v_escape_mps": vesc_mps,
-        "units": {"distance": output_units, "time": output_time}
+        "units": {"distance": output_dist_unit, "time": output_time_unit}
     }

abstract_math/solar_math/src/utils/velocity_utils.py

@@ -2,51 +2,80 @@
 from ..imports import *
 from ..constants import *
 
-def distance_per_time_to_mps(v: float, dist_units: str, time_units: str) -> float:
+def distance_per_time_to_mps(v: float, dist_unit: str, time_unit: str) -> float:
     """
-    Convert <v> in (<dist_units>/<time_units>) to m/s.
+    Convert <v> in (<dist_unit>/<time_unit>) to m/s.
     """
     # distance: unit -> meters
-    norm_dist_unit = normalize_distance_unit(dist_units)   # <-- was normalize_time_unit
-    meters_per_unit = get_distance_unit_conversions(norm_dist_unit)["conv"]["meters"]
-    v_meters_per_timeunit = mul(v, meters_per_unit)
+    norm_dist_unit = normalize_distance_unit(
+        dist_unit
+        )   # <-- was normalize_time_unit
+    meters_per_unit = get_distance_unit_conversions(
+        norm_dist_unit
+        )["conv"]["meters"]
+    v_meters_per_timeunit = mul(
+        v,
+        meters_per_unit
+        )
 
     # time: timeunit -> seconds
-    sec_per_time = seconds_per(time_units)                 # from time_constants.py
-    return div(v_meters_per_timeunit, sec_per_time)
+    sec_per_time = seconds_per(
+        time_unit
+        )                 # from time_constants.py
+    return div(
+        v_meters_per_timeunit,
+        sec_per_time
+        )
 
-def mps_to_distance_per_time(v_mps: float, dist_units: str, time_units: str) -> float:
+def mps_to_distance_per_time(v_mps: float, dist_unit: str, time_unit: str) -> float:
     """
-    Convert m/s to <dist_units>/<time_units>.
+    Convert m/s to <dist_unit>/<time_unit>.
     """
-    norm_dist_unit = normalize_distance_unit(dist_units)
-    meters_per_unit = get_distance_unit_conversions(norm_dist_unit)["conv"]["meters"]
-    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]
+    norm_dist_unit = normalize_distance_unit(
+        dist_unit
+        )
+    meters_per_unit = get_distance_unit_conversions(
+        norm_dist_unit
+        )["conv"]["meters"]
+    v_unit_per_sec = div(v_mps, meters_per_unit)          # [dist_unit / s]
+    sec_per_time = seconds_per(
+        time_unit
+        )
+    return mul(
+        v_unit_per_sec,
+        sec_per_time
+        )              # [dist_unit / time_unit]
 
 
 
 
 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,
+    input_time_unit: str = DEFAULT_TIME_UNIT,
+    input_dist_unit: str = DEFAULT_DIST_UNIT,
+    output_dist_unit: str = DEFAULT_DIST_UNIT,
+    output_time_unit: str = DEFAULT_TIME_UNIT,
     ):
-    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)
+    v0_mps = distance_per_time_to_mps(
+        v=velocity,
+        dist_unit=input_dist_unit,
+        time_unit=input_time_unit
+        )
+    v0_unit_p_time = mps_to_distance_per_time(
+        v_mps=v0_mps,
+        dist_unit=output_dist_unit,
+        time_unit=output_time_unit
+        )
     return v0_unit_p_time
 
 def normalized_velocity_conversioin(
     velocity,
-    input_time: str = DEFAULT_TIME,
-    input_units: str = DEFAULT_UNITS
+    input_time_unit: str = DEFAULT_TIME_UNIT,
+    input_dist_unit: str = DEFAULT_DIST_UNIT
     ):
     v0_mps = get_velocity_conversioin(
         velocity=velocity,
-        input_time=input_time,
-        input_units=input_units
+        input_time_unit=input_time_unit,
+        input_dist_unit=input_dist_unit
         )
     return v0_mps

{abstract_math-0.0.0.30.dist-info → abstract_math-0.0.0.32.dist-info}/METADATA

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

{abstract_math-0.0.0.30.dist-info → abstract_math-0.0.0.32.dist-info}/RECORD

@@ -6,18 +6,18 @@ abstract_math/flask_scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 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=2QtMUMXP2Fshdr95gIKKDm_NAJCTDjFqzt_x9R2hMA8,9613
+abstract_math/solar_math/main.py,sha256=7YYjAduPpt8oDxxr1rEJeC6LHQx49o8cfrui4O0Qc8g,9849
 abstract_math/solar_math/src/__init__.py,sha256=qeal73F-NLu6sO_YSmD_komVpe17f0OFy2IfBR2QU_s,70
 abstract_math/solar_math/src/imports.py,sha256=aiFyZLsoVwkGopAL0uLaIPordUizM7UT9shwShmf0f0,195
-abstract_math/solar_math/src/constants/__init__.py,sha256=Xsb9_3DdF5HxqWOleD-6jQbv09XdDd6o8Urdqb8Af1s,801
-abstract_math/solar_math/src/constants/distance_constants.py,sha256=1TM_dzo0semwZkk5kveRljzPYN0ry5yNCmwORks4yUs,2793
-abstract_math/solar_math/src/constants/planet_constants.py,sha256=h1jJQJmIQGYUY-__hiDCSUWjUfNjfmF7IYMByRHmMJk,6842
-abstract_math/solar_math/src/constants/time_constants.py,sha256=i1gMbymsAkF23YwF4KGwEPpNuwNp1n5MCb4ALHdjxnU,1890
+abstract_math/solar_math/src/constants/__init__.py,sha256=VSo386-vGfJirycDGRGmLrjmi8GLXXW0kXJr2E7ZAnI,810
+abstract_math/solar_math/src/constants/distance_constants.py,sha256=pqFgSB0WrIlmv0xhhy1biVjBTMXzxO3RsiKYes4bLT4,2893
+abstract_math/solar_math/src/constants/planet_constants.py,sha256=XqdvEjoMuSv-3dCMwWNf9CE-6zFqWfvn_9WKvKE_NS4,6964
+abstract_math/solar_math/src/constants/time_constants.py,sha256=9_7gCR3swAjyUwFNLja1keRxTYx4kzF39TB9Vwav_PM,1960
 abstract_math/solar_math/src/utils/__init__.py,sha256=Vb2bfx1p9YSmhnbqXBjGVPt1OQZ9I7PG_fMQdFqj-3k,91
-abstract_math/solar_math/src/utils/escape_velocity.py,sha256=nngwySzxqB7JOV1RLRHKj6O3v4O45yOIkV3lVchPdGg,4926
+abstract_math/solar_math/src/utils/escape_velocity.py,sha256=rZkwf6gaBpciCmxUKnzLGXfI5P9JRkFSLyCvXNcsLtk,5245
 abstract_math/solar_math/src/utils/geometry_utils.py,sha256=Ij4mASNFp2-CWy425fxMTEuMPuAZHs-E0qvi3BjaNkk,4169
-abstract_math/solar_math/src/utils/velocity_utils.py,sha256=eiXstQ3PF0KAUamSFOHFIL1chyWweygdTyvBjQB_DXo,1888
-abstract_math-0.0.0.30.dist-info/METADATA,sha256=tqh6vYAjAsinRigYYJ1MoXURnRbwrZLCTC27k4x_PgM,3081
-abstract_math-0.0.0.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-abstract_math-0.0.0.30.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
-abstract_math-0.0.0.30.dist-info/RECORD,,
+abstract_math/solar_math/src/utils/velocity_utils.py,sha256=se1RiyLN3uhJwXy42_6JFidbDECWB_sVzt8F6HXK0x0,2211
+abstract_math-0.0.0.32.dist-info/METADATA,sha256=LyysVhRcqa3QM-7mdbJs4WeZqmjW1AzV1Vg3fyBiTz4,3081
+abstract_math-0.0.0.32.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+abstract_math-0.0.0.32.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
+abstract_math-0.0.0.32.dist-info/RECORD,,