faiss 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ab397b95262fa87d28a4f08098de35f487b44e6240682ec8e98c4efc823c4df
-  data.tar.gz: 719490d3f20bad4531f588e9469d3fa9ec2362cc18f800e913725ffb6b0aeca0
+  metadata.gz: 18db7914c6db421beb972845cdf1d6489f179d6347f2cc52252b5908c7dd2db0
+  data.tar.gz: fcbc66c8b544a9f96e913c4e4e3d7a8be8c450d56db0332bc3ea1810776e424b
 SHA512:
-  metadata.gz: 56e16fad10a1ba95c9727f2e356470e984ca29b44406cf125b1ab529c83fee2c9bf15efa564a543cda331489dbdc56c9c44f4eda4ad53178979370987b6fbf9e
-  data.tar.gz: 691e9a843eaac7e699dafc15d5505f6febf783ae6d474ee0409cb01d1b1f1575477db13cb7290a4d2cc639692503099fa7d4ff767d3c3034838d05ea0476521a
+  metadata.gz: a885807f3c74cb4ce27a5931f7f2b73dc3ec9bd214c06e96d191086a841d1f366e1d8ebbe9af35143c8facd1285070d0f0b46814f5a78d1d55fb0b1821ab3fa3
+  data.tar.gz: f7ec06da8dc75e0341763f15501e2bc503ef3001dee29c88a0b0253ce78c38cb5e5b222ec75b26814a7c9f2a69e02e1ff685f108d3a4512ef8bf55e5a42214ce

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 0.6.0 (2026-04-06)
+
+- Updated Faiss to 1.14.1
+- Added `id_map` method to `IndexIDMap2`
+- Switched to `numo-narray-alt`
+- Dropped support for Ruby < 3.3
+- Dropped support for C++17
+
+## 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

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/ext.cpp

@@ -8,7 +8,7 @@ void init_product_quantizer(Rice::Module& m);
 
 extern "C"
 void Init_ext() {
-  auto m = Rice::define_module("Faiss");
+  Rice::Module m = Rice::define_module("Faiss");
 
   init_index(m);
   init_index_binary(m);

data/ext/faiss/extconf.rb

@@ -1,5 +1,5 @@
 require "mkmf-rice"
-require "numo/narray"
+require "numo/narray/alt"
 
 # libomp changed to keg-only
 # https://github.com/Homebrew/homebrew-core/issues/112107
@@ -13,14 +13,13 @@ abort "BLAS not found" unless have_library("blas")
 abort "LAPACK not found" unless have_library("lapack")
 abort "OpenMP not found" unless have_library("omp") || have_library("gomp")
 
-numo = File.join(Gem.loaded_specs["numo-narray"].require_path, "numo")
+numo = File.join(Gem.loaded_specs["numo-narray-alt"].require_path, "numo")
 abort "Numo not found" unless find_header("numo/narray.h", numo)
 
 # for https://bugs.ruby-lang.org/issues/19005
 $LDFLAGS += " -Wl,-undefined,dynamic_lookup" if RbConfig::CONFIG["host_os"] =~ /darwin/i
 
-$CXXFLAGS += " -std=c++17 $(optflags) -DFINTEGER=int"
-$CXXFLAGS += " -Wall -Wno-unused-parameter -Wno-unused-function -Wno-unused-variable -Wno-unused-private-field -Wno-deprecated-declarations -Wno-sign-compare"
+$CXXFLAGS += " -std=c++20 $(optflags) -DFINTEGER=int"
 
 # -march=native not supported with ARM Mac
 default_optflags = RbConfig::CONFIG["host_os"] =~ /darwin/i && RbConfig::CONFIG["host_cpu"] =~ /arm|aarch64/i ? "" : " -march=native"
@@ -34,8 +33,8 @@ ext = File.expand_path(".", __dir__)
 vendor = File.expand_path("../../vendor/faiss", __dir__)
 
 $srcs = Dir["{#{ext},#{vendor}/faiss,#{vendor}/faiss/{impl,invlists,utils}/**}/*.{cpp}"]
-$objs = $srcs.map { |v| v.sub(/cpp\z/, "o") }
+$srcs -= ["avx2", "avx512", "aarch64", "arm_sve"].map { |v| "#{vendor}/faiss/utils/simd_impl/distances_#{v}.cpp" }
 abort "Faiss not found" unless find_header("faiss/Index.h", vendor)
-$VPATH << vendor
+$VPATH += $srcs.filter_map { |v| File.dirname(v) if v.start_with?(vendor) }.uniq
 
 create_makefile("faiss/ext")

data/ext/faiss/index_binary.cpp

@@ -1,3 +1,10 @@
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <utility>
+#include <vector>
+
 #include <faiss/IndexBinary.h>
 #include <faiss/IndexBinaryFlat.h>
 #include <faiss/IndexBinaryIVF.h>
@@ -6,56 +13,84 @@
 #include <rice/rice.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 void init_index_binary(Rice::Module& m) {
   Rice::define_class_under<faiss::IndexBinary>(m, "IndexBinary")
     .define_method(
       "d",
-      [](faiss::IndexBinary &self) {
+      [](faiss::IndexBinary& self) {
         return self.d;
       })
     .define_method(
       "trained?",
-      [](faiss::IndexBinary &self) {
+      [](faiss::IndexBinary& self) {
         return self.is_trained;
       })
     .define_method(
       "ntotal",
-      [](faiss::IndexBinary &self) {
+      [](faiss::IndexBinary& self) {
         return self.ntotal;
       })
     .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);
+        auto& self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
+        size_t n = check_shape(objects, self.d / 8);
         self.train(n, objects.read_ptr());
       })
     .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);
+        auto& self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
+        size_t 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");
+        }
+        size_t 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) {
-        auto &self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
-        auto n = check_shape(objects, self.d / 8);
+      [](Rice::Object rb_self, numo::UInt8 objects, int64_t k) {
+        auto& self = *Rice::Data_Object<faiss::IndexBinary>{rb_self};
+        size_t n = check_shape(objects, self.d / 8);
+        if (k <= 0) {
+          throw Rice::Exception(rb_eArgError, "expected k to be positive");
+        }
+        if (std::cmp_greater_equal(k, std::numeric_limits<size_t>::max() / n)) {
+          throw Rice::Exception(rb_eArgError, "k too large");
+        }
 
-        auto distances = numo::Int32({n, k});
-        auto labels = numo::Int64({n, k});
+        numo::Int32 distances({n, static_cast<size_t>(k)});
+        numo::Int64 labels({n, static_cast<size_t>(k)});
 
         if (rb_self.is_frozen()) {
+          // Don't mess with Ruby-owned memory while the GVL is released
+          const 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 * static_cast<size_t>(k));
+          std::vector<int64_t> labels_vec(n * static_cast<size_t>(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::ranges::copy(distances_vec, distances.write_ptr());
+          std::ranges::copy(labels_vec, labels.write_ptr());
         } else {
           self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
         }
@@ -65,9 +100,33 @@ 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<size_t>(self.d / 8);
+        numo::UInt8 recons({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<size_t>(self.d / 8);
+        auto n = static_cast<size_t>(ni);
+        numo::UInt8 recons({n, d});
+        self.reconstruct_n(i0, ni, recons.write_ptr());
+        return recons;
+      })
     .define_method(
       "save",
-      [](faiss::IndexBinary &self, Rice::String fname) {
+      [](faiss::IndexBinary& self, Rice::String fname) {
         faiss::write_index_binary(&self, fname.c_str());
       })
     .define_singleton_function(

data/ext/faiss/{index.cpp → index_rb.cpp}

@@ -1,4 +1,10 @@
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include <faiss/AutoTune.h>
 #include <faiss/Index.h>
@@ -6,17 +12,17 @@
 #include <faiss/IndexHNSW.h>
 #include <faiss/IndexIDMap.h>
 #include <faiss/IndexIVFFlat.h>
-#include <faiss/IndexLSH.h>
-#include <faiss/IndexScalarQuantizer.h>
-#include <faiss/IndexPQ.h>
 #include <faiss/IndexIVFPQ.h>
 #include <faiss/IndexIVFPQR.h>
+#include <faiss/IndexLSH.h>
+#include <faiss/IndexPQ.h>
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/MetricType.h>
 #include <faiss/index_io.h>
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 namespace Rice::detail {
   template<>
@@ -31,10 +37,10 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    double is_convertible(VALUE value) { return Convertible::Exact; }
+    double is_convertible(VALUE /*value*/) { return Convertible::Exact; }
 
     faiss::MetricType convert(VALUE x) {
-      auto s = Object(x).to_s().str();
+      std::string s = Object(x).to_s().str();
       if (s == "inner_product") {
         return faiss::METRIC_INNER_PRODUCT;
       } else if (s == "l2") {
@@ -60,10 +66,10 @@ namespace Rice::detail {
 
     explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-    double is_convertible(VALUE value) { return Convertible::Exact; }
+    double is_convertible(VALUE /*value*/) { return Convertible::Exact; }
 
     faiss::ScalarQuantizer::QuantizerType convert(VALUE x) {
-      auto s = Object(x).to_s().str();
+      std::string s = Object(x).to_s().str();
       if (s == "qt_8bit") {
         return faiss::ScalarQuantizer::QT_8bit;
       } else if (s == "qt_4bit") {
@@ -92,62 +98,90 @@ void init_index(Rice::Module& m) {
   Rice::define_class_under<faiss::Index>(m, "Index")
     .define_method(
       "d",
-      [](faiss::Index &self) {
+      [](faiss::Index& self) {
         return self.d;
       })
     .define_method(
       "trained?",
-      [](faiss::Index &self) {
+      [](faiss::Index& self) {
         return self.is_trained;
       })
     .define_method(
       "ntotal",
-      [](faiss::Index &self) {
+      [](faiss::Index& self) {
         return self.ntotal;
       })
     .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);
+        auto& self = *Rice::Data_Object<faiss::Index>{rb_self};
+        size_t n = check_shape(objects, self.d);
         self.train(n, objects.read_ptr());
       })
     .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);
+        auto& self = *Rice::Data_Object<faiss::Index>{rb_self};
+        size_t n = check_shape(objects, self.d);
         self.add(n, objects.read_ptr());
       })
     .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);
+        auto& self = *Rice::Data_Object<faiss::Index>{rb_self};
+        size_t n = check_shape(objects, self.d);
         if (ids.ndim() != 1 || ids.shape()[0] != n) {
           throw Rice::Exception(rb_eArgError, "expected ids to be 1d array with size %d", n);
         }
         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");
+        }
+        size_t 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) {
-        auto &self = *Rice::Data_Object<faiss::Index>{rb_self};
-        auto n = check_shape(objects, self.d);
+      [](Rice::Object rb_self, numo::SFloat objects, int64_t k) {
+        auto& self = *Rice::Data_Object<faiss::Index>{rb_self};
+        size_t n = check_shape(objects, self.d);
+        if (k <= 0) {
+          throw Rice::Exception(rb_eArgError, "expected k to be positive");
+        }
+        if (k >= std::numeric_limits<size_t>::max() / n) {
+          throw Rice::Exception(rb_eArgError, "k too large");
+        }
 
-        auto distances = numo::SFloat({n, k});
-        auto labels = numo::Int64({n, k});
+        numo::SFloat distances({n, static_cast<size_t>(k)});
+        numo::Int64 labels({n, static_cast<size_t>(k)});
 
         if (rb_self.is_frozen()) {
+          // Don't mess with Ruby-owned memory while the GVL is released
+          const auto* objects_ptr = objects.read_ptr();
+          std::vector<float> objects_vec(objects_ptr, objects_ptr + n * self.d);
+          std::vector<float> distances_vec(n * static_cast<size_t>(k));
+          std::vector<int64_t> labels_vec(n * static_cast<size_t>(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::ranges::copy(distances_vec, distances.write_ptr());
+          std::ranges::copy(labels_vec, labels.write_ptr());
         } else {
           self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
         }
@@ -160,22 +194,50 @@ 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};
+        auto& self = *Rice::Data_Object<faiss::Index>{rb_self};
         faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
       })
     .define_method(
       "reconstruct",
-      [](faiss::Index &self, int64_t key) {
-        auto d = static_cast<std::size_t>(self.d);
-        auto recons = numo::SFloat({d});
+      [](faiss::Index& self, int64_t key) {
+        auto d = static_cast<size_t>(self.d);
+        numo::SFloat recons({d});
         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<size_t>(ids.shape()[0]);
+        auto d = static_cast<size_t>(self.d);
+        numo::SFloat recons({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<size_t>(self.d);
+        auto n = static_cast<size_t>(ni);
+        numo::SFloat recons({n, d});
+        self.reconstruct_n(i0, ni, recons.write_ptr());
+        return recons;
+      })
     .define_method(
       "save",
-      [](faiss::Index &self, Rice::String fname) {
+      [](faiss::Index& self, Rice::String fname) {
         faiss::write_index(&self, fname.c_str());
       })
     .define_singleton_function(
@@ -221,10 +283,21 @@ void init_index(Rice::Module& m) {
     .define_constructor(Rice::Constructor<faiss::ParameterSpace>())
     .define_method(
       "set_index_parameter",
-      [](faiss::ParameterSpace& self, faiss::Index* index, const std::string& name, double val) {
-        self.set_index_parameter(index, name, val);
+      [](faiss::ParameterSpace& self, faiss::Index* index, Rice::String name, double val) {
+        self.set_index_parameter(index, name.str(), val);
       });
 
   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*>())
+    .define_method(
+      "id_map",
+      [](faiss::IndexIDMap2& self) {
+        size_t n = self.id_map.size();
+        numo::Int64 ids({n});
+        std::ranges::copy(self.id_map, ids.write_ptr());
+        return ids;
+      });
 }

data/ext/faiss/kmeans.cpp

@@ -1,9 +1,12 @@
+#include <algorithm>
+#include <cstddef>
+
 #include <faiss/Clustering.h>
 #include <faiss/IndexFlat.h>
 #include <rice/rice.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 void init_kmeans(Rice::Module& m) {
   Rice::define_class_under<faiss::Clustering>(m, "Kmeans")
@@ -15,27 +18,27 @@ void init_kmeans(Rice::Module& m) {
       })
     .define_method(
       "d",
-      [](faiss::Clustering &self) {
+      [](faiss::Clustering& self) {
         return self.d;
       })
     .define_method(
       "k",
-      [](faiss::Clustering &self) {
+      [](faiss::Clustering& self) {
         return self.k;
       })
     .define_method(
       "centroids",
-      [](faiss::Clustering &self) {
-        auto centroids = numo::SFloat({self.k, self.d});
-        memcpy(centroids.write_ptr(), self.centroids.data(), self.centroids.size() * sizeof(float));
+      [](faiss::Clustering& self) {
+        numo::SFloat centroids({self.k, self.d});
+        std::ranges::copy(self.centroids, centroids.write_ptr());
         return centroids;
       })
     .define_method(
       "train",
       [](Rice::Object rb_self, numo::SFloat objects) {
-        auto &self = *Rice::Data_Object<faiss::Clustering>{rb_self};
-        auto n = check_shape(objects, self.d);
-        auto index = faiss::IndexFlatL2(self.d);
+        auto& self = *Rice::Data_Object<faiss::Clustering>{rb_self};
+        size_t n = check_shape(objects, self.d);
+        faiss::IndexFlatL2 index(self.d);
         rb_self.iv_set("@index", index);
         self.train(n, objects.read_ptr(), index);
       });

data/ext/faiss/numo.hpp

@@ -1,5 +1,5 @@
 /*!
- * Numo.hpp v0.3.0
+ * 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;

data/ext/faiss/pca_matrix.cpp

@@ -1,34 +1,36 @@
+#include <cstddef>
+
 #include <faiss/VectorTransform.h>
 #include <rice/rice.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 void init_pca_matrix(Rice::Module& m) {
   Rice::define_class_under<faiss::PCAMatrix>(m, "PCAMatrix")
     .define_constructor(Rice::Constructor<faiss::PCAMatrix, int, int>())
     .define_method(
       "d_in",
-      [](faiss::PCAMatrix &self) {
+      [](faiss::PCAMatrix& self) {
         return self.d_in;
       })
     .define_method(
       "d_out",
-      [](faiss::PCAMatrix &self) {
+      [](faiss::PCAMatrix& self) {
         return self.d_out;
       })
     .define_method(
       "train",
-      [](faiss::PCAMatrix &self, numo::SFloat objects) {
-        auto n = check_shape(objects, self.d_in);
+      [](faiss::PCAMatrix& self, numo::SFloat objects) {
+        size_t n = check_shape(objects, self.d_in);
         self.train(n, objects.read_ptr());
       })
     .define_method(
       "apply",
-      [](faiss::PCAMatrix &self, numo::SFloat objects) {
-        auto n = check_shape(objects, self.d_in);
+      [](faiss::PCAMatrix& self, numo::SFloat objects) {
+        size_t n = check_shape(objects, self.d_in);
 
-        auto ary = numo::SFloat({n, static_cast<size_t>(self.d_out)});
+        numo::SFloat ary({n, static_cast<size_t>(self.d_out)});
         self.apply_noalloc(n, objects.read_ptr(), ary.write_ptr());
         return ary;
       });