abstract-math 0.0.0.27__tar.gz → 0.0.0.47__tar.gz

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/PKG-INFO

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

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/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.27',
+    version='0.0.0.47',
     author='putkoff',
     author_email='partners@abstractendeavors.com',
     description="",

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/flask_scripts/flask_utils.py

@@ -1,4 +1,4 @@
-from abstract_flask import *  # must provide Blueprint, request, jsonify, get_request_data, get_logFile, offer_help
+from abstract_flask import offer_help,Blueprint,get_logFile,get_request_data,jsonify  # 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/')

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/safe_math.py

@@ -1,4 +1,4 @@
-from abstract_utilities import *
+from abstract_utilities import is_number
 import math
 import operator
 from functools import reduce

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/flask_utils.py

@@ -1,4 +1,4 @@
-from abstract_flask import *
+from abstract_flask import generate_from_files
 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'

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/main.py

@@ -5,31 +5,32 @@ 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.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
     )
+
 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,
     )
 
@@ -44,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)
@@ -198,7 +199,7 @@ def simulate_radial_flight_si(
         "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": exp(mul(2.0, div(mu, r)),-2),
 
         # extended stats
         "furthest_r": tracker["furthest_r"],
@@ -212,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,
@@ -225,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(
@@ -240,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,
@@ -249,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-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/src/constants/__init__.py

@@ -2,12 +2,14 @@
 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,
+    get_smallest_dist_unit_string
 )
 from .time_constants import (
     TIME_CONVERSIONS, ALL_TIME_UNITS,
-    normalize_time_unit, get_time_unit_conversions,
-    time_factor, convert_time, seconds_per,DEFAULT_TIME
+    normalize_time_unit, get_time_unit_conversions,tconvert,
+    time_factor, convert_time, seconds_per,DEFAULT_TIME_UNIT,
+    get_smallest_time_unit_string
 )
 from .planet_constants import (
     PLANETS, G, g0, MU_MOON,
@@ -18,3 +20,11 @@ from .planet_constants import (
     earth_volume, earth_circumference,DEFAULT_PLANET,DEFAULT_AS_RADIUS,
     distance_per_sec_to_mps
 )
+def get_smallest_unit_string(unit):
+    for key,values in DISTANCE_CONVERSIONS.items():
+        if unit in values["strings"]:
+            return values["strings"][0]
+    for key,values in TIME_CONVERSIONS.items():
+        if unit in values["strings"]:
+            return values["strings"][0]
+    return unit

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/src/constants/distance_constants.py

@@ -19,8 +19,13 @@ DISTANCE_CONVERSIONS: Dict[str, Dict[str, Dict[str, float]]] = {
     "feet": FEET
 }
 ALL_DISTANCE_UNITS = ("meters", "kilometers", "miles", "feet")
-DEFAULT_UNITS="meters"
+DEFAULT_DIST_UNIT="m"
 DEFAULT_START_ALTITUDE=0.0
+def get_smallest_dist_unit_string(unit):
+    for key,values in DISTANCE_CONVERSIONS.items():
+        if unit in values["strings"]:
+            return values["strings"][0]
+    return unit
 # -------------------------
 # Unit helpers
 # -------------------------
@@ -34,36 +39,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
+                dist_unit_from=input_dist_units,
+                dist_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)
+                              dist_unit_from=input_dist_units,
+                              dist_unit_to=output_dist_units)
     return target_distance

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/src/constants/planet_constants.py

@@ -47,8 +47,9 @@ 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.lower()
-    return _NAME_ALIASES.get(n, n)
+    if isinstance(name,str):
+        n = name.lower()
+        return _NAME_ALIASES.get(n, n)
 
 _BODY_BY_NAME: Dict[str, Dict[str, Any]] = {}
 for entry in PLANETS:
@@ -57,7 +58,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 +68,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(dist_unit)
     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) -> float:
-    v = get_planet_vars(name)["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 +120,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:
-    return planet_radius('earth', units)
+def earth_radius(dist_unit: str = 'meters') -> float:
+    return planet_radius('earth', dist_unit)
 
-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-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/src/constants/time_constants.py

@@ -21,36 +21,40 @@ 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 get_smallest_time_unit_string(unit):
+    for key,values in TIME_CONVERSIONS.items():
+        if unit in values["strings"]:
+            return values["strings"][0]
+    return unit
+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 tconvert(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)."""
     return get_time_unit_conversions(normalize_time_unit(unit))["conv"]["seconds"]
-
-
+convert_time = tconvert
 

abstract_math-0.0.0.47/src/abstract_math/solar_math/src/imports.py

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

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

@@ -0,0 +1,145 @@
+# src/utils/escape_velocity.py
+from ..imports import math, mul, div, add
+from ..constants import (
+    DEFAULT_DIST_UNIT,
+    DEFAULT_TIME_UNIT,
+    DEFAULT_PLANET,
+    DEFAULT_START_ALTITUDE,
+    DEFAULT_AS_RADIUS,
+    get_smallest_unit_string
+    )
+from ..constants.planet_constants import get_body,get_R_mu,g_at_radius
+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,tconvert
+from .velocity_utils import normalized_velocity_conversion,get_velocity_conversion
+def get_r_m(planet: str = DEFAULT_PLANET,start_altitude: float = DEFAULT_START_ALTITUDE,input_dist_unit: str = DEFAULT_DIST_UNIT,as_radius:bool = DEFAULT_AS_RADIUS):
+    R,mu = get_R_mu(planet=planet)
+    r_m = dconvert(start_altitude, input_dist_unit, DEFAULT_DIST_UNIT)
+    # 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_dist_unit: str = DEFAULT_DIST_UNIT,
+    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_dist_unit=input_dist_unit,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_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_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_conversion(
+        velocity=starting_velocity,
+        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_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:
+    """
+    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_dist_unit=input_dist_unit,
+                  as_radius=as_radius
+                  )
+    r_conv = dconvert(r_m, input_dist_unit, output_dist_unit)
+    v_escape_mps = get_vesc_mps(
+        planet=planet,
+        start_altitude=start_altitude,
+        input_dist_unit=input_dist_unit,
+        as_radius=as_radius
+        )
+    v_escape = get_velocity_conversion(velocity=v_escape_mps,
+                                    input_time_unit= DEFAULT_TIME_UNIT,
+                                    input_dist_unit= DEFAULT_DIST_UNIT,
+                                    output_dist_unit= output_dist_unit,
+                                    output_time_unit= output_time_unit)
+    # Convert speed to <output_units>/<output_time>
+
+    # Also return the radius in output_units for convenience
+    
+    
+    g_o_mps = g_at_radius(mu, r_m)
+    g_o_conv = get_velocity_conversion(velocity=g_o_mps,
+                                    input_time_unit= DEFAULT_TIME_UNIT,
+                                    input_dist_unit= DEFAULT_DIST_UNIT,
+                                    output_dist_unit= output_dist_unit,
+                                    output_time_unit= output_time_unit)
+   
+    smallest_time_unit = get_smallest_unit_string(output_time_unit)
+    smallest_distance_unit = get_smallest_unit_string(output_dist_unit)
+    return {
+        "ok": True,
+        "planet": planet,
+        
+        "v_escape": round(v_escape,6),
+        "v_escape_mps": round(v_escape_mps,6),
+        "units": {"distance": output_dist_unit, "time": output_time_unit},
+        "r_m":round(r_m,6),
+        "r": round(r_conv,6),
+        "g_o_mps":round(g_o_mps,6),
+        "g_o":round(g_o_conv,6),
+        
+
+        "units": {"distance": output_dist_unit, "time": output_time_unit},
+        "radius_from_center": f"{round(r_conv,2)} {smallest_distance_unit}",
+        "v_escape": f"{round(v_escape,2)} {smallest_distance_unit}/{smallest_time_unit}^2",
+        "g_out": f"{round(g_o_conv,2)} {smallest_distance_unit}/{smallest_time_unit}^2",
+        "escape_velocity": f"{round(v_escape,2)} {smallest_distance_unit}/{smallest_time_unit}^2"
+      
+    }

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math/solar_math/src/utils/geometry_utils.py

@@ -14,23 +14,23 @@ def get_h_cap(r_m: float, h_m: float, theta: Optional[float] = None) -> float:
         theta = get_central_angle(r_m, h_m)
     return mul(r_m, sub(1.0, math.cos(theta)))
 
-def spherical_cap_area(observer_altitude: float, units: str = 'meters'):
+def spherical_cap_area(observer_altitude: float, dist_unit: str = 'meters'):
     """
     Visible spherical cap area from altitude (same units as input returned in unit^2).
     """
     r_m = earth_radius('meters')
-    h_m = convert(observer_altitude, units, 'meters')
+    h_m = convert(observer_altitude, dist_unit, 'meters')
 
     theta = get_central_angle(r_m, h_m)
     h_cap_m = get_h_cap(r_m, h_m, theta)
     area_m2 = mul(2 * pi() * r_m, h_cap_m)  # 2π R h
     # return in requested units^2
-    area_u2 = mul(area_m2, exp(_factor('meters', units), 2))
-    return area_u2, convert(h_cap_m, 'meters', units), theta
+    area_u2 = mul(area_m2, exp(_factor('meters', dist_unit), 2))
+    return area_u2, convert(h_cap_m, 'meters', dist_unit), theta
 
-def percent_visible(observer_altitude: float, units: str = 'meters') -> float:
-    cap_area_u2, _, _ = spherical_cap_area(observer_altitude, units)
-    full_area_u2 = full_earth_surface_area(units)
+def percent_visible(observer_altitude: float, dist_unit: str = 'meters') -> float:
+    cap_area_u2, _, _ = spherical_cap_area(observer_altitude, dist_unit)
+    full_area_u2 = full_earth_surface_area(dist_unit)
     return mul(div(cap_area_u2, full_area_u2), 100.0)
 
 # --- Camera/FOV flat-projection helper (approximate) ---
@@ -70,9 +70,9 @@ def get_triangle_heights(a: float, b: float, c: float, area: float):
     hc = mul(2.0, div(area, c))
     return {"ha": ha, "hb": hb, "hc": hc}
 
-def compute_fov_triangle(altitude: float, fov_angle_deg: float, units: str = 'meters'):
+def compute_fov_triangle(altitude: float, fov_angle_deg: float, dist_unit: str = 'meters'):
     """Simple isosceles triangle model for a camera at altitude."""
-    a = convert(altitude, units, 'meters')
+    a = dconvert(altitude, dist_unit, 'meters')
     fov_angle_rad = math.radians(fov_angle_deg)
     base = 2.0 * a * math.tan(fov_angle_rad / 2.0)
     b = c = a

abstract_math-0.0.0.47/src/abstract_math/solar_math/src/utils/velocity_utils.py

@@ -0,0 +1,74 @@
+#src/utils/velocity_utils.py
+from ..imports import *
+from ..constants import *
+
+def distance_per_time_to_mps(v: float, dist_unit: str, time_unit: str) -> float:
+    """
+    Convert <v> in (<dist_unit>/<time_unit>) to m/s.
+    """
+    # distance: unit -> meters
+    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_unit
+        )                 # from time_constants.py
+    return div(
+        v_meters_per_timeunit,
+        sec_per_time
+        )
+
+def mps_to_distance_per_time(v_mps: float, dist_unit: str, time_unit: str) -> float:
+    """
+    Convert m/s to <dist_unit>/<time_unit>.
+    """
+    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_conversion(
+    velocity,
+    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_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_conversion(
+    velocity,
+    input_time_unit: str = DEFAULT_TIME_UNIT,
+    input_dist_unit: str = DEFAULT_DIST_UNIT,
+    ):
+    v0_mps = get_velocity_conversion(
+        velocity=velocity,
+        input_time_unit=input_time_unit,
+        input_dist_unit=input_dist_unit
+        )
+    return v0_mps
+

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math.egg-info/PKG-INFO

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

{abstract_math-0.0.0.27 → abstract_math-0.0.0.47}/src/abstract_math.egg-info/SOURCES.txt

@@ -23,4 +23,5 @@ src/abstract_math/solar_math/src/constants/time_constants.py
 src/abstract_math/solar_math/src/utils/__init__.py
 src/abstract_math/solar_math/src/utils/escape_velocity.py
 src/abstract_math/solar_math/src/utils/geometry_utils.py
-src/abstract_math/solar_math/src/utils/velocity_utils.py
+src/abstract_math/solar_math/src/utils/velocity_utils.py
+tests/test.py

abstract_math-0.0.0.47/tests/test.py

@@ -0,0 +1,5 @@
+from imports import *
+
+
+
+input(radial_travel('earth',output_dist_unit='mi',output_time_unit='hr'))

abstract_math-0.0.0.27/src/abstract_math/solar_math/src/imports.py

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

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

@@ -1,111 +0,0 @@
-# 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.27/src/abstract_math/solar_math/src/utils/velocity_utils.py

@@ -1,52 +0,0 @@
-#src/utils/velocity_utils.py
-from ..imports import *
-from ..constants import *
-
-def distance_per_time_to_mps(v: float, dist_units: str, time_units: str) -> float:
-    """
-    Convert <v> in (<dist_units>/<time_units>) 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)
-
-    # time: timeunit -> seconds
-    sec_per_time = seconds_per(time_units)                 # 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:
-    """
-    Convert m/s to <dist_units>/<time_units>.
-    """
-    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]
-
-
-
-
-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