Fix intersection bug and add Python 3.13 support (v0.7.0)

BREAKING CHANGES:
- Changed internal Real type from float to double to fix precision bug
- Binary serialization format changed (incompatible with v0.6.x)
- Updated pybind11 from v2.12.0 to v2.13.6

Bug Fix:
- Fixed critical bug where boxes with small gaps (< 1e-5) were incorrectly
  reported as intersecting due to float32 precision loss
- Root cause: PRTree constructor and insert method were using py::array_t<float>
  instead of py::array_t<Real>, causing float64 -> float32 conversion
- Example: boxes separated by 5.39e-06 would collapse to same float32 value

Changes:
- cpp/prtree.h: Changed 'using Real = float' to 'using Real = double'
- cpp/prtree.h: Updated PRTree constructor to use py::array_t<Real>
- cpp/prtree.h: Updated insert method to use py::array_t<Real>
- cpp/main.cc: Updated all pybind11 bindings to use py::array_t<double>
- third/pybind11: Updated submodule from v2.12.0 to v2.13.6
- setup.py: Bumped version to v0.7.0, added Python 3.13 support
- requirements.txt: Removed numpy<2.0 constraint for numpy 2.0 support
- .github/workflows/cibuildwheel.yml: Added Python 3.13 builds
- README.md: Added breaking changes notice and bug fix details
- tests/test_PRTree.py: Added comprehensive tests for:
  - Disjoint boxes with small gaps (regression test)
  - Touching boxes (closed interval semantics)
  - Large magnitude coordinates
  - Degenerate boxes
  - Query vs batch_query consistency

All 121 tests pass.

Fixes issue reported by Matteo Lacki.

Co-Authored-By: atksh <[email protected]>

Author: devin-ai-integration[bot]

.github/workflows/cibuildwheel.yml

@@ -51,6 +51,10 @@ jobs:
             python: 312
             platform_id: win_amd64
             arch: AMD64
+          - os: windows-latest
+            python: 313
+            platform_id: win_amd64
+            arch: AMD64
 
           # Linux 64 bit manylinux2014
           - os: ubuntu-latest
@@ -88,6 +92,11 @@ jobs:
             platform_id: manylinux_x86_64
             manylinux_image: manylinux2014
             arch: x86_64
+          - os: ubuntu-latest
+            python: 313
+            platform_id: manylinux_x86_64
+            manylinux_image: manylinux2014
+            arch: x86_64
 
           # Linux 64 bit aarch64
           - os: ubuntu-latest
@@ -125,6 +134,11 @@ jobs:
             platform_id: manylinux_aarch64
             manylinux_image: manylinux2014
             arch: aarch64
+          - os: ubuntu-latest
+            python: 313
+            platform_id: manylinux_aarch64
+            manylinux_image: manylinux2014
+            arch: aarch64
 
           # MacOS x86_64
           - os: macos-13
@@ -162,6 +176,11 @@ jobs:
             platform_id: macosx_x86_64
             macosx_deployment_target: 10.14
             arch: x86_64
+          - os: macos-13
+            python: 313
+            platform_id: macosx_x86_64
+            macosx_deployment_target: 10.14
+            arch: x86_64
 
           # MacOS arm64
           - os: macos-14
@@ -189,6 +208,11 @@ jobs:
             platform_id: macosx_arm64
             macosx_deployment_target: 11.7
             arch: arm64
+          - os: macos-14
+            python: 313
+            platform_id: macosx_arm64
+            macosx_deployment_target: 11.7
+            arch: arm64
 
 
     steps:

README.md

@@ -174,6 +174,20 @@ Note that cross-version compatibility is **NOT** guaranteed, so please reconstru
 
 ## New Features and Changes
 
+### `python-prtree>=0.7.0`
+
+**BREAKING CHANGES:**
+
+- **Fixed critical intersection bug**: Boxes with small gaps (< 1e-5) were incorrectly reported as intersecting due to float32 precision loss. The internal `Real` type has been changed from `float` to `double` to preserve float64 precision from NumPy arrays.
+- **Serialization format changed**: Binary files saved with previous versions are incompatible with 0.7.0+. You must rebuild and re-save your trees after upgrading.
+- **Updated pybind11**: Upgraded from v2.12.0 to v2.13.6 for Python 3.13+ support.
+- **Python 3.13 support**: Added official support for Python 3.13.
+- **Improved test coverage**: Added comprehensive tests for edge cases including disjoint boxes with small gaps, touching boxes, large magnitude coordinates, and degenerate boxes.
+
+**Bug Fix Details:**
+
+The bug occurred when two bounding boxes were separated by a very small gap (e.g., 5.39e-06). When converted from float64 to float32, the values would collapse to the same float32 value, causing the intersection check to incorrectly report them as intersecting. This has been fixed by using double precision throughout the library.
+
 ### `python-prtree>=0.5.8`
 
 - The insert method has been improved to select the node with the smallest mbb expansion.

cpp/main.cc

@@ -18,7 +18,7 @@ PYBIND11_MODULE(PRTree, m)
     )pbdoc";
 
   py::class_<PRTree<T, B, 2>>(m, "_PRTree2D")
-      .def(py::init<py::array_t<T>, py::array_t<float>>(), R"pbdoc(
+      .def(py::init<py::array_t<T>, py::array_t<double>>(), R"pbdoc(
           Construct PRTree with init.
         )pbdoc")
       .def(py::init<>(), R"pbdoc(
@@ -62,7 +62,7 @@ PYBIND11_MODULE(PRTree, m)
         )pbdoc");
 
   py::class_<PRTree<T, B, 3>>(m, "_PRTree3D")
-      .def(py::init<py::array_t<T>, py::array_t<float>>(), R"pbdoc(
+      .def(py::init<py::array_t<T>, py::array_t<double>>(), R"pbdoc(
           Construct PRTree with init.
         )pbdoc")
       .def(py::init<>(), R"pbdoc(
@@ -106,7 +106,7 @@ PYBIND11_MODULE(PRTree, m)
         )pbdoc");
 
   py::class_<PRTree<T, B, 4>>(m, "_PRTree4D")
-      .def(py::init<py::array_t<T>, py::array_t<float>>(), R"pbdoc(
+      .def(py::init<py::array_t<T>, py::array_t<double>>(), R"pbdoc(
           Construct PRTree with init.
         )pbdoc")
       .def(py::init<>(), R"pbdoc(

cpp/prtree.h

@@ -44,7 +44,7 @@
 #include <gperftools/profiler.h>
 #endif
 
-using Real = float;
+using Real = double;
 
 namespace py = pybind11;
 
@@ -790,7 +790,7 @@ class PRTree
 
   PRTree(std::string fname) { load(fname); }
 
-  PRTree(const py::array_t<T> &idx, const py::array_t<float> &x)
+  PRTree(const py::array_t<T> &idx, const py::array_t<Real> &x)
   {
     const auto &buff_info_idx = idx.request();
     const auto &shape_idx = buff_info_idx.shape;
@@ -869,7 +869,7 @@ class PRTree
     return obj;
   }
 
-  void insert(const T &idx, const py::array_t<float> &x, const std::optional<std::string> objdumps = std::nullopt)
+  void insert(const T &idx, const py::array_t<Real> &x, const std::optional<std::string> objdumps = std::nullopt)
   {
 #ifdef MY_DEBUG
     ProfilerStart("insert.prof");

requirements.txt

@@ -1 +1 @@
-numpy>=1.16,<2.0
+numpy>=1.16

setup.py

@@ -9,7 +9,7 @@
 from setuptools import Extension, find_packages, setup
 from setuptools.command.build_ext import build_ext
 
-version = "v0.6.1"
+version = "v0.7.0"
 
 sys.path.append("./tests")
 
@@ -114,5 +114,6 @@ def build_extension(self, ext):
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
     ],
 )

tests/test_PRTree.py

@@ -168,3 +168,126 @@ def test_readme():
     # point query
     assert prtree.query([0.5, 0.5]) == [1]
     assert prtree.query(0.5, 0.5) == [1]
+
+
+@pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+def test_disjoint_small_gap(PRTree, dim):
+    """Test for the bug reported by Matteo Lacki where boxes with small gaps are incorrectly reported as intersecting.
+    
+    This was caused by float32 precision loss where values like 75.02750896 and 75.02751435
+    would collapse to the same float32 value (75.02751159667968750000).
+    """
+    if dim == 2:
+        A = np.array([[72.47410062, 80.52848893, 75.02750896, 85.40646976]])
+        B = np.array([[75.02751435, 80.0, 78.71358218, 85.0]])
+        gap_dim = 0
+    elif dim == 3:
+        A = np.array([[72.47410062, 80.52848893, 54.68197159, 75.02750896, 85.40646976, 62.42859506]])
+        B = np.array([[75.02751435, 74.65699325, 61.09751679, 78.71358218, 82.4585436, 67.24904609]])
+        gap_dim = 0
+    else:  # dim == 4
+        A = np.array([[72.47410062, 80.52848893, 54.68197159, 60.0, 75.02750896, 85.40646976, 62.42859506, 70.0]])
+        B = np.array([[75.02751435, 74.65699325, 61.09751679, 55.0, 78.71358218, 82.4585436, 67.24904609, 65.0]])
+        gap_dim = 0
+    
+    assert A[0][gap_dim + dim] < B[0][gap_dim], f"A_max ({A[0][gap_dim + dim]}) should be < B_min ({B[0][gap_dim]})"
+    gap = B[0][gap_dim] - A[0][gap_dim + dim]
+    assert gap > 0, f"Gap should be positive, got {gap}"
+    
+    tree = PRTree(np.array([0]), A)
+    
+    result = tree.batch_query(B)
+    assert result == [[]], f"Expected [[]] (no intersection), got {result}. Gap was {gap}"
+    
+    result_query = tree.query(B[0])
+    assert result_query == [], f"Expected [] (no intersection), got {result_query}. Gap was {gap}"
+
+
+@pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+def test_touching_boxes(PRTree, dim):
+    """Test that boxes that exactly touch (share a boundary) are considered intersecting.
+    
+    This documents the intended closed-interval semantics where touching counts as intersecting.
+    """
+    A = np.zeros((1, 2 * dim))
+    B = np.zeros((1, 2 * dim))
+    
+    for i in range(dim):
+        A[0][i] = 0.0  # min coords
+        A[0][i + dim] = 1.0  # max coords
+        B[0][i] = 1.0  # min coords
+        B[0][i + dim] = 2.0  # max coords
+    
+    tree = PRTree(np.array([0]), A)
+    
+    result = tree.batch_query(B)
+    assert result == [[0]], f"Expected [[0]] (touching boxes intersect), got {result}"
+    
+    result_query = tree.query(B[0])
+    assert result_query == [0], f"Expected [0] (touching boxes intersect), got {result_query}"
+
+
+@pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+def test_large_magnitude_coords(PRTree, dim):
+    """Test boxes with large magnitude coordinates to ensure precision is maintained."""
+    A = np.zeros((1, 2 * dim))
+    B = np.zeros((1, 2 * dim))
+    
+    base = 1e6
+    for i in range(dim):
+        A[0][i] = base + i  # min coords
+        A[0][i + dim] = base + i + 1.0  # max coords
+        B[0][i] = base + i + 1.1  # min coords (larger gap for double precision limits)
+        B[0][i + dim] = base + i + 2.0  # max coords
+    
+    tree = PRTree(np.array([0]), A)
+    
+    result = tree.batch_query(B)
+    assert result == [[]], f"Expected [[]] (no intersection at large magnitude), got {result}"
+
+
+@pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+def test_degenerate_boxes(PRTree, dim):
+    """Test boxes with zero volume (degenerate in one or more dimensions)."""
+    A = np.zeros((1, 2 * dim))
+    B = np.zeros((1, 2 * dim))
+    
+    for i in range(dim):
+        if i == 0:
+            A[0][i] = 1.0
+            A[0][i + dim] = 1.0
+            B[0][i] = 1.0
+            B[0][i + dim] = 1.0
+        else:
+            A[0][i] = 0.0
+            A[0][i + dim] = 1.0
+            B[0][i] = 0.5
+            B[0][i + dim] = 1.5
+    
+    tree = PRTree(np.array([0]), A)
+    
+    result = tree.batch_query(B)
+    assert result == [[0]], f"Expected [[0]] (degenerate boxes intersect), got {result}"
+
+
+@pytest.mark.parametrize("PRTree, dim", [(PRTree2D, 2), (PRTree3D, 3), (PRTree4D, 4)])
+def test_query_vs_batch_query_consistency(PRTree, dim):
+    """Test that query and batch_query return consistent results."""
+    np.random.seed(42)
+    N = 50
+    idx = np.arange(N)
+    x = np.random.rand(N, 2 * dim) * 100  # Use larger range to test precision
+    for i in range(dim):
+        x[:, i + dim] += x[:, i] + 0.1  # Ensure valid boxes with small width
+    
+    tree = PRTree(idx, x)
+    
+    queries = np.random.rand(20, 2 * dim) * 100
+    for i in range(dim):
+        queries[:, i + dim] += queries[:, i] + 0.1
+    
+    batch_results = tree.batch_query(queries)
+    for i, query in enumerate(queries):
+        single_result = tree.query(query)
+        assert set(batch_results[i]) == set(single_result), \
+            f"Query {i}: batch_query returned {batch_results[i]}, query returned {single_result}"