faiss 0.5.1 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 439ff96f613cd71e2a32197194d3814cf5ea516bd31489fdc2bd7a98747ec8ff
-  data.tar.gz: b2eaf07886acc74aaee4e6f1956a8c09f1d76da0ebaca14b6d4f3e889d728ef7
+  metadata.gz: 46b01025b31b0b052236ffb42c9d046de719f2c6ffbdff50299e51f339def739
+  data.tar.gz: 1d50d77f839ad49dd6827776dca2f7eeea25eb333ccac6d86077a4366a085065
 SHA512:
-  metadata.gz: 03d9a8aa01c86c176437adfab3038b91eb9b9991b2446f4b442114fac8e16133f213eec779d8bdedf80f13c643e96ec2ae39cfa9e1de4313148d53efa565d5c8
-  data.tar.gz: aa3ef7993a7411cbd480134e054528f069931c57ec55a8dd74c33642fa9debf203507f5744fa1ad178c04d142ac6efd482d63e6df1ced32e890fedd1def73769
+  metadata.gz: ffd3ca8a5726dacc053da5c489f19212399c780fd41048793ebd9785716e934ac3e158a5a1fa09c11723fa12ab172d65166bb12216f245dd01864cef83b4608f
+  data.tar.gz: c485d9b425913d52f3a53c7e229dffa04fe1535de151b2abb5ac2e09a56d4ba4cfcfd8838846eab5b9a18c898115f56fa107640c210001b69ea8fd8a7eac8428

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 0.5.3 (2026-02-12)
+
+- Added `IndexIDMap2` class
+- Added `remove_ids` method
+- Added `reconstruct_batch` and `reconstruct_n` methods
+- Fixed error when searching frozen indexes
+- Fixed memory leak with frozen exceptions
+
+## 0.5.2 (2026-01-02)
+
+- Fixed error with Rice 4.8
+
 ## 0.5.1 (2025-12-20)
 
 - Updated Faiss to 1.13.2

data/LICENSE.txt

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) Facebook, Inc. and its affiliates.
-Copyright (c) 2020-2025 Andrew Kane
+Copyright (c) 2020-2026 Andrew Kane
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/ext/faiss/index.cpp

@@ -1,4 +1,6 @@
+#include <algorithm>
 #include <string>
+#include <vector>
 
 #include <faiss/AutoTune.h>
 #include <faiss/Index.h>
@@ -31,13 +33,9 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     faiss::MetricType convert(VALUE x) {
-      if (x == Qnil && this->arg_ && this->arg_->hasDefaultValue()) {
-        return this->arg_->defaultValue<faiss::MetricType>();
-      }
-
       auto s = Object(x).to_s().str();
       if (s == "inner_product") {
         return faiss::METRIC_INNER_PRODUCT;
@@ -64,7 +62,7 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+    double is_convertible(VALUE value) { return Convertible::Exact; }
 
     faiss::ScalarQuantizer::QuantizerType convert(VALUE x) {
       auto s = Object(x).to_s().str();
@@ -112,7 +110,7 @@ void init_index(Rice::Module& m) {
     .define_method(
       "train",
       [](Rice::Object rb_self, numo::SFloat objects) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
@@ -121,7 +119,7 @@ void init_index(Rice::Module& m) {
     .define_method(
       "add",
       [](Rice::Object rb_self, numo::SFloat objects) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
@@ -130,7 +128,7 @@ void init_index(Rice::Module& m) {
     .define_method(
       "add_with_ids",
       [](Rice::Object rb_self, numo::SFloat objects, numo::Int64 ids) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         auto n = check_shape(objects, self.d);
@@ -139,6 +137,19 @@ void init_index(Rice::Module& m) {
         }
         self.add_with_ids(n, objects.read_ptr(), ids.read_ptr());
       })
+    .define_method(
+      "remove_ids",
+      [](Rice::Object rb_self, numo::Int64 ids) {
+        check_frozen(rb_self);
+
+        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
+        if (ids.ndim() != 1) {
+          throw Rice::Exception(rb_eArgError, "expected ids to be 1d array");
+        }
+        auto n = ids.shape()[0];
+        faiss::IDSelectorBatch sel(n, ids.read_ptr());
+        return self.remove_ids(sel);
+      })
     .define_method(
       "search",
       [](Rice::Object rb_self, numo::SFloat objects, size_t k) {
@@ -149,9 +160,18 @@ void init_index(Rice::Module& m) {
         auto labels = numo::Int64({n, k});
 
         if (rb_self.is_frozen()) {
+          // Don't mess with Ruby-owned memory while the GVL is released
+          auto objects_ptr = objects.read_ptr();
+          std::vector<float> objects_vec(objects_ptr, objects_ptr + n * self.d);
+          std::vector<float> distances_vec(n * k);
+          std::vector<int64_t> labels_vec(n * k);
+
           Rice::detail::no_gvl([&] {
-            self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+            self.search(n, objects_vec.data(), k, distances_vec.data(), labels_vec.data());
           });
+
+          std::copy(distances_vec.begin(), distances_vec.end(), distances.write_ptr());
+          std::copy(labels_vec.begin(), labels_vec.end(), labels.write_ptr());
         } else {
           self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
         }
@@ -164,7 +184,7 @@ void init_index(Rice::Module& m) {
     .define_method(
       "nprobe=",
       [](Rice::Object rb_self, double val) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
         faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
@@ -177,6 +197,34 @@ void init_index(Rice::Module& m) {
         self.reconstruct(key, recons.write_ptr());
         return recons;
       })
+    .define_method(
+      "reconstruct_batch",
+      [](faiss::Index &self, numo::Int64 ids) {
+        if (ids.ndim() != 1) {
+          throw Rice::Exception(rb_eArgError, "expected ids to be 1d array");
+        }
+        auto n = static_cast<std::size_t>(ids.shape()[0]);
+        auto d = static_cast<std::size_t>(self.d);
+        auto recons = numo::SFloat({n, d});
+        self.reconstruct_batch(n, ids.read_ptr(), recons.write_ptr());
+        return recons;
+      })
+    .define_method(
+      "reconstruct_n",
+      [](faiss::Index &self, int64_t i0, int64_t ni) {
+        if (ni < 0) {
+          throw Rice::Exception(rb_eArgError, "expected n to be non-negative");
+        }
+        // second condition written this way to avoid overflow
+        if (i0 < 0 || i0 > self.ntotal - ni) {
+          throw Rice::Exception(rb_eIndexError, "index out of range");
+        }
+        auto d = static_cast<std::size_t>(self.d);
+        auto n = static_cast<std::size_t>(ni);
+        auto recons = numo::SFloat({n, d});
+        self.reconstruct_n(i0, ni, recons.write_ptr());
+        return recons;
+      })
     .define_method(
       "save",
       [](faiss::Index &self, Rice::String fname) {
@@ -195,10 +243,12 @@ void init_index(Rice::Module& m) {
     .define_constructor(Rice::Constructor<faiss::IndexFlatIP, int64_t>());
 
   Rice::define_class_under<faiss::IndexHNSWFlat, faiss::Index>(m, "IndexHNSWFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int, faiss::MetricType>(), Rice::Arg("_d"), Rice::Arg("_M"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int>())
+    .define_constructor(Rice::Constructor<faiss::IndexHNSWFlat, int, int, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexIVFFlat, faiss::Index>(m, "IndexIVFFlat")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t, faiss::MetricType>(), Rice::Arg("_quantizer"), Rice::Arg("_d"), Rice::Arg("_nlist"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t>())
+    .define_constructor(Rice::Constructor<faiss::IndexIVFFlat, faiss::Index*, size_t, size_t, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexLSH, faiss::Index>(m, "IndexLSH")
     .define_constructor(Rice::Constructor<faiss::IndexLSH, int64_t, int>());
@@ -213,7 +263,8 @@ void init_index(Rice::Module& m) {
     .define_constructor(Rice::Constructor<faiss::IndexIVFScalarQuantizer, faiss::Index*, size_t, size_t, faiss::ScalarQuantizer::QuantizerType>());
 
   Rice::define_class_under<faiss::IndexIVFPQ, faiss::Index>(m, "IndexIVFPQ")
-    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t, faiss::MetricType>(), Rice::Arg("_quantizer"), Rice::Arg("_d"), Rice::Arg("_nlist"), Rice::Arg("_M"), Rice::Arg("_nbits_per_idx"), Rice::Arg("_metric") = faiss::METRIC_L2);
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t>())
+    .define_constructor(Rice::Constructor<faiss::IndexIVFPQ, faiss::Index*, size_t, size_t, size_t, size_t, faiss::MetricType>());
 
   Rice::define_class_under<faiss::IndexIVFPQR, faiss::Index>(m, "IndexIVFPQR")
     .define_constructor(Rice::Constructor<faiss::IndexIVFPQR, faiss::Index*, size_t, size_t, size_t, size_t, size_t, size_t>());
@@ -228,4 +279,7 @@ void init_index(Rice::Module& m) {
 
   Rice::define_class_under<faiss::IndexIDMap, faiss::Index>(m, "IndexIDMap")
     .define_constructor(Rice::Constructor<faiss::IndexIDMap, faiss::Index*>());
+
+  Rice::define_class_under<faiss::IndexIDMap2, faiss::Index>(m, "IndexIDMap2")
+    .define_constructor(Rice::Constructor<faiss::IndexIDMap2, faiss::Index*>());
 }

data/ext/faiss/index_binary.cpp

@@ -1,3 +1,6 @@
+#include <algorithm>
+#include <vector>
+
 #include <faiss/IndexBinary.h>
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/IndexBinaryIVF.h>
@@ -28,7 +31,7 @@ void init_index_binary(Rice::Module& m) {
     .define_method(
       "train",
       [](Rice::Object rb_self, numo::UInt8 objects) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
         auto n = check_shape(objects, self.d / 8);
@@ -37,12 +40,25 @@ void init_index_binary(Rice::Module& m) {
     .define_method(
       "add",
       [](Rice::Object rb_self, numo::UInt8 objects) {
-        rb_check_frozen(rb_self.value());
+        check_frozen(rb_self);
 
         auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
         auto n = check_shape(objects, self.d / 8);
         self.add(n, objects.read_ptr());
       })
+    .define_method(
+      "remove_ids",
+      [](Rice::Object rb_self, numo::Int64 ids) {
+        check_frozen(rb_self);
+
+        auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
+        if (ids.ndim() != 1) {
+          throw Rice::Exception(rb_eArgError, "expected ids to be 1d array");
+        }
+        auto n = ids.shape()[0];
+        faiss::IDSelectorBatch sel(n, ids.read_ptr());
+        return self.remove_ids(sel);
+      })
     .define_method(
       "search",
       [](Rice::Object rb_self, numo::UInt8 objects, size_t k) {
@@ -53,9 +69,18 @@ void init_index_binary(Rice::Module& m) {
         auto labels = numo::Int64({n, k});
 
         if (rb_self.is_frozen()) {
+          // Don't mess with Ruby-owned memory while the GVL is released
+          auto objects_ptr = objects.read_ptr();
+          std::vector<uint8_t> objects_vec(objects_ptr, objects_ptr + n * (self.d / 8));
+          std::vector<int32_t> distances_vec(n * k);
+          std::vector<int64_t> labels_vec(n * k);
+
           Rice::detail::no_gvl([&] {
-            self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
+            self.search(n, objects_vec.data(), k, distances_vec.data(), labels_vec.data());
           });
+
+          std::copy(distances_vec.begin(), distances_vec.end(), distances.write_ptr());
+          std::copy(labels_vec.begin(), labels_vec.end(), labels.write_ptr());
         } else {
           self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
         }
@@ -65,6 +90,30 @@ void init_index_binary(Rice::Module& m) {
         ret.push(std::move(labels), false);
         return ret;
       })
+    .define_method(
+      "reconstruct",
+      [](faiss::IndexBinary &self, int64_t key) {
+        auto d = static_cast<std::size_t>(self.d / 8);
+        auto recons = numo::UInt8({d});
+        self.reconstruct(key, recons.write_ptr());
+        return recons;
+      })
+    .define_method(
+      "reconstruct_n",
+      [](faiss::IndexBinary &self, int64_t i0, int64_t ni) {
+        if (ni < 0) {
+          throw Rice::Exception(rb_eArgError, "expected n to be non-negative");
+        }
+        // second condition written this way to avoid overflow
+        if (i0 < 0 || i0 > self.ntotal - ni) {
+          throw Rice::Exception(rb_eIndexError, "index out of range");
+        }
+        auto d = static_cast<std::size_t>(self.d / 8);
+        auto n = static_cast<std::size_t>(ni);
+        auto recons = numo::UInt8({n, d});
+        self.reconstruct_n(i0, ni, recons.write_ptr());
+        return recons;
+      })
     .define_method(
       "save",
       [](faiss::IndexBinary &self, Rice::String fname) {

data/ext/faiss/kmeans.cpp

@@ -1,3 +1,5 @@
+#include <algorithm>
+
 #include <faiss/Clustering.h>
 #include <faiss/IndexFlat.h>
 #include <rice/rice.hpp>
@@ -27,7 +29,7 @@ void init_kmeans(Rice::Module& m) {
       "centroids",
       [](faiss::Clustering &self) {
         auto centroids = numo::SFloat({self.k, self.d});
-        memcpy(centroids.write_ptr(), self.centroids.data(), self.centroids.size() * sizeof(float));
+        std::copy(self.centroids.begin(), self.centroids.end(), centroids.write_ptr());
         return centroids;
       })
     .define_method(

data/ext/faiss/numo.hpp

@@ -1,5 +1,5 @@
 /*!
- * Numo.hpp v0.2.1
+ * Numo.hpp v0.3.1
  * https://github.com/ankane/numo.hpp
  * BSD-2-Clause License
  */
@@ -38,7 +38,7 @@ public:
   }
 
   bool is_contiguous() const {
-    return nary_check_contiguous(this->_value) == Qtrue;
+    return Rice::detail::protect(nary_check_contiguous, this->_value) == Qtrue;
   }
 
   operator Rice::Object() const {
@@ -46,26 +46,28 @@ public:
   }
 
   const void* read_ptr() {
-    if (!is_contiguous()) {
-      this->_value = nary_dup(this->_value);
-    }
-    return nary_get_pointer_for_read(this->_value) + nary_get_offset(this->_value);
+    return Rice::detail::protect([&]() {
+      if (!nary_check_contiguous(this->_value)) {
+        this->_value = nary_dup(this->_value);
+      }
+      return nary_get_pointer_for_read(this->_value) + nary_get_offset(this->_value);
+    });
   }
 
   void* write_ptr() {
-    return nary_get_pointer_for_write(this->_value);
+    return Rice::detail::protect(nary_get_pointer_for_write, this->_value);
   }
 
 protected:
   NArray() { }
 
   void construct_value(VALUE dtype, VALUE v) {
-    this->_value = rb_funcall(dtype, rb_intern("cast"), 1, v);
+    this->_value = Rice::detail::protect(rb_funcall, dtype, rb_intern("cast"), 1, v);
   }
 
   void construct_shape(VALUE dtype, std::initializer_list<size_t> shape) {
     // rb_narray_new doesn't modify shape, but not marked as const
-    this->_value = rb_narray_new(dtype, shape.size(), const_cast<size_t*>(shape.begin()));
+    this->_value = Rice::detail::protect(rb_narray_new, dtype, shape.size(), const_cast<size_t*>(shape.begin()));
   }
 
   VALUE _value;
@@ -460,12 +462,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::NArray>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -506,12 +508,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -552,12 +554,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -598,12 +600,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -644,12 +646,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -690,12 +692,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -736,12 +738,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -782,12 +784,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -828,12 +830,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -874,12 +876,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -920,12 +922,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -966,12 +968,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1012,12 +1014,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1058,12 +1060,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Bit>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1104,12 +1106,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::RObject>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }

data/ext/faiss/utils.cpp

@@ -14,3 +14,8 @@ size_t check_shape(const numo::NArray& objects, size_t k) {
   }
   return shape[0];
 }
+
+void check_frozen(Rice::Object obj) {
+  // use protect to avoid skipping destructors and leaking memory
+  Rice::detail::protect(rb_check_frozen, obj.value());
+}

data/ext/faiss/utils.h

@@ -3,3 +3,5 @@
 #include "numo.hpp"
 
 size_t check_shape(const numo::NArray& objects, size_t k);
+
+void check_frozen(Rice::Object obj);

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.5.1"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faiss
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Andrew Kane
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.7'
+        version: '4.8'
 - !ruby/object:Gem::Dependency
   name: numo-narray
   requirement: !ruby/object:Gem::Requirement
@@ -407,7 +407,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Efficient similarity search and clustering for Ruby
 test_files: []