fastquadtree 1.2.3__tar.gz → 1.3.1__tar.gz

fastquadtree-1.3.1/.github/workflows/test.yml

@@ -0,0 +1,65 @@
+# .github/workflows/test.yml
+name: Test
+on:
+  push:
+    branches: [ main ]
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+jobs:
+  test:
+    name: Test build (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+          cache: "pip"
+        
+      - name: Create venv for maturin develop
+        run: python -m venv .venv
+
+      - name: Build with maturin into this Python
+        uses: PyO3/maturin-action@v1
+        with:
+          command: develop
+          args: --release
+          manylinux: manylinux2014
+
+      - name: Install Python test deps into .venv
+        run: |
+          . .venv/bin/activate
+          pip install -e '.[dev]'
+
+      - name: Run Python tests
+        run: |
+          . .venv/bin/activate
+          pytest
+
+      - name: Run Python tests
+        run: |
+          . .venv/bin/activate
+          pytest
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Run Rust tests
+        run: cargo test
+
+      - name: Upload coverage to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/Cargo.lock

@@ -30,9 +30,10 @@ dependencies = [
 
 [[package]]
 name = "fastquadtree"
-version = "1.2.3"
+version = "1.3.1"
 dependencies = [
  "bincode",
+ "num-traits",
  "numpy",
  "pyo3",
  "serde",

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fastquadtree"
-version = "1.2.3"
+version = "1.3.1"
 edition = "2021"
 readme = "README.md"
 
@@ -13,6 +13,7 @@ smallvec = "1.15.1"
 numpy = "0.26"
 serde = { version = "1.0", features = ["derive"] }
 bincode = {version = "2.0.1", features = ["serde"]}
+num-traits = "0.2"
 
 [profile.release]
 opt-level = 3

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastquadtree
-Version: 1.2.3
+Version: 1.3.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: Rust
@@ -26,6 +26,7 @@ Requires-Dist: mkdocs-minify-plugin ; extra == 'dev'
 Requires-Dist: maturin>=1.5 ; extra == 'dev'
 Requires-Dist: pyqtree==1.0.0 ; extra == 'dev'
 Requires-Dist: numpy ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
 Provides-Extra: dev
 License-File: LICENSE
 Summary: Rust-accelerated quadtree for Python with fast inserts, range queries, and k-NN search.
@@ -73,6 +74,7 @@ Rust-optimized quadtree with a clean Python API
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
 - Fast [serialization](https://elan456.github.io/fastquadtree/benchmark/#serialization-vs-rebuild) to/from bytes
+- Support for multiple data types (f32, f64, i32, i64) for coordinates
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 - Offers a drop-in [pyqtree shim](https://elan456.github.io/fastquadtree/benchmark/#pyqtree-drop-in-shim-performance-gains) that is 6.567x faster while keeping the same API
 

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/README.md

@@ -33,6 +33,7 @@ Rust-optimized quadtree with a clean Python API
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
 - Fast [serialization](https://elan456.github.io/fastquadtree/benchmark/#serialization-vs-rebuild) to/from bytes
+- Support for multiple data types (f32, f64, i32, i64) for coordinates
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 - Offers a drop-in [pyqtree shim](https://elan456.github.io/fastquadtree/benchmark/#pyqtree-drop-in-shim-performance-gains) that is 6.567x faster while keeping the same API
 

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/docs/benchmark.md

@@ -11,21 +11,20 @@ Quadtrees are the focus of the benchmark, but Rtrees are included for reference.
 ![Throughput](https://raw.githubusercontent.com/Elan456/fastquadtree/main/assets/quadtree_bench_throughput.png)
 
 ### Summary (largest dataset, PyQtree baseline)
-
 - Points: **250,000**, Queries: **500**
-- Fastest total: **fastquadtree** at **0.120 s**
+- Fastest total: **fastquadtree** at **0.100 s**
 
 | Library | Build (s) | Query (s) | Total (s) | Speed vs PyQtree |
 |---|---:|---:|---:|---:|
-| **fastquadtree** | 0.031 | 0.089 | 0.120 | **14.64×** |
-| Shapely STRtree | 0.179 | 0.100 | 0.279 | 6.29× |
-| nontree-QuadTree | 0.595 | 0.605 | 1.200 | 1.46× |
-| Rtree        | 0.961 | 0.300 | 1.261 | 1.39× |
-| e-pyquadtree | 1.005 | 0.660 | 1.665 | 1.05× |
-| PyQtree      | 1.492 | 0.263 | 1.755 | 1.00× |
-| quads        | 1.407 | 0.484 | 1.890 | 0.93× |
-
-### Benchmark Configuration
+| fastquadtree | 0.027 | 0.073 | 0.100 | 16.12× |
+| Shapely STRtree | 0.148 | 0.083 | 0.231 | 7.00× |
+| Rtree        | 0.814 | 0.245 | 1.059 | 1.53× |
+| nontree-QuadTree | 0.532 | 0.582 | 1.114 | 1.45× |
+| e-pyquadtree | 0.913 | 0.641 | 1.554 | 1.04× |
+| PyQtree      | 1.352 | 0.264 | 1.616 | 1.00× |
+| quads        | 1.231 | 0.465 | 1.695 | 0.95× |
+
+#### Benchmark Configuration
 | Parameter | Value |
 |---|---:|
 | Bounds | (0, 0, 1000, 1000) |

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/docs/future_features.md

@@ -9,27 +9,19 @@ The features will likely be implemented in the order they are listed below, but
 
 ## 🚧 Planned Features
 
-### 1. Configurable Quadtree Coordinate Type
-
-Currently, the point quadtree only uses f32 for point coordinates, limiting precision in favor of better performance.
-To make the quadtree more flexible, we could allow users to specify the coordinate type (e.g., f64, i32, etc.) when creating a quadtree.
-The f32 will remain the default, but users will be able to specify a different type if needed.
-
-If the type cannot be made truly generic, then only the following types would be supported: f32, f64, i32, i64
-
-### 2. KNN with criteria function
+### 1. KNN with criteria function
 
 Currently, KNN only supports finding the nearest neighbors based on euclidean distance.
 By adding a criteria function, we could allow users to define custom criteria for finding neighbors by passing a function that 
 takes in a point and returns a score. The KNN algorithm would then use this score to determine the nearest neighbors.
 
-### 3. KNN in rectangle quadtree
+### 2. KNN in rectangle quadtree
 
 Currently, KNN is only supported in the point quadtree. By adding KNN support to the rectangle quadtree, we could allow users to find the nearest rectangles to a given point. This would be to the nearest edge of the rectangle, adding complexity to the algorithm.
 However, it will allow for really quick collision detection between a point and a set of rectangles as the point can just do
 robust-collision handling with the nearest rectangles.
 
-### 4. Circle support
+### 3. Circle support
 
 Currently, we support points and rectangles in two separate quadtrees.
 For example, in the ball-pit demo, we use a point quadtree, but then query a larger area to account for the radius of the balls.
@@ -41,6 +33,15 @@ A good alternative is to use the rectangle quadtree and insert the minimum bound
 
 Once a feature from above is completed, it will be moved to this section.
 
-### Quadtree serialization
+
+### Configurable Quadtree Coordinate Type (1.3.0)
+
+Currently, the point quadtree only uses f32 for point coordinates, limiting precision in favor of better performance.
+To make the quadtree more flexible, we could allow users to specify the coordinate type (e.g., f64, i32, etc.) when creating a quadtree.
+The f32 will remain the default, but users will be able to specify a different type if needed.
+
+If the type cannot be made truly generic, then only the following types would be supported: f32, f64, i32, i64
+
+### Quadtree serialization (1.2.0)
 
 By serializing the quadtree, we can save its state to a file and load it later. This will allow us to persist the quadtree structure and data across sessions. For example, you could pre build a quadtree with all the walls in your video game level, serialize it to a file, and then load it when the game starts. This will heavily reduce the game load time since you won't have to rebuild the quadtree from scratch every time.

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/docs/index.md

@@ -42,6 +42,7 @@
 - Fast KNN and range queries
 - Optional object tracking for id ↔ object mapping
 - Fast [serialization](benchmark.md#serialization-vs-rebuild) to/from bytes
+- Support for multiple data types (f32, f64, i32, i64) for coordinates
 - [100% test coverage](https://codecov.io/gh/Elan456/fastquadtree) and CI on GitHub Actions
 
 ## Examples

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/interactive/ballpit.py

@@ -246,7 +246,7 @@ def main():
 
     running = True
     while running:
-        dt_ms = clock.tick(60)  # target 60 fps
+        dt_ms = clock.tick(200)  # target 200 FPS
         dt = dt_ms / 1000.0
 
         for event in pygame.event.get():

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/pyproject.toml

@@ -80,6 +80,7 @@ dev = [
   "maturin>=1.5",  # build Rust wheels
   "pyqtree==1.0.0", # for comparison in tests
   "numpy",
+  "pre-commit",
 ]
 
 [tool.ruff]

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/pysrc/fastquadtree/_base_quadtree.py

@@ -29,6 +29,14 @@ G = TypeVar("G")  # geometry type, e.g. Point or Bounds
 HitT = TypeVar("HitT")  # raw native tuple, e.g. (id,x,y) or (id,x0,y0,x1,y1)
 ItemType = TypeVar("ItemType", bound=Item)  # e.g. PointItem or RectItem
 
+# Quadtree dtype to numpy dtype mapping
+QUADTREE_DTYPE_TO_NP_DTYPE = {
+    "f32": "float32",
+    "f64": "float64",
+    "i32": "int32",
+    "i64": "int64",
+}
+
 
 def _is_np_array(x: Any) -> bool:
     mod = getattr(x.__class__, "__module__", "")
@@ -48,6 +56,7 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         "_bounds",
         "_capacity",
         "_count",
+        "_dtype",
         "_max_depth",
         "_native",
         "_next_id",
@@ -62,7 +71,7 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         """Create the native engine instance."""
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str) -> Any:
         """Create the native engine instance from serialized bytes."""
 
     @staticmethod
@@ -79,10 +88,12 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         self._bounds = bounds
         self._max_depth = max_depth
         self._capacity = capacity
+        self._dtype = dtype
         self._native = self._new_native(bounds, capacity, max_depth)
 
         self._track_objects = bool(track_objects)
@@ -138,12 +149,13 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         return pickle.dumps(self.to_dict())
 
     @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
+    def from_bytes(cls, data: bytes, dtype: str = "f32") -> Self:
         """
-        Deserialize a quadtree from bytes.
+        Deserialize a quadtree from bytes. Specifiy the dtype if the original tree that was serialized used a non-default dtype.
 
         Args:
             data: Bytes representing the serialized quadtree from `to_bytes()`.
+            dtype: The data type used in the native engine ('f32', 'f64', 'i32', 'i64') when saved to bytes.
 
         Returns:
             A new quadtree instance with the same state as when serialized.
@@ -160,7 +172,15 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
         store_dict = in_dict["store"]
 
         qt = cls.__new__(cls)  # type: ignore[call-arg]
-        qt._native = cls._new_native_from_bytes(core_bytes)
+        try:
+            qt._native = cls._new_native_from_bytes(core_bytes, dtype=dtype)
+        except ValueError as ve:
+            raise ValueError(
+                "Failed to deserialize quadtree native core. "
+                "This may be due to a dtype mismatch. "
+                "Ensure the dtype used in from_bytes() matches the original tree. "
+                "Error details: " + str(ve)
+            ) from ve
 
         if store_dict is not None:
             qt._store = ObjStore.from_dict(store_dict, qt._make_item)
@@ -238,7 +258,7 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
     ) -> int:
         """
         Bulk insert with auto-assigned contiguous ids. Faster than inserting one-by-one.<br>
-        Can accept either a Python sequence of geometries or a NumPy array of shape (N,2) or (N,4) with dtype float32.
+        Can accept either a Python sequence of geometries or a NumPy array of shape (N,2) or (N,4) with a dtype that matches the quadtree's dtype.
 
         If tracking is enabled, the objects will be bulk stored internally.
         If no objects are provided, the items will have obj=None (if tracking).
@@ -277,8 +297,12 @@ class _BaseQuadTree(Generic[G, HitT, ItemType], ABC):
             if geoms.size == 0:
                 return 0
 
-            if geoms.dtype != _np.float32:
-                raise TypeError("Numpy array must use dtype float32")
+            # Check if dtype matches quadtree dtype
+            expected_np_dtype = QUADTREE_DTYPE_TO_NP_DTYPE.get(self._dtype)
+            if geoms.dtype != expected_np_dtype:
+                raise TypeError(
+                    f"Numpy array dtype {geoms.dtype} does not match quadtree dtype {self._dtype}"
+                )
 
         if self._store is None:
             # Simple contiguous path with native bulk insert

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/pysrc/fastquadtree/point_quadtree.py

@@ -5,10 +5,17 @@ from typing import Any, Literal, Tuple, overload
 
 from ._base_quadtree import Bounds, _BaseQuadTree
 from ._item import Point, PointItem
-from ._native import QuadTree as _RustQuadTree  # native point tree
+from ._native import QuadTree as QuadTreeF32, QuadTreeF64, QuadTreeI32, QuadTreeI64
 
 _IdCoord = Tuple[int, float, float]
 
+DTYPE_MAP = {
+    "f32": QuadTreeF32,
+    "f64": QuadTreeF64,
+    "i32": QuadTreeI32,
+    "i64": QuadTreeI64,
+}
+
 
 class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
     """
@@ -29,6 +36,7 @@ class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
         capacity: Max number of points per node before splitting.
         max_depth: Optional max tree depth. If omitted, engine decides.
         track_objects: Enable id <-> object mapping inside Python.
+        dtype: Data type for coordinates and ids in the native engine. Default is 'f32'. Options are 'f32', 'f64', 'i32', 'i64'.
 
     Raises:
         ValueError: If parameters are invalid or inserts are out of bounds.
@@ -41,12 +49,14 @@ class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         super().__init__(
             bounds,
             capacity,
             max_depth=max_depth,
             track_objects=track_objects,
+            dtype=dtype,
         )
 
     @overload
@@ -148,14 +158,19 @@ class QuadTree(_BaseQuadTree[Point, _IdCoord, PointItem]):
         return out
 
     def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> Any:
-        if max_depth is None:
-            return _RustQuadTree(bounds, capacity)
-        return _RustQuadTree(bounds, capacity, max_depth=max_depth)
+        """Create the native engine instance."""
+        rust_cls = DTYPE_MAP.get(self._dtype)
+        if rust_cls is None:
+            raise TypeError(f"Unsupported dtype: {self._dtype}")
+        return rust_cls(bounds, capacity, max_depth)
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str = "f32") -> Any:
         """Create a new native engine instance from serialized bytes."""
-        return _RustQuadTree.from_bytes(data)
+        rust_cls = DTYPE_MAP.get(dtype)
+        if rust_cls is None:
+            raise TypeError(f"Unsupported dtype: {dtype}")
+        return rust_cls.from_bytes(data)
 
     @staticmethod
     def _make_item(id_: int, geom: Point, obj: Any | None) -> PointItem:

{fastquadtree-1.2.3 → fastquadtree-1.3.1}/pysrc/fastquadtree/rect_quadtree.py

@@ -5,10 +5,21 @@ from typing import Any, Literal, Tuple, overload
 
 from ._base_quadtree import Bounds, _BaseQuadTree
 from ._item import RectItem
-from ._native import RectQuadTree as _RustRectQuadTree  # native rect tree
+from ._native import (
+    RectQuadTree as RectQuadTreeF32,
+    RectQuadTreeF64,
+    RectQuadTreeI32,
+    RectQuadTreeI64,
+)
 
 _IdRect = Tuple[int, float, float, float, float]
-Point = Tuple[float, float]  # only for type hints in docstrings
+
+DTYPE_MAP = {
+    "f32": RectQuadTreeF32,
+    "f64": RectQuadTreeF64,
+    "i32": RectQuadTreeI32,
+    "i64": RectQuadTreeI64,
+}
 
 
 class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
@@ -30,6 +41,7 @@ class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
         capacity: Max number of points per node before splitting.
         max_depth: Optional max tree depth. If omitted, engine decides.
         track_objects: Enable id <-> object mapping inside Python.
+        dtype: Data type for coordinates and ids in the native engine. Default is 'f32'. Options are 'f32', 'f64', 'i32', 'i64'.
 
     Raises:
         ValueError: If parameters are invalid or inserts are out of bounds.
@@ -42,12 +54,14 @@ class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
         *,
         max_depth: int | None = None,
         track_objects: bool = False,
+        dtype: str = "f32",
     ):
         super().__init__(
             bounds,
             capacity,
             max_depth=max_depth,
             track_objects=track_objects,
+            dtype=dtype,
         )
 
     @overload
@@ -84,14 +98,19 @@ class RectQuadTree(_BaseQuadTree[Bounds, _IdRect, RectItem]):
         return self._store.get_many_by_ids(self._native.query_ids(rect))
 
     def _new_native(self, bounds: Bounds, capacity: int, max_depth: int | None) -> Any:
-        if max_depth is None:
-            return _RustRectQuadTree(bounds, capacity)
-        return _RustRectQuadTree(bounds, capacity, max_depth=max_depth)
+        """Create the native engine instance."""
+        rust_cls = DTYPE_MAP.get(self._dtype)
+        if rust_cls is None:
+            raise TypeError(f"Unsupported dtype: {self._dtype}")
+        return rust_cls(bounds, capacity, max_depth)
 
     @classmethod
-    def _new_native_from_bytes(cls, data: bytes) -> Any:
+    def _new_native_from_bytes(cls, data: bytes, dtype: str = "f32") -> Any:
         """Create a new native engine instance from serialized bytes."""
-        return _RustRectQuadTree.from_bytes(data)
+        rust_cls = DTYPE_MAP.get(dtype)
+        if rust_cls is None:
+            raise TypeError(f"Unsupported dtype: {dtype}")
+        return rust_cls.from_bytes(data)
 
     @staticmethod
     def _make_item(id_: int, geom: Bounds, obj: Any | None) -> RectItem:

fastquadtree-1.3.1/src/geom.rs

@@ -0,0 +1,73 @@
+use core::ops::{Add, Sub, Mul, Div};
+use num_traits::{Zero, One};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+
+// Creating a set of traits for coordinate types
+// Requires basic arithmetic operations and ordering
+pub trait Coord:
+    Copy + PartialOrd + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> + Div<Output = Self> + Zero + One + Serialize + DeserializeOwned
+{}
+
+impl<T> Coord for T where
+    T: Copy + PartialOrd + Add<Output = Self> + Sub<Output = Self> + Mul<Output = Self> + Div<Output = Self> + Zero + One + Serialize + DeserializeOwned
+{}
+
+// Generic mid function for all Coord types
+#[inline(always)]
+pub fn mid<T: Coord>(a: T, b: T) -> T {
+    // a + (b - a) / 2
+    a + (b - a) / (T::one() + T::one())  // 1 + 1 = 2 for Div
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+#[serde(bound(serialize = "", deserialize = ""))]
+pub struct Point<T: Coord> {
+    pub x: T,
+    pub y: T,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+#[serde(bound(serialize = "", deserialize = ""))]
+pub struct Rect<T: Coord> {
+    pub min_x: T,
+    pub min_y: T,
+    pub max_x: T,
+    pub max_y: T,
+}
+
+impl<T: Coord> Rect<T> {
+    pub fn contains(&self, point: &Point<T>) -> bool {
+        return point.x >= self.min_x && point.x < self.max_x && point.y >= self.min_y && point.y < self.max_y;
+    }
+
+    // Check if two Rect overlap at all
+    pub fn intersects(&self, other: &Rect<T>) -> bool {
+        return self.min_x < other.max_x && self.max_x > other.min_x && self.min_y < other.max_y && self.max_y > other.min_y
+    }
+}
+
+pub fn dist_sq_point_to_rect<T: Coord>(p: &Point<T>, r: &Rect<T>) -> T {
+    let dx = if p.x < r.min_x {
+        r.min_x - p.x
+    } else if p.x > r.max_x {
+        p.x - r.max_x
+    } else {
+        T::zero()
+    };
+
+    let dy = if p.y < r.min_y {
+        r.min_y - p.y
+    } else if p.y > r.max_y {
+        p.y - r.max_y
+    } else {
+        T::zero()
+    };
+
+    dx * dx + dy * dy
+}
+
+pub fn dist_sq_points<T: Coord>(a: &Point<T>, b: &Point<T>) -> T {
+    let dx = a.x - b.x;
+    let dy = a.y - b.y;
+    dx * dx + dy * dy
+}