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

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

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

abstract_math-0.0.0.18.dist-info/RECORD

@@ -0,0 +1,23 @@
+abstract_math/__init__.py,sha256=wr-kwaB8micSsR1nCHuDXRlsL59DWlqZQFN7M_rfZys,80
+abstract_math/derive_tokens.py,sha256=0rHanu6-UweOXxVuPn-DQsbUn7Xaoz39TQJiWDe7K5Q,4382
+abstract_math/safe_math.py,sha256=Rt5STOAuRRKhV1-YNfhX-OlhwVgRpk6XdN74UjnHvRc,5394
+abstract_math/flask_scripts/__init__.py,sha256=En366EX8hQ7FRsh_8hgjrgHFAQkkVi72wFcpSiOxz-s,26
+abstract_math/flask_scripts/flask_utils.py,sha256=z6gpPshiOeqNANBQkZMZPkegCzj-GK3OpSOi1lN19Sc,28483
+abstract_math/flask_scripts/make_flask.py,sha256=6c7Vt_iSTDf_bhmBkK5E-GIiHGbhkwHl_B_79C3BTZY,104
+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=U2wY9NwbzarE6IXrIRpPbRV2e42V3cX8HS8f_80CZ7I,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=K_t6q5kO0jJjkhWfIpTJlfJCLBneYh0LKf3FwQf0ye4,2972
+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.18.dist-info/METADATA,sha256=tb1dh0iK-jG-yHIQerV-P6E2Kwoqt7VsXvT-C59YhN0,1150
+abstract_math-0.0.0.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+abstract_math-0.0.0.18.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
+abstract_math-0.0.0.18.dist-info/RECORD,,

{abstract_math-0.0.0.16.dist-info → abstract_math-0.0.0.18.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.16.dist-info/RECORD

@@ -1,8 +0,0 @@
-abstract_math/__init__.py,sha256=3I0YJakDUyWD7qXpdRsaEsmcA7IxwcWhoyecvDfOE98,54
-abstract_math/derive_tokens.py,sha256=Ba2hq3-W3NPmfko-Lf-58HfkBtl4kfN-GFuSZJMyiWM,4233
-abstract_math/deriveit.py,sha256=Og8QtDGRrgGbmaHTh-jEusg35jUpb74DgzslsxZ_2iU,4271
-abstract_math/safe_math.py,sha256=WIIiHELl3AqV2IdWlWd5Ca4TOD6qffeGNA33gJQqS6k,5378
-abstract_math-0.0.0.16.dist-info/METADATA,sha256=C9JFxjf0rGKI9LaXkNbC1JvgGkie_TUsUkQO8fGaarc,1150
-abstract_math-0.0.0.16.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-abstract_math-0.0.0.16.dist-info/top_level.txt,sha256=b7jOgD9c0U-CGH-l7yxhMPukzD40kMEQkQRV_sGyVfE,14
-abstract_math-0.0.0.16.dist-info/RECORD,,