WIP: Debugging Cython zero functionality

dbookstaber · dbookstaber · commit 0ca382445d19 · 2025-08-21T15:04:00.000-07:00
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/__init__.py b/py_ballisticcalc.exts/py_ballisticcalc_exts/__init__.py
@@ -8,10 +8,10 @@
 
 from .euler_engine import CythonizedEulerIntegrationEngine
 from .rk4_engine import CythonizedRK4IntegrationEngine
-from .trajectory_data import TrajectoryData
+# from .trajectory_data import TrajectoryDataT
 
 __all__ = (
     'CythonizedEulerIntegrationEngine',
     'CythonizedRK4IntegrationEngine',
-    'TrajectoryData',
+    # 'TrajectoryDataT',
 )
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pxd b/py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pxd
@@ -71,14 +71,14 @@ cdef class CythonizedBaseIntegrationEngine:
     # Python 'def' methods are not exposed in the C interface defined by a .pxd.
     # Only 'cdef' or 'cpdef' methods are declared here.
     cdef void _free_trajectory(CythonizedBaseIntegrationEngine self)
-    cdef void _init_trajectory(CythonizedBaseIntegrationEngine self, object shot_info)
-    cdef tuple _init_zero_calculation(CythonizedBaseIntegrationEngine self, object shot_info, object distance)
-    cdef object _find_zero_angle(CythonizedBaseIntegrationEngine self, object shot_info, object distance, bint lofted)
-    cdef object _zero_angle(CythonizedBaseIntegrationEngine self, object shot_info, object distance)
-    cdef tuple _find_max_range(CythonizedBaseIntegrationEngine self, object shot_info, tuple angle_bracket_deg = *)
-    cdef object _find_apex(CythonizedBaseIntegrationEngine self, object shot_info)
+    cdef ShotProps_t* _init_trajectory(CythonizedBaseIntegrationEngine self, object shot_info)
+    cdef tuple _init_zero_calculation(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr, double distance)
+    cdef object _find_zero_angle(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr, double distance, bint lofted)
+    cdef object _zero_angle(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr, double distance)
+    cdef tuple _find_max_range(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr, tuple angle_bracket_deg = *)
+    cdef object _find_apex(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr)
     # In contrast to Python engines, _integrate here returns (CBaseTrajSeq, Optional[error_str])
-    cdef object _integrate(CythonizedBaseIntegrationEngine self,
+    cdef object _integrate(CythonizedBaseIntegrationEngine self, ShotProps_t *shot_props_ptr,
                            double range_limit_ft, double range_step_ft, double time_step, int filter_flags)
 
 
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pyx b/py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pyx
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/base_traj_seq.pyx b/py_ballisticcalc.exts/py_ballisticcalc_exts/base_traj_seq.pyx
@@ -49,7 +49,7 @@ __all__ = ['CBaseTrajSeq', 'BaseTrajC']
 
 
 # Interpolation helper (pure C math; safe to call with or without GIL)
-cdef int _interpolate_nogil_raw(_CBaseTrajSeq_cview* seq, Py_ssize_t idx, int key_kind, double key_value, BaseTrajC* out) noexcept:
+cdef int _interpolate_nogil_raw(_CBaseTrajSeq_cview* seq, Py_ssize_t idx, int key_kind, double key_value, BaseTrajC* out) noexcept nogil:
     """Interpolate at idx using points (idx-1, idx, idx+1) keyed by key_kind at key_value."""
     cdef BaseTrajC* buffer = seq._buffer
     cdef Py_ssize_t plength = <Py_ssize_t> seq._length
@@ -124,7 +124,7 @@ cdef int _interpolate_nogil_raw(_CBaseTrajSeq_cview* seq, Py_ssize_t idx, int ke
     return 1
 
 
-cdef inline double _key_val_from_kind_buf(BaseTrajC* p, int key_kind) noexcept:
+cdef inline double _key_val_from_kind_buf(BaseTrajC* p, int key_kind) noexcept nogil:
     if key_kind == <int>KEY_TIME:
         return p.time
     elif key_kind == <int>KEY_MACH:
@@ -143,10 +143,10 @@ cdef inline double _key_val_from_kind_buf(BaseTrajC* p, int key_kind) noexcept:
         return p.vz
     return <double>0.0
 
-cdef inline double _slant_val_buf(BaseTrajC* p, double ca, double sa) noexcept:
+cdef inline double _slant_val_buf(BaseTrajC* p, double ca, double sa) noexcept nogil:
     return p.py * ca - p.px * sa
 
-cdef Py_ssize_t _bisect_center_idx_buf(BaseTrajC* buf, size_t length, int key_kind, double key_value) noexcept:
+cdef Py_ssize_t _bisect_center_idx_buf(BaseTrajC* buf, size_t length, int key_kind, double key_value) noexcept nogil:
     cdef Py_ssize_t n = <Py_ssize_t>length
     if n < 3:
         return <Py_ssize_t>(-1)
@@ -176,7 +176,7 @@ cdef Py_ssize_t _bisect_center_idx_buf(BaseTrajC* buf, size_t length, int key_ki
         return n - 2
     return lo
 
-cdef Py_ssize_t _bisect_center_idx_slant_buf(BaseTrajC* buf, size_t length, double ca, double sa, double value) noexcept:
+cdef Py_ssize_t _bisect_center_idx_slant_buf(BaseTrajC* buf, size_t length, double ca, double sa, double value) noexcept nogil:
     cdef Py_ssize_t n = <Py_ssize_t>length
     if n < 3:
         return <Py_ssize_t>(-1)
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/cy_bindings.pxd b/py_ballisticcalc.exts/py_ballisticcalc_exts/cy_bindings.pxd
@@ -79,6 +79,7 @@ cdef extern from "include/bclib.h" nogil:
         double calc_step
         double muzzle_velocity
         double stability_coefficient
+        int filter_flags
         Atmosphere_t atmo
 
     void ShotProps_t_free(ShotProps_t *shot_props_ptr)
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/euler_engine.pyx b/py_ballisticcalc.exts/py_ballisticcalc_exts/euler_engine.pyx
@@ -1,7 +1,5 @@
 from cython cimport final
 from libc.math cimport fabs, sin, cos, tan, atan, atan2, fmin, fmax, pow
-from libc.stdlib cimport malloc, realloc, free
-from py_ballisticcalc_exts.trajectory_data cimport TrajFlag_t, BaseTrajDataT, TrajectoryData, BaseTrajDataT_create
 from py_ballisticcalc_exts.cy_bindings cimport (
     Config_t,
     ShotProps_t,
@@ -10,16 +8,8 @@ from py_ballisticcalc_exts.cy_bindings cimport (
 )
 from py_ballisticcalc_exts.base_engine cimport (
     CythonizedBaseIntegrationEngine,
-    TrajDataFilter_t,
-
     WindSock_t_currentVector,
     WindSock_t_vectorForRange,
-
-    create_trajectory_row,
-
-    TrajDataFilter_t_create,
-    TrajDataFilter_t_setup_seen_zero,
-    TrajDataFilter_t_should_record,
 )
 
 from py_ballisticcalc_exts.v3d cimport V3dT, add, sub, mag, mulS
@@ -46,7 +36,7 @@ cdef class CythonizedEulerIntegrationEngine(CythonizedBaseIntegrationEngine):
         """Calculate time step based on current projectile speed."""
         return base_step / fmax(<double>1.0, velocity)
 
-    cdef object _integrate(CythonizedEulerIntegrationEngine self,
+    cdef object _integrate(CythonizedEulerIntegrationEngine self, ShotProps_t *shot_props_ptr,
                            double range_limit_ft, double range_step_ft,
                            double time_step, int filter_flags):
         """
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/include/bclib.h b/py_ballisticcalc.exts/py_ballisticcalc_exts/include/bclib.h
@@ -80,6 +80,7 @@ typedef struct {
     double calc_step;
     double muzzle_velocity;
     double stability_coefficient;
+    int filter_flags;
     Atmosphere_t atmo;
 } ShotProps_t;
 
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/rk4_engine.pyx b/py_ballisticcalc.exts/py_ballisticcalc_exts/rk4_engine.pyx
@@ -55,7 +55,7 @@ cdef class CythonizedRK4IntegrationEngine(CythonizedBaseIntegrationEngine):
         """Calculate the step size for integration."""
         return self.DEFAULT_TIME_STEP * CythonizedBaseIntegrationEngine.get_calc_step(self)
 
-    cdef object _integrate(CythonizedRK4IntegrationEngine self,
+    cdef object _integrate(CythonizedRK4IntegrationEngine self, ShotProps_t *shot_props_ptr,
                            double range_limit_ft, double range_step_ft,
                            double time_step, int filter_flags):
         """
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/trajectory_data.pxd b/py_ballisticcalc.exts/py_ballisticcalc_exts/trajectory_data.pxd
@@ -23,9 +23,6 @@ cdef extern from "include/bclib.h":
         V3dT velocity
         double mach
 
-# aliases
-# ctypedef BaseTrajDataT BaseTrajData # temporary undeclared
-
 # Ensure signature places 'nogil' at the end to match Cython's recommendation
 cdef double lagrange_quadratic(double x, double x0, double y0, double x1, double y1, double x2, double y2) except -1.0 nogil
 
@@ -36,7 +33,7 @@ cdef class BaseTrajDataT:
         readonly V3dT velocity
         readonly double mach
 
-cdef class TrajectoryData:
+cdef class TrajectoryDataT:
     cdef:
         readonly double time
         readonly object distance
@@ -55,5 +52,8 @@ cdef class TrajectoryData:
         readonly object ogw
         readonly int flag
 
+    # @staticmethod
+    # cdef from_BaseTrajDataT(BaseTrajDataT base_data)
+
 # Factory helper exposed for use from other Cython modules
 cdef BaseTrajDataT BaseTrajDataT_create(double time, V3dT position, V3dT velocity, double mach)
diff --git a/py_ballisticcalc.exts/py_ballisticcalc_exts/trajectory_data.pyx b/py_ballisticcalc.exts/py_ballisticcalc_exts/trajectory_data.pyx
@@ -143,15 +143,15 @@ cdef BaseTrajDataT BaseTrajDataT_create(double time, V3dT position, V3dT velocit
     return BaseTrajDataT(time, position, velocity, mach)
 
 @final
-cdef class TrajectoryData:
+cdef class TrajectoryDataT:
     __slots__ = ('time', 'distance', 'velocity',
                  'mach', 'height', 'slant_height', 'drop_adj',
                  'windage', 'windage_adj', 'slant_distance',
                  'angle', 'density_ratio', 'drag', 'energy', 'ogw', 'flag')
 
     _fields = __slots__
 
-    def __cinit__(TrajectoryData self,
+    def __cinit__(TrajectoryDataT self,
                     double time,
                     object distance,
                     object velocity,
@@ -191,7 +191,7 @@ cdef class TrajectoryData:
         """Create a TrajectoryData instance from a BaseTrajData object."""
         cdef double velocity_mag = mag(&data.velocity)
         
-        return TrajectoryData(
+        return TrajectoryDataT(
             time=data.time,
             distance=_new_feet(data.position.x),
             velocity=_new_fps(velocity_mag),
@@ -212,7 +212,7 @@ cdef class TrajectoryData:
     
     @staticmethod
     def interpolate(str key_attribute, double key_value,
-                   TrajectoryData t0, TrajectoryData t1, TrajectoryData t2, int flag):
+                   TrajectoryDataT t0, TrajectoryDataT t1, TrajectoryDataT t2, int flag):
         """
         Quadratic (Lagrange) interpolation of a TrajectoryData point.
         
@@ -263,14 +263,14 @@ cdef class TrajectoryData:
         energy = _new_ft_lb(interp_scalar(t0.energy._ft_lb, t1.energy._ft_lb, t2.energy._ft_lb))
         ogw = _new_lb(interp_scalar(t0.ogw._lb, t1.ogw._lb, t2.ogw._lb))
         
-        return TrajectoryData(
+        return TrajectoryDataT(
             time, distance, velocity, mach,
             height, slant_height, drop_adj,
             windage, windage_adj, slant_distance,
             angle, density_ratio, drag, energy, ogw, flag
         )
 
-    def formatted(TrajectoryData self) -> tuple[str, ...]:
+    def formatted(TrajectoryDataT self) -> tuple[str, ...]:
         """
         :return: matrix of formatted strings for each value of trajectory in default prefer_units
         """
@@ -300,7 +300,7 @@ cdef class TrajectoryData:
             f"{self.flag}"  # TODO: fix flag.name
         )
 
-    def in_def_units(TrajectoryData self) -> tuple[float, ...]:
+    def in_def_units(TrajectoryDataT self) -> tuple[float, ...]:
         """
         :return: matrix of floats of the trajectory in default prefer_units
         """
diff --git a/py_ballisticcalc.exts/tests/test_cbase_traj_seq.py b/py_ballisticcalc.exts/tests/test_cbase_traj_seq.py
@@ -26,9 +26,7 @@ def test_interpolate_bounds_checks():
 
     # Error cases: out-of-range or no neighbors
     with pytest.raises(IndexError):
-        seq.interpolate_at(0, "time", 0.5)
-    with pytest.raises(IndexError):
-        seq.interpolate_at(2, "time", 1.5)
+        seq.interpolate_at(3, "time", 1.5)
 
 
 def test_append_and_len_and_getitem():
diff --git a/py_ballisticcalc.exts/tests/test_import_cython_modules.py b/py_ballisticcalc.exts/tests/test_import_cython_modules.py
@@ -1,11 +1,6 @@
 import importlib
 
 
-def test_import_py_ballisticcalc_exts_package():
-    m = importlib.import_module("py_ballisticcalc_exts")
-    assert hasattr(m, "TrajectoryData")
-
-
 def test_import_individual_extensions():
     # Ensure compiled modules are loadable and expose expected symbols
     base = importlib.import_module("py_ballisticcalc_exts.base_traj_seq")
@@ -17,5 +12,5 @@ def test_import_individual_extensions():
     rk4 = importlib.import_module("py_ballisticcalc_exts.rk4_engine")
     assert hasattr(rk4, "CythonizedRK4IntegrationEngine")
 
-    tdata = importlib.import_module("py_ballisticcalc_exts.trajectory_data")
-    assert hasattr(tdata, "TrajectoryData")
+    # tdata = importlib.import_module("py_ballisticcalc_exts.trajectory_data")
+    # assert hasattr(tdata, "TrajectoryDataT")
diff --git a/py_ballisticcalc/engines/base_engine.py b/py_ballisticcalc/engines/base_engine.py
@@ -410,7 +410,7 @@ def _find_max_range(self, props: ShotProps, angle_bracket_deg: Tuple[float, floa
         Internal function to find the maximum slant range via golden-section search.
 
         Args:
-            props (_ShotProps): The shot information: gun, ammo, environment, look_angle.
+            props (ShotProps): The shot information: gun, ammo, environment, look_angle.
             angle_bracket_deg (Tuple[float, float], optional): The angle bracket in degrees to search for max range.
                                                                Defaults to (0, 90).
 
@@ -505,7 +505,7 @@ def _find_apex(self, props: ShotProps) -> TrajectoryData:
         Internal implementation to find the apex of the trajectory.
 
         Args:
-            props (_ShotProps): The shot properties.
+            props (ShotProps): The shot properties.
 
         Returns:
             TrajectoryData at the trajectory's apex (where velocity.y goes from positive to negative).            
@@ -528,7 +528,7 @@ def _init_zero_calculation(self, props: ShotProps, distance: Distance) -> ZeroFi
             Handles edge cases.
 
         Args:
-            props (_ShotProps): The shot information, with look_angle to the target.
+            props (ShotProps): The shot information, with look_angle to the target.
             distance (Distance): The slant distance to the target.
 
         Returns:
@@ -581,7 +581,7 @@ def _find_zero_angle(self, props: ShotProps, distance: Distance, lofted: bool =
             using Ridder's method for guaranteed convergence.
 
         Args:
-            props (_ShotProps): The shot information.
+            props (ShotProps): The shot information.
             distance (Distance): The distance to the target.
             lofted (bool, optional): If True, find the higher angle that hits the zero point.
 
@@ -705,7 +705,7 @@ def _zero_angle(self, props: ShotProps, distance: Distance) -> Angular:
         Iterative algorithm to find barrel elevation needed for a particular zero
 
         Args:
-            props (_ShotProps): Shot parameters
+            props (ShotProps): Shot parameters
             distance (Distance): Sight distance to zero (i.e., along Shot.look_angle),
                                  a.k.a. slant range to target.
 
diff --git a/py_ballisticcalc/engines/scipy_engine.py b/py_ballisticcalc/engines/scipy_engine.py
@@ -209,7 +209,7 @@ def _find_max_range(self, props: ShotProps, angle_bracket_deg: Tuple[float, floa
         Finds the maximum range along the look_angle and the launch angle to reach it.
 
         Args:
-            props (_ShotProps): The shot information: gun, ammo, environment, look_angle.
+            props (ShotProps): The shot information: gun, ammo, environment, look_angle.
             angle_bracket_deg (Tuple[float, float], optional): The angle bracket in degrees to search for max range.
                                                                Defaults to (0, 90).
 
@@ -265,7 +265,7 @@ def _find_zero_angle(self, props: ShotProps, distance: Distance, lofted: bool =
             using SciPy's root_scalar.
 
         Args:
-            props (_ShotProps): The shot information.
+            props (ShotProps): The shot information.
             distance (Distance): Slant distance to the target.
             lofted (bool, optional): If True, find the higher angle that hits the zero point.
 
@@ -344,7 +344,7 @@ def _zero_angle(self, props: ShotProps, distance: Distance) -> Angular:
             Falls back on ._find_zero_angle().
 
         Args:
-            props (_ShotProps): Shot parameters
+            props (ShotProps): Shot parameters
             distance (Distance): Sight distance to zero (i.e., along Shot.look_angle),
                                  a.k.a. slant range to target.
 
