docs: update benchmarks based on new performance gains

Author: Elan456

README.md

@@ -35,7 +35,7 @@ Rust-optimized quadtree with a clean Python API
 - 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.5x faster while keeping the same API
+- Offers a drop-in [pyqtree shim](https://elan456.github.io/fastquadtree/benchmark/#pyqtree-drop-in-shim-performance-gains) that is ~10x faster while keeping the same API
 
 ----
 
@@ -49,7 +49,7 @@ from fastquadtree import QuadTree  # Point handling
 from fastquadtree import RectQuadTree  # Bounding box handling
 from fastquadtree import QuadTreeObjects  # Point handling with object tracking
 from fastquadtree import RectQuadTreeObjects  # Bounding box handling with object tracking
-from fastquadtree.pyqtree import Index  # Drop-in pyqtree shim (~6.5x faster while keeping the same API)
+from fastquadtree.pyqtree import Index  # Drop-in pyqtree shim (~10x faster while keeping the same API)
 ```
 
 
@@ -77,15 +77,15 @@ fastquadtree **outperforms** all other quadtree Python packages, including the R
 
 | Library | Build (s) | Query (s) | Total (s) | Speed vs PyQtree |
 |---|---:|---:|---:|---:|
-| fastquadtree (np)[^fqtnp] | 0.057 | 0.021 | 0.078 | 54.45× |
-| fastquadtree[^fqt] | 0.060 | 0.189 | 0.249 | 17.04× |
-| Shapely STRtree[^npreturn] | 0.321 | 0.196 | 0.517 | 8.21× |
-| fastquadtree (obj tracking)[^fqto] | 0.437 | 0.239 | 0.675 | 6.28× |
-| Rtree        | 1.796 | 0.561 | 2.357 | 1.80× |
-| nontree-QuadTree | 1.275 | 1.272 | 2.547 | 1.67× |
-| e-pyquadtree | 2.144 | 1.507 | 3.650 | 1.16× |
-| quads        | 3.001 | 1.171 | 4.172 | 1.02× |
-| PyQtree      | 3.677 | 0.565 | 4.242 | 1.00× |
+| fastquadtree (np)[^fqtnp] | 0.052 | 0.017 | 0.068 | 42.52× |
+| fastquadtree[^fqt] | 0.054 | 0.231 | 0.285 | 10.20× |
+| Shapely STRtree[^npreturn] | 0.200 | 0.110 | 0.309 | 9.40× |
+| fastquadtree (obj tracking)[^fqto] | 0.263 | 0.093 | 0.356 | 8.17× |
+| nontree-QuadTree | 0.826 | 0.844 | 1.670 | 1.74× |
+| Rtree        | 1.805 | 0.546 | 2.351 | 1.24× |
+| e-pyquadtree | 1.530 | 0.941 | 2.471 | 1.18× |
+| quads        | 1.907 | 0.759 | 2.667 | 1.09× |
+| PyQtree      | 2.495 | 0.414 | 2.909 | 1.00× |
 
 [^fqtnp]: Uses `query_np` for Numpy array return values rather than Python lists.  
 [^fqt]: Uses standard `query` method returning Python lists.  

assets/quadtree_bench_throughput.png

@@ -73,7 +73,7 @@ def query(qt, queries):
 
     return Engine(
         "e-pyquadtree",
-        "#1f77b4",
+        "#5c8daf",
         build,
         query,  # display name  # color (blue)
     )
@@ -94,7 +94,7 @@ def query(qt, queries):
         for q in queries:
             _ = list(qt.intersect(q))
 
-    return Engine("PyQtree", "#2ca02c", build, query)  # display name  # color (green)
+    return Engine("PyQtree", "#759d75", build, query)  # display name  # color (green)
 
 
 def _create_fastquadtree_np_engine(
@@ -113,7 +113,7 @@ def query(qt, queries):
 
     return Engine(
         "fastquadtree (np)",
-        "#e55100",
+        "#FF3D00",
         build,
         query,  # display name  # color (orange)
     )
@@ -135,7 +135,7 @@ def query(qt, queries):
 
     return Engine(
         "fastquadtree",
-        "#ff9500",
+        "#FF9100",
         build,
         query,  # display name  # color (orange)
     )
@@ -157,7 +157,7 @@ def query(qt, queries):
 
     return Engine(
         "fastquadtree (objs)",
-        "#ffc107",
+        "#FFD166",
         build,
         query,  # display name  # color (orange)
     )
@@ -190,7 +190,7 @@ def query(tree, queries):
             bb = qd.BoundingBox(min_x=xmin, min_y=ymin, max_x=xmax, max_y=ymax)
             _ = tree.within_bb(bb)
 
-    return Engine("quads", "#8c564b", build, query)  # display name  # color (brown)
+    return Engine("quads", "#8b6c66", build, query)  # display name  # color (brown)
 
 
 def _create_nontree_engine(
@@ -220,7 +220,7 @@ def query(tm: TreeMap, queries):
 
     return Engine(
         "nontree-QuadTree",
-        "#17becf",
+        "#55c2ce",
         build,
         query,  # display name  # color (cyan)
     )
@@ -245,7 +245,7 @@ def query(points, queries):
 
     return Engine(
         "Brute force",
-        "#9467bd",
+        "#a088b6",
         build,
         query,  # display name  # color (purple)
     )
@@ -336,13 +336,13 @@ def get_engines(
     """
     # Always available engines
     engines = {
-        "fastquadtree (np)": _create_fastquadtree_np_engine(
-            bounds, max_points, max_depth
-        ),
         "fastquadtree": _create_fastquadtree_engine(bounds, max_points, max_depth),
         "fastquadtree (obj tracking)": _create_fastquadtree_items_engine(
             bounds, max_points, max_depth
         ),
+        "fastquadtree (np)": _create_fastquadtree_np_engine(
+            bounds, max_points, max_depth
+        ),
         "e-pyquadtree": _create_e_pyquadtree_engine(bounds, max_points, max_depth),
         "PyQtree": _create_pyqtree_engine(bounds, max_points, max_depth),
         #    "Brute force": _create_brute_force_engine(bounds, max_points, max_depth),  # Brute force doesn't scale well on the graphs so omit it from the main set

assets/quadtree_bench_time.png

@@ -57,7 +57,14 @@ def add_time_traces(y_data: dict[str, list], col: int):
         # Update axes
         for col in (1, 2, 3):
             fig.update_xaxes(title_text="Number of points", row=1, col=col)
-            fig.update_yaxes(title_text="Time (s)", row=1, col=col)
+            fig.update_yaxes(
+                title_text="Time (s)",
+                row=1,
+                col=col,
+                type="log",
+                tickformat=".3g",
+                dtick=0.25,
+            )
 
         # Update layout
         fig.update_layout(
@@ -250,7 +257,6 @@ def create_comparison_plot(
             height=600,
         )
 
-        if "rate" in metric:
-            fig.update_yaxes(type="log")
+        fig.update_yaxes(type="log")
 
         return fig

benchmarks/quadtree_bench/engines.py

@@ -12,19 +12,19 @@ Quadtrees are the focus of the benchmark, but Rtrees are included for reference.
 
 ### Summary (largest dataset, PyQtree baseline)
 - Points: **500,000**, Queries: **500**
-- Fastest total: **fastquadtree** at **0.078 s**
+- Fastest total: **fastquadtree** at **0.068 s**
 
 | Library | Build (s) | Query (s) | Total (s) | Speed vs PyQtree |
 |---|---:|---:|---:|---:|
-| fastquadtree (np)[^fqtnp] | 0.057 | 0.021 | 0.078 | 54.45× |
-| fastquadtree[^fqt] | 0.060 | 0.189 | 0.249 | 17.04× |
-| Shapely STRtree[^npreturn] | 0.321 | 0.196 | 0.517 | 8.21× |
-| fastquadtree (obj tracking)[^fqto] | 0.437 | 0.239 | 0.675 | 6.28× |
-| Rtree        | 1.796 | 0.561 | 2.357 | 1.80× |
-| nontree-QuadTree | 1.275 | 1.272 | 2.547 | 1.67× |
-| e-pyquadtree | 2.144 | 1.507 | 3.650 | 1.16× |
-| quads        | 3.001 | 1.171 | 4.172 | 1.02× |
-| PyQtree      | 3.677 | 0.565 | 4.242 | 1.00× |
+| fastquadtree (np)[^fqtnp] | 0.052 | 0.017 | 0.068 | 42.52× |
+| fastquadtree[^fqt] | 0.054 | 0.231 | 0.285 | 10.20× |
+| Shapely STRtree[^npreturn] | 0.200 | 0.110 | 0.309 | 9.40× |
+| fastquadtree (obj tracking)[^fqto] | 0.263 | 0.093 | 0.356 | 8.17× |
+| nontree-QuadTree | 0.826 | 0.844 | 1.670 | 1.74× |
+| Rtree        | 1.805 | 0.546 | 2.351 | 1.24× |
+| e-pyquadtree | 1.530 | 0.941 | 2.471 | 1.18× |
+| quads        | 1.907 | 0.759 | 2.667 | 1.09× |
+| PyQtree      | 2.495 | 0.414 | 2.909 | 1.00× |
 
 [^fqtnp]: Uses `query_np` for Numpy array return values rather than Python lists.
 [^fqt]: Uses standard `query` method returning Python lists.
@@ -57,19 +57,21 @@ Quadtrees are the focus of the benchmark, but Rtrees are included for reference.
 
 | Variant | Build | Query | Total |
 |---|---:|---:|---:|
-| Native | 0.141 | 1.858 | 1.999 |
-| QuadTree (no objects) | 0.235 | 1.920 | 2.155 |
-| QuadTreeObjects | 0.927 | 2.052 | 2.979 |
-| QuadTree (numpy, no objects) | 0.046 | 0.252 | 0.297 |
+| Native | 0.140 | 2.364 | 2.504 |
+| Native (ID-only query) | 0.136 | 0.434 | 0.570 |
+| QuadTree (no objects) | 0.179 | 2.210 | 2.389 |
+| QuadTree insert_many (no objects) | 0.058 | 2.085 | 2.143 |
+| QuadTreeObjects | 0.599 | 0.732 | 1.331 |
+| QuadTree (numpy, no objects) | 0.032 | 0.102 | 0.134 |
 
 ### Summary
 
-- The Python shim (QuadTree) is 1.078x slower than the native engine due to Python overhead.
+- The Python shim (QuadTree) is 0.954x slower than the native engine due to Python overhead.
 
-- NumPy points are the fastest path: build is **5.157x faster** than the list path and queries are **7.627x faster**,
-  for a **7.249x** total speedup vs the list path.
+- NumPy points are the fastest path: build is **5.536x faster** than the list path and queries are **21.733x faster**,
+  for a **17.822x** total speedup vs the list path.
 
-- QuadTreeObjects adds object association overhead. Build time increases significantly, query time is moderately slower.
+- QuadTreeObjects adds object association overhead. Build time increases significantly, query time much faster.
 
 ## pyqtree drop-in shim performance gains
 
@@ -82,13 +84,13 @@ Quadtrees are the focus of the benchmark, but Rtrees are included for reference.
 
 | Variant | Build | Query | Total |
 |---|---:|---:|---:|
-| pyqtree (fastquadtree) | 0.485 | 2.086 | 2.571 |
-| pyqtree (original) | 3.463 | 13.209 | 16.672 |
+| pyqtree (fastquadtree) | 0.326 | 0.801 | 1.127 |
+| pyqtree (original) | 2.111 | 9.536 | 11.647 |
 
 ### Summary
 
-If you directly replace pyqtree with the drop-in `fastquadtree.pyqtree.Index` shim, you get a build time of 0.485s and query time of 2.086s.
-This is a **total speedup of 6.486x** compared to the original pyqtree and requires no code changes.
+If you directly replace pyqtree with the drop-in `fastquadtree.pyqtree.Index` shim, you get a build time of 0.326s and query time of 0.801s.
+This is a **total speedup of 10.333x** compared to the original pyqtree and requires no code changes.
 
 ---------
 
@@ -144,10 +146,10 @@ If your data is already in a NumPy array, using the `insert_many_np` method dire
 ----------------
 
 ## System Info
-- **OS**: Windows 11 AMD64
-- **Python**: CPython 3.12.2
+- **OS**: CachyOS 6.18.5-2-cachyos x86_64
+- **Python**: CPython 3.14.2
 - **CPU**: AMD Ryzen 7 3700X 8-Core Processor (16 threads)
-- **Memory**: 31.9 GB
+- **Memory**: 31.3 GB
 - **GPU**: NVIDIA GeForce RTX 5070 (11.9 GB)
 
 ## Running Benchmarks

benchmarks/quadtree_bench/plotting.py

@@ -61,5 +61,5 @@ from fastquadtree import QuadTree  # Point handling
 from fastquadtree import RectQuadTree  # Bounding box handling
 from fastquadtree import QuadTreeObjects  # Point handling with object tracking
 from fastquadtree import RectQuadTreeObjects  # Bounding box handling with object tracking
-from fastquadtree.pyqtree import Index # Drop-in replacement for pyqtree (~6.5x faster while keeping the same API)
+from fastquadtree.pyqtree import Index # Drop-in replacement for pyqtree (~10x faster while keeping the same API)
 ```

docs/benchmark.md

@@ -25,7 +25,7 @@ class Index:
 
     This class provides the same interface as pyqtree.Index but is backed by
     a high-performance Rust implementation. Based on benchmarks, this provides
-    an overall performance boost of approximately 6.5x compared to the original
+    an overall performance boost of approximately 10x compared to the original
     pure-Python implementation.
 
     For new projects not requiring pyqtree compatibility, consider using