Add adaptive epsilon and configurable precision parameters

- Fix query methods to use Real type instead of hardcoded float
  - find_one() now accepts vec<Real> for proper float64 precision
  - find_all() now accepts py::array_t<Real> matching tree precision
- Fix Python wrapper to preserve precision settings on first insert
  - Handle subnormal detection disabled case with workaround
  - Preserve relative_epsilon, absolute_epsilon, adaptive_epsilon settings
- Remove obsolete query_exact and refine_candidates code
- All precision tests now passing

Author: claude

include/prtree/core/prtree.h

@@ -584,7 +584,7 @@ template <IndexType T, int B = 6, int D = 2, typename Real = float> class PRTree
 #endif
   }
 
-  auto find_all(const py::array_t<float> &x) {
+  auto find_all(const py::array_t<Real> &x) {
 #ifdef MY_DEBUG
     ProfilerStart("find_all.prof");
     std::cout << "profiler start of find_all" << std::endl;
@@ -728,40 +728,34 @@ template <IndexType T, int B = 6, int D = 2, typename Real = float> class PRTree
     return out;
   }
 
-  auto find_all_array(const py::array_t<float> &x) {
+  auto find_all_array(const py::array_t<Real> &x) {
     return list_list_to_arrays(std::move(find_all(x)));
   }
 
-  auto find_one(const vec<float> &x) {
+  auto find_one(const vec<Real> &x) {
     bool is_point = false;
     if (unlikely(!(x.size() == 2 * D || x.size() == D))) {
       throw std::runtime_error("invalid shape");
     }
     Real minima[D];
     Real maxima[D];
-    std::array<double, 2 * D> query_exact;
 
     if (x.size() == D) {
       is_point = true;
     }
     for (int i = 0; i < D; ++i) {
       minima[i] = x.at(i);
-      query_exact[i] = static_cast<double>(x.at(i));
 
       if (is_point) {
         maxima[i] = minima[i];
-        query_exact[i + D] = query_exact[i];
       } else {
         maxima[i] = x.at(i + D);
-        query_exact[i + D] = static_cast<double>(x.at(i + D));
       }
     }
     const auto bb = BB<D, Real>(minima, maxima);
     auto candidates = find(bb);
 
-    // Refine with double precision if exact coordinates are available
-    auto out = candidates;
-    return out;
+    return candidates;
   }
 
   // Helper method: Check intersection with double precision (closed interval

src/python_prtree/core.py

@@ -201,10 +201,48 @@ def insert(
 
         objdumps = _dumps(obj)
         if self.n == 0:
-            # Reinitialize tree with correct precision
+            # Reinitialize tree with correct precision and preserve settings
             Klass = self.Klass_float64 if self._use_float64 else self.Klass_float32
-            self._tree = Klass([idx], [bb])
-            self._tree.set_obj(idx, objdumps)
+            old_tree = self._tree
+
+            # Check if subnormal detection is disabled - if so, use workaround
+            subnormal_disabled = (hasattr(old_tree, 'get_subnormal_detection') and
+                                  not old_tree.get_subnormal_detection())
+
+            if subnormal_disabled:
+                # Create with dummy valid box first
+                dummy_idx = -999999
+                dummy_bb = np.ones(len(bb), dtype=bb.dtype)
+                self._tree = Klass([dummy_idx], [dummy_bb])
+
+                # Preserve settings and disable subnormal detection
+                if hasattr(old_tree, 'get_relative_epsilon'):
+                    self._tree.set_relative_epsilon(old_tree.get_relative_epsilon())
+                if hasattr(old_tree, 'get_absolute_epsilon'):
+                    self._tree.set_absolute_epsilon(old_tree.get_absolute_epsilon())
+                if hasattr(old_tree, 'get_adaptive_epsilon'):
+                    self._tree.set_adaptive_epsilon(old_tree.get_adaptive_epsilon())
+                self._tree.set_subnormal_detection(False)
+
+                # Now insert the real box (tree is not empty, insert will work)
+                self._tree.insert(idx, bb, objdumps)
+                # Erase dummy
+                self._tree.erase(dummy_idx)
+            else:
+                # Normal path
+                self._tree = Klass([idx], [bb])
+
+                # Preserve settings from old tree
+                if hasattr(old_tree, 'get_relative_epsilon'):
+                    self._tree.set_relative_epsilon(old_tree.get_relative_epsilon())
+                if hasattr(old_tree, 'get_absolute_epsilon'):
+                    self._tree.set_absolute_epsilon(old_tree.get_absolute_epsilon())
+                if hasattr(old_tree, 'get_adaptive_epsilon'):
+                    self._tree.set_adaptive_epsilon(old_tree.get_adaptive_epsilon())
+                if hasattr(old_tree, 'get_subnormal_detection'):
+                    self._tree.set_subnormal_detection(old_tree.get_subnormal_detection())
+
+                self._tree.set_obj(idx, objdumps)
         else:
             self._tree.insert(idx, bb, objdumps)