Fix serialization bug and packaging issues for macOS/Windows

This commit addresses two critical issues blocking CI:

1. Serialization bug (GitHub issue comment):
   - Added idx2exact to serialize(), save(), and load() methods
   - This fixes correctness loss after save/load for trees built from float64 input
   - The idx2exact map stores double-precision coordinates for refinement
   - Without this fix, trees lose precision after save/load cycles

2. Packaging issue (macOS/Windows test failures):
   - Added CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE for Windows
   - Added CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE for macOS
   - Fixes ModuleNotFoundError on macOS/Windows due to multi-config generators
   - Windows treats .pyd as RUNTIME, macOS needs config-specific output dirs

3. Comprehensive regression tests:
   - test_save_load_float64_matteo_case: Tests Matteo bug case with float64
   - test_save_load_float32_no_regression: Ensures float32 path still works
   - Both tests verify correctness survives save/load cycles
   - Tests include explicit gc.collect() for Windows file locking

All 123 tests pass locally (121 original + 2 new regression tests).

Related to PR #45

Author: atksh

cpp/prtree.h

@@ -756,7 +756,7 @@ class PRTree
   template <class Archive>
   void serialize(Archive &archive)
   {
-    archive(flat_tree, idx2bb, idx2data, global_idx, n_at_build);
+    archive(flat_tree, idx2bb, idx2data, global_idx, n_at_build, idx2exact);
   }
 
   void save(std::string fname)
@@ -769,7 +769,8 @@ class PRTree
                   cereal::make_nvp("idx2bb", idx2bb),
                   cereal::make_nvp("idx2data", idx2data),
                   cereal::make_nvp("global_idx", global_idx),
-                  cereal::make_nvp("n_at_build", n_at_build));
+                  cereal::make_nvp("n_at_build", n_at_build),
+                  cereal::make_nvp("idx2exact", idx2exact));
       }
     }
   }
@@ -784,7 +785,8 @@ class PRTree
                   cereal::make_nvp("idx2bb", idx2bb),
                   cereal::make_nvp("idx2data", idx2data),
                   cereal::make_nvp("global_idx", global_idx),
-                  cereal::make_nvp("n_at_build", n_at_build));
+                  cereal::make_nvp("n_at_build", n_at_build),
+                  cereal::make_nvp("idx2exact", idx2exact));
       }
     }
   }

setup.py

@@ -65,11 +65,18 @@ def build_extension(self, ext):
 
         if platform.system() == "Windows":
             cmake_args += [
-                "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}".format(cfg.upper(), extdir)
+                "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}".format(cfg.upper(), extdir),
+                "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY_{}={}".format(cfg.upper(), extdir)
             ]
             if sys.maxsize > 2**32:
                 cmake_args += ["-A", "x64"]
             build_args += ["--", "/m"]
+        elif platform.system() == "Darwin":
+            cmake_args += [
+                "-DCMAKE_BUILD_TYPE=" + cfg,
+                "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY_{}={}".format(cfg.upper(), extdir)
+            ]
+            build_args += ["--", "-j" + str(cpu_count())]
         else:
             cmake_args += ["-DCMAKE_BUILD_TYPE=" + cfg]
             build_args += ["--", "-j" + str(cpu_count())]

tests/test_PRTree.py

@@ -291,3 +291,93 @@ def test_query_vs_batch_query_consistency(PRTree, dim):
         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}"
+
+
+def test_save_load_float64_matteo_case(tmp_path):
+    """Regression test: ensure idx2exact survives save/load for float64 input.
+    
+    This tests the fix for the serialization bug where idx2exact was not being
+    archived, causing trees built from float64 input to lose correctness after
+    save/load. The Matteo bug case has boxes separated by ~5.4e-6, which requires
+    double-precision refinement to correctly identify as disjoint.
+    """
+    import gc
+    
+    A = np.array([[72.47410062, 80.52848893, 54.68197159, 75.02750896, 85.40646976, 62.42859506]], dtype=np.float64)
+    B = np.array([[75.02751435, 74.65699325, 61.09751679, 78.71358218, 82.4585436, 67.24904609]], dtype=np.float64)
+    
+    assert A[0][3] < B[0][0], "Test setup error: boxes should be disjoint"
+    gap = B[0][0] - A[0][3]
+    assert 5e-6 < gap < 6e-6, f"Test setup error: expected gap ~5.4e-6, got {gap}"
+    
+    tree = PRTree3D(np.array([0], dtype=np.int64), A)
+    
+    result_before = tree.batch_query(B)
+    assert result_before == [[]], f"Before save: Expected [[]] (disjoint), got {result_before}"
+    
+    fname = tmp_path / "tree_float64.bin"
+    fname = str(fname)
+    tree.save(fname)
+    
+    del tree
+    gc.collect()
+    
+    tree_loaded = PRTree3D(fname)
+    
+    result_after = tree_loaded.batch_query(B)
+    assert result_after == [[]], f"After load: Expected [[]] (disjoint), got {result_after}"
+    
+    np.random.seed(42)
+    queries = np.random.rand(10, 6).astype(np.float64) * 100
+    for i in range(3):
+        queries[:, i + 3] += queries[:, i] + 1e-5  # Small gaps
+    
+    results_before_save = tree_loaded.batch_query(queries)
+    
+    fname2 = tmp_path / "tree_float64_2.bin"
+    fname2 = str(fname2)
+    tree_loaded.save(fname2)
+    del tree_loaded
+    gc.collect()
+    
+    tree_loaded2 = PRTree3D(fname2)
+    results_after_save = tree_loaded2.batch_query(queries)
+    
+    assert results_before_save == results_after_save, \
+        "Random queries: results changed after save/load cycle"
+
+
+def test_save_load_float32_no_regression(tmp_path):
+    """Regression test: ensure float32 path still works correctly after save/load.
+    
+    This tests that the serialization fix (adding idx2exact to archive) doesn't
+    break the float32 path, which doesn't use idx2exact.
+    """
+    import gc
+    
+    np.random.seed(42)
+    N = 100
+    idx = np.arange(N, dtype=np.int64)
+    x = np.random.rand(N, 6).astype(np.float32) * 100
+    for i in range(3):
+        x[:, i + 3] += x[:, i] + 1.0  # Ensure valid boxes
+    
+    tree = PRTree3D(idx, x)
+    
+    queries = np.random.rand(20, 6).astype(np.float32) * 100
+    for i in range(3):
+        queries[:, i + 3] += queries[:, i] + 1.0
+    
+    results_before = tree.batch_query(queries)
+    
+    fname = tmp_path / "tree_float32.bin"
+    fname = str(fname)
+    tree.save(fname)
+    del tree
+    gc.collect()
+    
+    tree_loaded = PRTree3D(fname)
+    results_after = tree_loaded.batch_query(queries)
+    
+    assert results_before == results_after, \
+        "Float32 path: results changed after save/load cycle"