faiss 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46b01025b31b0b052236ffb42c9d046de719f2c6ffbdff50299e51f339def739
-  data.tar.gz: 1d50d77f839ad49dd6827776dca2f7eeea25eb333ccac6d86077a4366a085065
+  metadata.gz: 18db7914c6db421beb972845cdf1d6489f179d6347f2cc52252b5908c7dd2db0
+  data.tar.gz: fcbc66c8b544a9f96e913c4e4e3d7a8be8c450d56db0332bc3ea1810776e424b
 SHA512:
-  metadata.gz: ffd3ca8a5726dacc053da5c489f19212399c780fd41048793ebd9785716e934ac3e158a5a1fa09c11723fa12ab172d65166bb12216f245dd01864cef83b4608f
-  data.tar.gz: c485d9b425913d52f3a53c7e229dffa04fe1535de151b2abb5ac2e09a56d4ba4cfcfd8838846eab5b9a18c898115f56fa107640c210001b69ea8fd8a7eac8428
+  metadata.gz: a885807f3c74cb4ce27a5931f7f2b73dc3ec9bd214c06e96d191086a841d1f366e1d8ebbe9af35143c8facd1285070d0f0b46814f5a78d1d55fb0b1821ab3fa3
+  data.tar.gz: f7ec06da8dc75e0341763f15501e2bc503ef3001dee29c88a0b0253ce78c38cb5e5b222ec75b26814a7c9f2a69e02e1ff685f108d3a4512ef8bf55e5a42214ce

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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

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,4 +1,8 @@
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <utility>
 #include <vector>
 
 #include <faiss/IndexBinary.h>
@@ -9,23 +13,23 @@
 #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(
@@ -33,8 +37,8 @@ void init_index_binary(Rice::Module& m) {
       [](Rice::Object rb_self, numo::UInt8 objects) {
         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(
@@ -42,8 +46,8 @@ void init_index_binary(Rice::Module& m) {
       [](Rice::Object rb_self, numo::UInt8 objects) {
         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(
@@ -51,36 +55,42 @@ void init_index_binary(Rice::Module& m) {
       [](Rice::Object rb_self, numo::Int64 ids) {
         check_frozen(rb_self);
 
-        auto &self = *Rice::Data_Object<faiss::IndexBinary>{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];
+        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
-          auto objects_ptr = objects.read_ptr();
+          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 * k);
-          std::vector<int64_t> labels_vec(n * k);
+          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_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());
+          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());
         }
@@ -92,15 +102,15 @@ void init_index_binary(Rice::Module& m) {
       })
     .define_method(
       "reconstruct",
-      [](faiss::IndexBinary &self, int64_t key) {
-        auto d = static_cast<std::size_t>(self.d / 8);
-        auto recons = numo::UInt8({d});
+      [](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) {
+      [](faiss::IndexBinary& self, int64_t i0, int64_t ni) {
         if (ni < 0) {
           throw Rice::Exception(rb_eArgError, "expected n to be non-negative");
         }
@@ -108,15 +118,15 @@ void init_index_binary(Rice::Module& m) {
         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});
+        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,5 +1,9 @@
 #include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include <faiss/AutoTune.h>
@@ -8,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<>
@@ -33,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") {
@@ -62,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") {
@@ -94,17 +98,17 @@ 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(
@@ -112,8 +116,8 @@ void init_index(Rice::Module& m) {
       [](Rice::Object rb_self, numo::SFloat objects) {
         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(
@@ -121,8 +125,8 @@ void init_index(Rice::Module& m) {
       [](Rice::Object rb_self, numo::SFloat objects) {
         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(
@@ -130,8 +134,8 @@ void init_index(Rice::Module& m) {
       [](Rice::Object rb_self, numo::SFloat objects, numo::Int64 ids) {
         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);
         }
@@ -142,36 +146,42 @@ void init_index(Rice::Module& m) {
       [](Rice::Object rb_self, numo::Int64 ids) {
         check_frozen(rb_self);
 
-        auto &self = *Rice::Data_Object<faiss::Index>{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];
+        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
-          auto objects_ptr = objects.read_ptr();
+          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 * k);
-          std::vector<int64_t> labels_vec(n * k);
+          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_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());
+          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());
         }
@@ -186,32 +196,32 @@ void init_index(Rice::Module& m) {
       [](Rice::Object rb_self, double val) {
         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) {
+      [](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});
+        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) {
+      [](faiss::Index& self, int64_t i0, int64_t ni) {
         if (ni < 0) {
           throw Rice::Exception(rb_eArgError, "expected n to be non-negative");
         }
@@ -219,15 +229,15 @@ void init_index(Rice::Module& m) {
         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});
+        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(
@@ -273,13 +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_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,11 +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")
@@ -17,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});
-        std::copy(self.centroids.begin(), self.centroids.end(), centroids.write_ptr());
+      [](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/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;
       });

data/ext/faiss/product_quantizer.cpp

@@ -1,50 +1,52 @@
+#include <cstddef>
+
 #include <faiss/impl/ProductQuantizer.h>
 #include <faiss/index_io.h>
 #include <rice/rice.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 void init_product_quantizer(Rice::Module& m) {
   Rice::define_class_under<faiss::ProductQuantizer>(m, "ProductQuantizer")
     .define_constructor(Rice::Constructor<faiss::ProductQuantizer, size_t, size_t, size_t>())
     .define_method(
       "d",
-      [](faiss::ProductQuantizer &self) {
+      [](faiss::ProductQuantizer& self) {
         return self.d;
       })
     .define_method(
       "m",
-      [](faiss::ProductQuantizer &self) {
+      [](faiss::ProductQuantizer& self) {
         return self.M;
       })
     .define_method(
       "train",
-      [](faiss::ProductQuantizer &self, numo::SFloat objects) {
-        auto n = check_shape(objects, self.d);
+      [](faiss::ProductQuantizer& self, numo::SFloat objects) {
+        size_t n = check_shape(objects, self.d);
         self.train(n, objects.read_ptr());
       })
     .define_method(
       "compute_codes",
-      [](faiss::ProductQuantizer &self, numo::SFloat objects) {
-        auto n = check_shape(objects, self.d);
+      [](faiss::ProductQuantizer& self, numo::SFloat objects) {
+        size_t n = check_shape(objects, self.d);
 
-        auto codes = numo::UInt8({n, self.M});
+        numo::UInt8 codes({n, self.M});
         self.compute_codes(objects.read_ptr(), codes.write_ptr(), n);
         return codes;
       })
     .define_method(
       "decode",
-      [](faiss::ProductQuantizer &self, numo::UInt8 objects) {
-        auto n = check_shape(objects, self.M);
+      [](faiss::ProductQuantizer& self, numo::UInt8 objects) {
+        size_t n = check_shape(objects, self.M);
 
-        auto x = numo::SFloat({n, self.d});
+        numo::SFloat x({n, self.d});
         self.decode(objects.read_ptr(), x.write_ptr(), n);
         return x;
       })
     .define_method(
       "save",
-      [](faiss::ProductQuantizer &self, Rice::String fname) {
+      [](faiss::ProductQuantizer& self, Rice::String fname) {
         faiss::write_ProductQuantizer(&self, fname.c_str());
       })
     .define_singleton_function(

data/ext/faiss/{utils.cpp → utils_rb.cpp}

@@ -1,14 +1,16 @@
+#include <cstddef>
+
 #include <rice/rice.hpp>
 
 #include "numo.hpp"
-#include "utils.h"
+#include "utils_rb.h"
 
 size_t check_shape(const numo::NArray& objects, size_t k) {
-  auto ndim = objects.ndim();
+  size_t ndim = objects.ndim();
   if (ndim != 2) {
     throw Rice::Exception(rb_eArgError, "expected 2 dimensions, not %d", ndim);
   }
-  auto shape = objects.shape();
+  size_t* shape = objects.shape();
   if (shape[1] != k) {
     throw Rice::Exception(rb_eArgError, "expected 2nd dimension to be %d, not %d", k, shape[1]);
   }

data/ext/faiss/{utils.h → utils_rb.h}

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <cstddef>
+
+#include <rice/rice.hpp>
+
 #include "numo.hpp"
 
 size_t check_shape(const numo::NArray& objects, size_t k);