faiss 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67b63e8dcaa5dcd8c8d08f823c3e1e063906b4a20ad70b28c2fd396e8cccdf48
-  data.tar.gz: 7e9fddc693db40a58c71b5a5ca6b89638b5cc1db708b30ea32a897519d48b970
+  metadata.gz: 61316c4fa0bbf7f85dfaeb6890d75b35e20e013a5ed25b8d87a3d252dfea2f50
+  data.tar.gz: af0de6135077f184092dbfec00f9bf7492eb38da66d5ef5f4f2d020ce0486648
 SHA512:
-  metadata.gz: 10b9b0efa35ab53fefd3cea964339c856b67af1f7c773f421952f247d16fbd50d76b29cf59eec9e3b77b1a091e96fccb58c1f24afde7d233f298f06ecc90b3b3
-  data.tar.gz: 70037e0611a6f6adddf30f95710b0e1f1c17ffadfe561c3010db8e66265692da17b49a07756ee946d70eed6602ddfbd2107248c01be353d58d3544b6bbc2b15e
+  metadata.gz: 6d21e6186d57eec3852ab285f0bcd89affacb56577c661b514763478ef6d610f808a7d1e4cbc062278aec6cbc11959b204de237b9669dcfb58de4b3070be2c1e
+  data.tar.gz: a65646746c2f558b48285d8c192d246ce4a95cead1f4413349e8eac4393ac4aa47ad3919764e7caa1abf517edb57153e385d7a012a3dbb22258a98c2795aa5b1

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.3 (2025-10-26)
+
+- Fixed error with Rice 4.7
+
 ## 0.4.2 (2025-08-13)
 
 - Updated Faiss to 1.12.0

data/ext/faiss/index.cpp

@@ -29,7 +29,7 @@ namespace Rice::detail {
   public:
     From_Ruby() = default;
 
-    From_Ruby(Arg* arg) : arg_(arg) {}
+    explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
     Convertible is_convertible(VALUE value) { return Convertible::Cast; }
 
@@ -49,7 +49,7 @@ namespace Rice::detail {
     }
 
   private:
-    Arg* arg_;
+    Arg* arg_ = nullptr;
   };
 
   template<>
@@ -60,6 +60,10 @@ namespace Rice::detail {
   template<>
   class From_Ruby<faiss::ScalarQuantizer::QuantizerType> {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
     Convertible is_convertible(VALUE value) { return Convertible::Cast; }
 
     faiss::ScalarQuantizer::QuantizerType convert(VALUE x) {
@@ -82,6 +86,9 @@ namespace Rice::detail {
         throw Rice::Exception(rb_eArgError, "Invalid quantizer type: %s", s.c_str());
       }
     }
+
+  private:
+    Arg* arg_ = nullptr;
   };
 } // namespace Rice::detail
 
@@ -134,8 +141,8 @@ void init_index(Rice::Module& m) {
         self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
 
         Rice::Array ret;
-        ret.push(distances);
-        ret.push(labels);
+        ret.push(std::move(distances), false);
+        ret.push(std::move(labels), false);
         return ret;
       })
     .define_method(

data/ext/faiss/index_binary.cpp

@@ -48,8 +48,8 @@ void init_index_binary(Rice::Module& m) {
         self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
 
         Rice::Array ret;
-        ret.push(distances);
-        ret.push(labels);
+        ret.push(std::move(distances), false);
+        ret.push(std::move(labels), false);
         return ret;
       })
     .define_method(

data/ext/faiss/numo.hpp

@@ -1,5 +1,5 @@
 /*!
- * Numo.hpp v0.2.0
+ * Numo.hpp v0.2.1
  * https://github.com/ankane/numo.hpp
  * BSD-2-Clause License
  */
@@ -444,23 +444,24 @@ private:
   }
 };
 
-}
+} // namespace numo
 
 namespace Rice::detail {
 
 template<>
-struct Type<numo::NArray>
-{
+struct Type<numo::NArray> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::NArray>
-{
+class From_Ruby<numo::NArray> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -473,30 +474,40 @@ public:
   numo::NArray convert(VALUE x) {
     return numo::NArray(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::NArray>
-{
+class To_Ruby<numo::NArray> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::NArray& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::SFloat>
-{
+struct Type<numo::SFloat> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::SFloat>
-{
+class From_Ruby<numo::SFloat> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -509,30 +520,40 @@ public:
   numo::SFloat convert(VALUE x) {
     return numo::SFloat(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::SFloat>
-{
+class To_Ruby<numo::SFloat> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::SFloat& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::DFloat>
-{
+struct Type<numo::DFloat> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::DFloat>
-{
+class From_Ruby<numo::DFloat> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -545,30 +566,40 @@ public:
   numo::DFloat convert(VALUE x) {
     return numo::DFloat(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::DFloat>
-{
+class To_Ruby<numo::DFloat> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::DFloat& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int8>
-{
+struct Type<numo::Int8> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int8>
-{
+class From_Ruby<numo::Int8> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -581,30 +612,40 @@ public:
   numo::Int8 convert(VALUE x) {
     return numo::Int8(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int8>
-{
+class To_Ruby<numo::Int8> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int8& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int16>
-{
+struct Type<numo::Int16> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int16>
-{
+class From_Ruby<numo::Int16> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -617,30 +658,40 @@ public:
   numo::Int16 convert(VALUE x) {
     return numo::Int16(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int16>
-{
+class To_Ruby<numo::Int16> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int16& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int32>
-{
+struct Type<numo::Int32> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int32>
-{
+class From_Ruby<numo::Int32> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -653,30 +704,40 @@ public:
   numo::Int32 convert(VALUE x) {
     return numo::Int32(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int32>
-{
+class To_Ruby<numo::Int32> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int32& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Int64>
-{
+struct Type<numo::Int64> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Int64>
-{
+class From_Ruby<numo::Int64> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -689,30 +750,40 @@ public:
   numo::Int64 convert(VALUE x) {
     return numo::Int64(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Int64>
-{
+class To_Ruby<numo::Int64> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Int64& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt8>
-{
+struct Type<numo::UInt8> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt8>
-{
+class From_Ruby<numo::UInt8> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -725,30 +796,40 @@ public:
   numo::UInt8 convert(VALUE x) {
     return numo::UInt8(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt8>
-{
+class To_Ruby<numo::UInt8> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt8& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt16>
-{
+struct Type<numo::UInt16> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt16>
-{
+class From_Ruby<numo::UInt16> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -761,30 +842,40 @@ public:
   numo::UInt16 convert(VALUE x) {
     return numo::UInt16(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt16>
-{
+class To_Ruby<numo::UInt16> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt16& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt32>
-{
+struct Type<numo::UInt32> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt32>
-{
+class From_Ruby<numo::UInt32> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -797,30 +888,40 @@ public:
   numo::UInt32 convert(VALUE x) {
     return numo::UInt32(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt32>
-{
+class To_Ruby<numo::UInt32> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt32& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::UInt64>
-{
+struct Type<numo::UInt64> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::UInt64>
-{
+class From_Ruby<numo::UInt64> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -833,30 +934,40 @@ public:
   numo::UInt64 convert(VALUE x) {
     return numo::UInt64(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::UInt64>
-{
+class To_Ruby<numo::UInt64> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::UInt64& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::SComplex>
-{
+struct Type<numo::SComplex> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::SComplex>
-{
+class From_Ruby<numo::SComplex> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -869,30 +980,40 @@ public:
   numo::SComplex convert(VALUE x) {
     return numo::SComplex(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::SComplex>
-{
+class To_Ruby<numo::SComplex> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::SComplex& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::DComplex>
-{
+struct Type<numo::DComplex> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::DComplex>
-{
+class From_Ruby<numo::DComplex> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -905,30 +1026,40 @@ public:
   numo::DComplex convert(VALUE x) {
     return numo::DComplex(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::DComplex>
-{
+class To_Ruby<numo::DComplex> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::DComplex& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::Bit>
-{
+struct Type<numo::Bit> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::Bit>
-{
+class From_Ruby<numo::Bit> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -941,30 +1072,40 @@ public:
   numo::Bit convert(VALUE x) {
     return numo::Bit(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::Bit>
-{
+class To_Ruby<numo::Bit> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::Bit& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-struct Type<numo::RObject>
-{
+struct Type<numo::RObject> {
   static bool verify() { return true; }
 };
 
 template<>
-class From_Ruby<numo::RObject>
-{
+class From_Ruby<numo::RObject> {
 public:
+  From_Ruby() = default;
+
+  explicit From_Ruby(Arg* arg) : arg_(arg) { }
+
   Convertible is_convertible(VALUE value) {
-    switch (rb_type(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:
@@ -977,15 +1118,24 @@ public:
   numo::RObject convert(VALUE x) {
     return numo::RObject(x);
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
 template<>
-class To_Ruby<numo::RObject>
-{
+class To_Ruby<numo::RObject> {
 public:
+  To_Ruby() = default;
+
+  explicit To_Ruby(Arg* arg) : arg_(arg) { }
+
   VALUE convert(const numo::RObject& x) {
     return x.value();
   }
+
+private:
+  Arg* arg_ = nullptr;
 };
 
-}
+} // namespace Rice::detail

data/lib/faiss/version.rb

@@ -1,3 +1,3 @@
 module Faiss
-  VERSION = "0.4.2"
+  VERSION = "0.4.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: faiss
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Andrew Kane
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.5'
+        version: '4.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.5'
+        version: '4.7'
 - !ruby/object:Gem::Dependency
   name: numo-narray
   requirement: !ruby/object:Gem::Requirement