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

abstract_math/solar_math/src/utils/escape_velocity.py

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

abstract_math/solar_math/src/utils/geometry_utils.py

@@ -0,0 +1,104 @@
+from ..imports import *
+from ..constants import *
+# --- Spherical cap (true horizon-limited visibility) ---
+def get_central_angle(r_m: float, h_m: float) -> float:
+    """Angle at Earth's center from observer to horizon (radians)."""
+    rh = add(r_m, h_m)
+    # clamp to avoid domain issues
+    val = max(-1.0, min(1.0, div(r_m, rh)))
+    return math.acos(val)
+
+def get_h_cap(r_m: float, h_m: float, theta: Optional[float] = None) -> float:
+    """Spherical cap height (meters)."""
+    if theta is None:
+        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'):
+    """
+    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')
+
+    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
+
+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)
+    return mul(div(cap_area_u2, full_area_u2), 100.0)
+
+# --- Camera/FOV flat-projection helper (approximate) ---
+def visible_area_flat(fov_degrees: float, altitude_m: float, units: str = 'meters'):
+    """
+    Given altitude in meters, return (area_m2, visible_radius_m). `units` arg is ignored,
+    kept for backward compatibility.
+    """
+    fov_radians = math.radians(fov_degrees)
+    visible_radius_m = altitude_m * math.tan(fov_radians / 2.0)
+    area_m2 = math.pi * (visible_radius_m ** 2)
+    return area_m2, visible_radius_m
+
+def visible_surface_angle(visible_radius: float, sphere_radius: float) -> tuple[float, float]:
+    """Chord-based angular span (approximate)."""
+    chord_length = mul(2.0, visible_radius)
+    angle_rad = mul(2.0, math.asin(div(chord_length, mul(2.0, sphere_radius))))
+    angle_deg = math.degrees(angle_rad)
+    return angle_rad, angle_deg
+
+# --- FOV triangle pack (kept but made unit-consistent) ---
+def get_triangle_area(a: float, b: float, c: float):
+    s = (a + b + c) / 2.0
+    area = math.sqrt(max(0.0, s * (s - a) * (s - b) * (s - c)))
+    return area, s
+
+def get_medians(a: float, b: float, c: float) -> float:
+    # median from side 'a'
+    return 0.5 * math.sqrt(max(0.0, 2*b*b + 2*c*c - a*a))
+
+def get_triangle_medians(a: float, b: float, c: float):
+    return {"ma": get_medians(b, c, a), "mb": get_medians(a, c, b), "mc": get_medians(a, b, c)}
+
+def get_triangle_heights(a: float, b: float, c: float, area: float):
+    ha = mul(2.0, div(area, a))
+    hb = mul(2.0, div(area, b))
+    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'):
+    """Simple isosceles triangle model for a camera at altitude."""
+    a = convert(altitude, units, 'meters')
+    fov_angle_rad = math.radians(fov_angle_deg)
+    base = 2.0 * a * math.tan(fov_angle_rad / 2.0)
+    b = c = a
+
+    # Triangle inequality guard
+    if not ((base + b > c) and (base + c > b) and (b + c > base)):
+        return {"error": "Invalid triangle geometry. Lower FOV or increase altitude.",
+                "sides": {"a": base, "b": b, "c": c}}
+
+    triangle_area, s = get_triangle_area(base, b, c)
+    medians = get_triangle_medians(base, b, c)
+    heights = get_triangle_heights(base, b, c, triangle_area)
+    vertices = {"A": (0, 0), "B": (base / 2.0, a), "C": (-base / 2.0, a)}
+    inradius = div(triangle_area, s)
+    circumradius = 0.5 * a  # right-ish simplification for this layout
+
+    return {
+        "sides": {"a": base, "b": b, "c": c},
+        "area": triangle_area,
+        "perimeter": base + 2.0 * a,
+        "semiperimeter": s,
+        "heights": heights,
+        "medians": medians,
+        "vertices": vertices,
+        "inradius": inradius,
+        "circumradius": circumradius
+    }
+
+

abstract_math/solar_math/src/utils/velocity_utils.py

@@ -0,0 +1,26 @@
+#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]

abstract_math-0.0.0.19.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: abstract_math
+Version: 0.0.0.19
+Author: putkoff
+Author-email: partners@abstractendeavors.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-python
+
+# abstract_math
+
+## Description
+The abstract_math Python module, currently in its Alpha development stage (version 0.0.0.14), is designed for performing complex mathematical operations and token manipulations. This module comprises primarily of two scripts: `safe_math` and `derive_tokens`.
+
+## Features
+- Performing complex mathematical operations.
+- Manipulation and derivation of mathematical tokens, referred to as 'lamports'.
+- High precision for decimal calculations for better accuracy.
+- Functions for deriving quantities like lamports, virtual reserves, sol reserves, sol amounts, token reserves, token amounts, derived token ratio, price, and token decimals.
+- Module components for updating Sol and token variables.
+
+## Scripts Overview
+
+- `derive_tokens.py`: This script is involved in the complex manipulation or derivation of mathematical tokens, referred to as 'lamports'. The functions defined in this script handle various aspects of token manipulations and calculations. 
+
+
+## Installation
+To install the abstract_math module, ensure that your Python version is 3.6 or later. This module currently does not have any external dependencies to be installed.
+
+## Usage
+This module could potentially be used as a framework for handling complex mathematical operations or token manipulations. Developers interested in working with and enhancing this module can access the source code at the repository (provide repo link here).
+
+## Dependencies
+Currently, the module does not require any external dependencies.
+
+## License
+The module is provided under the MIT License.
+
+## Author & Contact
+This Python module was authored by 'putkoff', who can be reached at partners@abstractendeavors.com for further queries or assistance.
+
+## Contributing
+Contributions are welcome to help in the development of the abstract_math module, particularly with the 'safe_math' and 'derive_tokens' scripts that form the core of the module.
+# Unknown Package (vUnknown Version)
+
+No description available
+
+## Installation
+
+```bash
+pip install Unknown Package
+```
+
+## Dependencies
+
+None
+
+## Modules
+
+### src/abstract_math/safe_math.py
+
+Description of script based on prompt: You are analyzing a Python script 'safe_math.py' l (mock response)
+
+### src/abstract_math/__init__.py
+
+Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
+
+### src/abstract_math/derive_tokens.py
+
+Description of script based on prompt: You are analyzing a Python script 'derive_tokens.p (mock response)
+

abstract_math-0.0.0.19.dist-info/RECORD

@@ -0,0 +1,22 @@
+abstract_math/__init__.py,sha256=wr-kwaB8micSsR1nCHuDXRlsL59DWlqZQFN7M_rfZys,80
+abstract_math/derive_tokens.py,sha256=mVrr8UJvS8mOOLMuowKVT0h9htiraHResjMuYBR4EhA,4559
+abstract_math/safe_math.py,sha256=dZzxR2glwmzYKD0YlNaxOTYAg_ZNKYhDSVu7KRVIbjk,6047
+abstract_math/flask_scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+abstract_math/flask_scripts/flask_utils.py,sha256=z6gpPshiOeqNANBQkZMZPkegCzj-GK3OpSOi1lN19Sc,28483
+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/src/__init__.py,sha256=qeal73F-NLu6sO_YSmD_komVpe17f0OFy2IfBR2QU_s,70
+abstract_math/solar_math/src/imports.py,sha256=GfkWfXDc6fzLe7kHYlSdghkN0Nob0xApxhEyRyDcZS0,182
+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/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/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.19.dist-info/METADATA,sha256=a-8SS2TnfGaM3ayj-3douwCk5qkcFuRtF5e3-iUN_cg,3081
+abstract_math-0.0.0.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_math-0.0.0.19.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
+abstract_math-0.0.0.19.dist-info/RECORD,,

{abstract_math-0.0.0.17.dist-info → abstract_math-0.0.0.19.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

abstract_math/deriveit.py

@@ -1,97 +0,0 @@
-from decimal import Decimal, getcontext
-from .safe_math import *
-getcontext().prec = 50  # High precision for accuracy
-SOL_DECIMAL_PLACE = 9
-SOL_LAMPORTS = sol_lamports =int(exponential(1,exp=SOL_DECIMAL_PLACE,num=1))
-def get_proper_args(strings,*args,**kwargs):
-    properArgs = [] 
-    for key in strings:
-        kwarg = kwargs.get(key)
-        if kwarg == None and args:
-            kwarg = args[0]
-            args = [] if len(args) == 1 else args[1:]
-        properArgs.append(kwarg)
-    return properArgs
-
-#lamports
-def get_lamports(integer):
-    return exp_it(10,len(str(integer))+1,1)
-def get_lamport_difference(lamports,virtual_lamports):
-    integer = int(virtual_lamports/lamports)
-    exponential = len(str(integer))
-    return int(exponential(1,exp=exponential,num=1))
-#virtual reserves
-def get_vitual_reserves(*args,**kwargs):
-    proper_args = get_proper_args(["virtualSolReserves","virtualTokenReserves"],*args,**kwargs)
-    return proper_args
-def get_virtual_reserve_ratio(*ars,**kwargs):
-    proper_args = get_vitual_reserves(*args,**kwargs)
-    return divide_it(*proper_args)
-#sol reserves
-def get_virtual_sol_reservs(*args,**kwargs):
-    proper_args = get_proper_args(["virtualSolReserves"],*args,**kwargs)
-    return proper_args[0] if proper_args else proper_args
-def get_virtual_sol_lamports(*args,**kwargs):
-    virtual_sol_reserves = get_virtual_sol_reservs(*args,**kwargs)
-    virtual_sol_lamports = get_lamports(virtual_sol_reserves)
-    return virtual_sol_lamports
-def get_virtual_sol_lamp_difference(*args,**kwargs):
-    virtual_sol_lamports = get_virtual_sol_lamports(*args,**kwargs)
-    return get_lamport_difference(SOL_LAMPORTS,virtual_sol_lamports)
-#sol Amount
-def get_sol_amount(*args,**kwargs):
-    proper_args = get_proper_args(["solAmount"],*args,**kwargs)
-    return proper_args[0] if proper_args else proper_args
-def getSolAmountUi(*args,**kwargs):
-    sol_amount = get_sol_amount(*args,**kwargs)
-    return exponential(sol_amount,SOL_DECIMAL_PLACE)
-#token reserves
-def get_virtual_token_reservs(*args,**kwargs):
-    proper_args = get_proper_args(["virtualTokenReserves"],*args,**kwargs)
-    return proper_args[0] if proper_args else proper_args
-def get_virtual_token_lamports(*args,**kwargs):
-    virtual_token_reserves = get_virtual_token_reservs(*args,**kwargs)
-    virtual_token_lamports = get_lamports(virtual_token_reserves)
-    return virtual_token_lamports
-#token amount
-def get_token_amount(*args,**kwargs):
-    proper_args = get_proper_args(["tokenAmount"],*args,**kwargs)
-    return proper_args[0] if proper_args else proper_args
-def get_token_amount_ui(*args,**kwargs):
-    token_amount = get_token_amount(*args,**kwargs)
-    token_decimals = derive_token_decimals(*args,**kwargs)
-    return exponential(token_amount,exp=token_decimals)
-#token derivision
-def derive_token_decimals_from_token_variables(variables):
-    variables["price"] = get_price(**variables)
-    variables["tokenDecimals"] = derive_decimals_from_vars(*args,**kwargs)
-    return variables
-def get_derived_token_ratio(*args,**kwarg):
-    derived_token_amount = derive_token_amount(*args,**kwargs)
-    token_amount = get_token_amount(*args,**kwargs)
-    ratio = divide_it(derived_token_amount,token_amount)
-    return ratio
-def derive_token_amount(*args,**kwargs):
-    virtual_token_reserves = get_virtual_token_reserves(*args,**kwargs)
-    price = get_price(*args,**kwargs)
-    derived_token_amount = divide_it(virtual_token_reserves,price)
-    return derived_token_amount
-#derive variables
-def get_price(*args,**kwargs):
-    reserve_ratios = get_virtual_reserve_ratio(*ars,**kwargs)
-    virtual_sol_lamp_difference = get_virtual_sol_lamp_difference(*args,**kwargs)
-    return reserve_ratios/virtual_sol_lamp_difference
-def derive_decimals_from_vars(*args,**kwargs):
-  ratio = get_derived_token_ratio(*args,**kwarg)
-  decimals = -1
-  while abs(ratio - round(ratio)) > 1e-9:
-      ratio *= 10
-      decimals += 1
-  return decimals
-def update_token_variables(variables):
-    variables['solAmountUi'] = getSolAmountUi(**variables)
-    variables['solDecimals'] = 9
-    variables = derive_token_decimals_from_token_variables(variables)
-    variables['tokenAmountUi'] = exponential(variables['tokenAmount'],variables["tokenDecimals"])
-    return variables
-

abstract_math-0.0.0.17.dist-info/METADATA

@@ -1,47 +0,0 @@
-Metadata-Version: 2.4
-Name: abstract_math
-Version: 0.0.0.17
-Author: putkoff
-Author-email: partners@abstractendeavors.com
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: requires-python
-
-# Unknown Package (vUnknown Version)
-
-No description available
-
-## Installation
-
-```bash
-pip install Unknown Package
-```
-
-## Dependencies
-
-None
-
-## Modules
-
-### src/abstract_math/safe_math.py
-
-Description of script based on prompt: You are analyzing a Python script 'safe_math.py' l (mock response)
-
-### src/abstract_math/__init__.py
-
-Description of script based on prompt: You are analyzing a Python script '__init__.py' lo (mock response)
-
-### src/abstract_math/derive_tokens.py
-
-Description of script based on prompt: You are analyzing a Python script 'derive_tokens.p (mock response)
-

abstract_math-0.0.0.17.dist-info/RECORD

@@ -1,8 +0,0 @@
-abstract_math/__init__.py,sha256=3I0YJakDUyWD7qXpdRsaEsmcA7IxwcWhoyecvDfOE98,54
-abstract_math/derive_tokens.py,sha256=0rHanu6-UweOXxVuPn-DQsbUn7Xaoz39TQJiWDe7K5Q,4382
-abstract_math/deriveit.py,sha256=Og8QtDGRrgGbmaHTh-jEusg35jUpb74DgzslsxZ_2iU,4271
-abstract_math/safe_math.py,sha256=Rt5STOAuRRKhV1-YNfhX-OlhwVgRpk6XdN74UjnHvRc,5394
-abstract_math-0.0.0.17.dist-info/METADATA,sha256=dcY6VVLpIcr_Vhm2AniROKDBdHi60GlbhxoXGC3s70Y,1150
-abstract_math-0.0.0.17.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-abstract_math-0.0.0.17.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
-abstract_math-0.0.0.17.dist-info/RECORD,,