WIP: Debugging Cython zero functionality

Author: dbookstaber

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',
 )

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)
 
 

py_ballisticcalc.exts/py_ballisticcalc_exts/base_engine.pyx

@@ -1,28 +1,10 @@
 """
 Header file for base_traj_seq.pyx - C Buffer Trajectory Sequence
-
-Notes and conventions (keep in sync with base_traj_seq.pyx):
-- This .pxd is authoritative for C-level declarations shared across Cython
-  modules. Avoid redeclaring enums, structs or function prototypes in the
-  corresponding .pyx files; duplicating declarations can cause "redeclared"
-  errors during editable installs or when Cython regenerates sources.
-- Nogil helpers are declared here with explicit exception sentinels so that
-  callers know the sentinel value used when the function is invoked without
-  the GIL.  Conventions used in this module:
-    * pointer-returning functions: use `except NULL nogil` (return NULL on error)
-    * bint-returning try-style helpers: use `except False nogil` (return False on error)
-    * append-style functions that cannot fail at the C level are marked `noexcept nogil`
-- The quadratic Lagrange interpolation used by the nogil core is currently
-  inlined in the implementation to avoid cross-module nogil call-site
-  diagnostics; a future refactor could move this math into a shared C
-  header and declare a pure-C helper here.
 """
 
 from libc.stddef cimport size_t
-# cimport BaseTrajDataT and interpolation helper
 from py_ballisticcalc_exts.trajectory_data cimport BaseTrajDataT
 
-# Include BaseTrajC struct definition from header file
 cdef extern from "include/basetraj_seq.h" nogil:
     ctypedef struct BaseTrajC:
         double time
@@ -34,8 +16,6 @@ cdef extern from "include/basetraj_seq.h" nogil:
         double vz
         double mach
 
-# Public enum for interpolation keys; exposed at module-level so .pyx can
-# reference it for nogil helpers.
 cdef class CBaseTrajSeq:
   cdef:
     BaseTrajC* _buffer

py_ballisticcalc.exts/py_ballisticcalc_exts/base_traj_seq.pxd

@@ -5,7 +5,7 @@ This module provides:
     - CBaseTrajSeq: a contiguous C buffer of BaseTrajC items with append/reserve access.
     - Quadratic Lagrange interpolation on the raw buffer without allocating Python objects.
     - Convenience methods to locate and interpolate a point by an independent variable
-        (time, mach, position.{x,y,z}, velocity.{x,y,z}) and slant height.
+        (time, mach, position.{x,y,z}, velocity.{x,y,z}) and slant_height.
 
 Design note: nogil helpers operate on a tiny C struct view of the sequence to avoid
     passing Python cdef-class instances into nogil code paths.
@@ -47,10 +47,29 @@ ctypedef struct _CBaseTrajSeq_cview:
 
 __all__ = ['CBaseTrajSeq', 'BaseTrajC']
 
+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:
+        return p.mach
+    elif key_kind == <int>KEY_POS_X:
+        return p.px
+    elif key_kind == <int>KEY_POS_Y:
+        return p.py
+    elif key_kind == <int>KEY_POS_Z:
+        return p.pz
+    elif key_kind == <int>KEY_VEL_X:
+        return p.vx
+    elif key_kind == <int>KEY_VEL_Y:
+        return p.vy
+    elif key_kind == <int>KEY_VEL_Z:
+        return p.vz
+    return <double>0.0
+
 
 # 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:
-    """Interpolate at idx using points (idx-1, idx, idx+1) keyed by key_kind at key_value."""
+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), computing new BaseTrajC where out.key_kind==key_value."""
     cdef BaseTrajC* buffer = seq._buffer
     cdef Py_ssize_t plength = <Py_ssize_t> seq._length
     cdef BaseTrajC *p0
@@ -124,29 +143,11 @@ 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:
-    if key_kind == <int>KEY_TIME:
-        return p.time
-    elif key_kind == <int>KEY_MACH:
-        return p.mach
-    elif key_kind == <int>KEY_POS_X:
-        return p.px
-    elif key_kind == <int>KEY_POS_Y:
-        return p.py
-    elif key_kind == <int>KEY_POS_Z:
-        return p.pz
-    elif key_kind == <int>KEY_VEL_X:
-        return p.vx
-    elif key_kind == <int>KEY_VEL_Y:
-        return p.vy
-    elif key_kind == <int>KEY_VEL_Z:
-        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:
+    """Computes the slant_height of a trajectory point `p` given cosine `ca` and sine `sa` of look_angle."""
     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 +177,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)
@@ -208,9 +209,9 @@ cdef Py_ssize_t _bisect_center_idx_slant_buf(BaseTrajC* buf, size_t length, doub
 
 
 cdef class CBaseTrajSeq:
-    """Contiguous C buffer of BaseTrajC with fast append and interpolation.
+    """Contiguous C buffer of BaseTrajC points with fast append and interpolation.
 
-    Python-facing access returns lightweight BaseTrajDataT objects; internal
+    Python-facing access lazily creates lightweight BaseTrajDataT objects; internal
         nogil helpers work directly on the C buffer for speed.
     """
     def __cinit__(self):
@@ -282,8 +283,8 @@ cdef class CBaseTrajSeq:
         """Number of points in the sequence."""
         return <Py_ssize_t> self._length
 
-    def __getitem__(self, idx):
-        """Return BaseTrajDataT for the given index (supports negative indices)."""
+    def __getitem__(self, idx: int) -> BaseTrajDataT:
+        """Return BaseTrajDataT for the given index.  Supports negative indices."""
         cdef V3dT position
         cdef V3dT velocity
         cdef BaseTrajC* entry_ptr
@@ -350,12 +351,12 @@ cdef class CBaseTrajSeq:
         """Interpolate using points (idx-1, idx, idx+1) keyed by key_attribute at key_value."""
         return self._interpolate_at_c(idx, key_attribute, key_value)
 
-    def get_at(self, str key_attribute, double key_value, start_from=None, start_from_time=None):
-        """Get BaseTrajDataT where key_attribute == key_value (quadratic interpolation).
+    def get_at(self, str key_attribute, double key_value, start_from_time=None):
+        """Get BaseTrajDataT where key_attribute == key_value (via quadratic interpolation).
 
         If start_from_time > 0, search is centered from the first point where time >= start_from_time,
         and proceeds forward or backward depending on local direction, mirroring
-        trajectory_data.HitResult.get_at.
+        trajectory_data.HitResult.get_at().
         """
         cdef int key_kind
         cdef Py_ssize_t n
@@ -399,8 +400,6 @@ cdef class CBaseTrajSeq:
         sft = <double>0.0
         if start_from_time is not None:
             sft = <double>float(start_from_time)
-        elif start_from is not None:
-            sft = <double>float(start_from)
         if sft > <double>0.0 and key_kind != <int>KEY_TIME:
             buf = self._buffer
             start_idx = <Py_ssize_t>0

py_ballisticcalc.exts/py_ballisticcalc_exts/base_traj_seq.pyx

@@ -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)

py_ballisticcalc.exts/py_ballisticcalc_exts/cy_bindings.pxd

@@ -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):
         """

py_ballisticcalc.exts/py_ballisticcalc_exts/euler_engine.pyx

@@ -80,6 +80,7 @@ typedef struct {
     double calc_step;
     double muzzle_velocity;
     double stability_coefficient;
+    int filter_flags;
     Atmosphere_t atmo;
 } ShotProps_t;
 

py_ballisticcalc.exts/py_ballisticcalc_exts/include/bclib.h

@@ -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):
         """

py_ballisticcalc.exts/py_ballisticcalc_exts/rk4_engine.pyx

@@ -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)