faiss 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6fb14299c0b91d6ddaf74ca2fa2d6895e8621249a5351683b109f35866ab541
-  data.tar.gz: 2ec9d11faf8f3f1af7790d1f39e31cb92d8a79d2539fa7c935dbda63f3052d8c
+  metadata.gz: 04246f7b765dc5680223f91ecc5c0951f6328411dcaf443c4ae88819c17b26a7
+  data.tar.gz: 81698c65e8cca4d7794253775ef06f6e84af005b8dac2872d5d3057a868638ac
 SHA512:
-  metadata.gz: 5afa3a7ca6947fad6f5a4f7693b524411875d212079621bc72bda73df36fdf090fcb566b83248302a83ecb38ee04189c57c812eaad4ffc99f94840eaf3abfd28
-  data.tar.gz: c29cf727d683f82e530ba1788630ae546ddb4470f3145f0a4dd1b6afe31555bb9363dfa52cc2a5e005a077f6e2aae24b3dc1aa44d1ff9c50fc9269987df0ec87
+  metadata.gz: 6ad4dcb525a55f0b6743fddeb856d6132c8a518eb92be3dc2ce57302ff05b921fb3ba517aecc76bde78aa6e8bf11d9199fa97cbfe4f3a00e4d466d47f0cabe14
+  data.tar.gz: b333df087e863c8ee828b66c1611d8576976064419403710b0b238346d46cc58e69f1c2c708e35bdbc995754b02f50a976389bb0eb102273e7b9f92d771ac395

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.2.0 (2021-05-23)
+
+- Improved performance
+- Updated to Rice 4
+- Dropped support for Ruby < 2.6
+
 ## 0.1.7 (2021-03-26)
 
 - Added `IndexScalarQuantizer` and `IndexIVFScalarQuantizer`

data/ext/faiss/ext.cpp

@@ -1,4 +1,4 @@
-#include <rice/Module.hpp>
+#include "utils.h"
 
 void init_index(Rice::Module& m);
 void init_index_binary(Rice::Module& m);

data/ext/faiss/extconf.rb

@@ -4,14 +4,17 @@ 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")
 
-$CXXFLAGS << " -std=c++11 -DFINTEGER=int " << with_config("optflags", "-march=native")
+numo = $LOAD_PATH.find { |v| File.exist?("#{v}/numo/numo/narray.h") }
+abort "Numo not found" unless numo && find_header("numo/narray.h", "#{numo}/numo")
+
+$CXXFLAGS << " -std=c++17 $(optflags) -DFINTEGER=int " << with_config("optflags", "-march=native")
 
 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") }
-$INCFLAGS << " -I#{vendor}"
+abort "Faiss not found" unless find_header("faiss/Index.h", vendor)
 $VPATH << vendor
 
 create_makefile("faiss/ext")

data/ext/faiss/index.cpp

@@ -10,109 +10,142 @@
 #include <faiss/index_io.h>
 #include <faiss/AutoTune.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-
 #include "utils.h"
 
-template<>
-faiss::MetricType from_ruby<faiss::MetricType>(Rice::Object x)
-{
-  auto s = x.to_s().str();
-  if (s == "inner_product") {
-    return faiss::METRIC_INNER_PRODUCT;
-  } else if (s == "l2") {
-    return faiss::METRIC_L2;
-  } else {
-    // TODO throw argument error
-    throw std::runtime_error("Invalid metric: " + s);
-  }
-}
-
-template<>
-faiss::ScalarQuantizer::QuantizerType from_ruby<faiss::ScalarQuantizer::QuantizerType>(Rice::Object x)
-{
-  auto s = x.to_s().str();
-  if (s == "qt_8bit") {
-    return faiss::ScalarQuantizer::QT_8bit;
-  } else if (s == "qt_4bit") {
-    return faiss::ScalarQuantizer::QT_4bit;
-  } else if (s == "qt_8bit_uniform") {
-    return faiss::ScalarQuantizer::QT_8bit_uniform;
-  } else if (s == "qt_4bit_uniform") {
-    return faiss::ScalarQuantizer::QT_4bit_uniform;
-  } else if (s == "qt_fp16") {
-    return faiss::ScalarQuantizer::QT_fp16;
-  } else if (s == "qt_8bit_direct") {
-    return faiss::ScalarQuantizer::QT_8bit_direct;
-  } else if (s == "qt_6bit") {
-    return faiss::ScalarQuantizer::QT_6bit;
-  } else {
-    // TODO throw argument error
-    throw std::runtime_error("Invalid quantizer type: " + s);
-  }
+namespace Rice::detail {
+  template<>
+  struct Type<faiss::MetricType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<faiss::MetricType>
+  {
+  public:
+    From_Ruby() = default;
+
+    From_Ruby(Arg* arg) : arg_(arg)
+    {
+    }
+
+    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;
+      } else if (s == "l2") {
+        return faiss::METRIC_L2;
+      } else {
+        throw Rice::Exception(rb_eArgError, "Invalid metric: %s", s.c_str());
+      }
+    }
+
+  private:
+    Arg* arg_;
+  };
+
+  template<>
+  struct Type<faiss::ScalarQuantizer::QuantizerType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<faiss::ScalarQuantizer::QuantizerType>
+  {
+  public:
+    faiss::ScalarQuantizer::QuantizerType convert(VALUE x)
+    {
+      auto s = Object(x).to_s().str();
+      if (s == "qt_8bit") {
+        return faiss::ScalarQuantizer::QT_8bit;
+      } else if (s == "qt_4bit") {
+        return faiss::ScalarQuantizer::QT_4bit;
+      } else if (s == "qt_8bit_uniform") {
+        return faiss::ScalarQuantizer::QT_8bit_uniform;
+      } else if (s == "qt_4bit_uniform") {
+        return faiss::ScalarQuantizer::QT_4bit_uniform;
+      } else if (s == "qt_fp16") {
+        return faiss::ScalarQuantizer::QT_fp16;
+      } else if (s == "qt_8bit_direct") {
+        return faiss::ScalarQuantizer::QT_8bit_direct;
+      } else if (s == "qt_6bit") {
+        return faiss::ScalarQuantizer::QT_6bit;
+      } else {
+        throw Rice::Exception(rb_eArgError, "Invalid quantizer type: %s", s.c_str());
+      }
+    }
+  };
 }
 
 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",
-      *[](faiss::Index &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.train(n, x);
+      "train",
+      [](faiss::Index &self, numo::SFloat objects) {
+        auto n = check_shape(objects, self.d);
+        self.train(n, objects.read_ptr());
       })
     .define_method(
-      "_add",
-      *[](faiss::Index &self, int64_t n, Rice::Object o) {
-        const float *x = float_array(o);
-        self.add(n, x);
+      "add",
+      [](faiss::Index &self, numo::SFloat objects) {
+        auto n = check_shape(objects, self.d);
+        self.add(n, objects.read_ptr());
       })
     .define_method(
-      "_search",
-      *[](faiss::Index &self, int64_t n, Rice::Object o, int64_t k) {
-        const float *x = float_array(o);
-        float *distances = new float[k * n];
-        int64_t *labels = new int64_t[k * n];
+      "search",
+      [](faiss::Index &self, numo::SFloat objects, size_t k) {
+        auto n = check_shape(objects, self.d);
 
-        self.search(n, x, k, distances, labels);
+        auto distances = numo::SFloat({n, k});
+        auto labels = numo::Int64({n, k});
 
-        auto dstr = result(distances, k * n);
-        auto lstr = result(labels, k * n);
+        self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
 
         Rice::Array ret;
-        ret.push(dstr);
-        ret.push(lstr);
+        ret.push(distances);
+        ret.push(labels);
         return ret;
       })
     .define_method(
       "nprobe=",
-      *[](faiss::Index &self, double val) {
+      [](faiss::Index &self, double val) {
         faiss::ParameterSpace().set_index_parameter(&self, "nprobe", val);
       })
     .define_method(
       "save",
-      *[](faiss::Index &self, const char *fname) {
+      [](faiss::Index &self, const char *fname) {
         faiss::write_index(&self, fname);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "load",
-      *[](const char *fname) {
+      [](const char *fname) {
         return faiss::read_index(fname);
       });
 
@@ -123,10 +156,10 @@ 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, faiss::MetricType>(), Rice::Arg("d"), Rice::Arg("M"), Rice::Arg("metric") = faiss::METRIC_L2);
 
   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, faiss::MetricType>(), Rice::Arg("quantizer"), Rice::Arg("d"), Rice::Arg("nlist"), Rice::Arg("metric") = faiss::METRIC_L2);
 
   Rice::define_class_under<faiss::IndexLSH, faiss::Index>(m, "IndexLSH")
     .define_constructor(Rice::Constructor<faiss::IndexLSH, int64_t, int>());
@@ -141,7 +174,7 @@ 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, 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);
 
   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>());
@@ -150,7 +183,7 @@ 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) {
+      [](faiss::ParameterSpace& self, faiss::Index* index, const std::string& name, double val) {
         self.set_index_parameter(index, name, val);
       });
 }

data/ext/faiss/index_binary.cpp

@@ -4,66 +4,60 @@
 #include <faiss/index_factory.h>
 #include <faiss/index_io.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-
 #include "utils.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",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o) {
-        const uint8_t *x = uint8_array(o);
-        self.train(n, x);
+      "train",
+      [](faiss::IndexBinary &self, numo::UInt8 objects) {
+        auto n = check_shape(objects, self.d / 8);
+        self.train(n, objects.read_ptr());
       })
     .define_method(
-      "_add",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o) {
-        const uint8_t *x = uint8_array(o);
-        self.add(n, x);
+      "add",
+      [](faiss::IndexBinary &self, numo::UInt8 objects) {
+        auto n = check_shape(objects, self.d / 8);
+        self.add(n, objects.read_ptr());
       })
     .define_method(
-      "_search",
-      *[](faiss::IndexBinary &self, int64_t n, Rice::Object o, int64_t k) {
-        const uint8_t *x = uint8_array(o);
-        int32_t *distances = new int32_t[k * n];
-        int64_t *labels = new int64_t[k * n];
+      "search",
+      [](faiss::IndexBinary &self, numo::UInt8 objects, size_t k) {
+        auto n = check_shape(objects, self.d / 8);
 
-        self.search(n, x, k, distances, labels);
+        auto distances = numo::Int32({n, k});
+        auto labels = numo::Int64({n, k});
 
-        auto dstr = result(distances, k * n);
-        auto lstr = result(labels, k * n);
+        self.search(n, objects.read_ptr(), k, distances.write_ptr(), labels.write_ptr());
 
         Rice::Array ret;
-        ret.push(dstr);
-        ret.push(lstr);
+        ret.push(distances);
+        ret.push(labels);
         return ret;
       })
     .define_method(
       "save",
-      *[](faiss::IndexBinary &self, const char *fname) {
+      [](faiss::IndexBinary &self, const char *fname) {
         faiss::write_index_binary(&self, fname);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "load",
-      *[](const char *fname) {
+      [](const char *fname) {
         return faiss::read_index_binary(fname);
       });
 
@@ -73,9 +67,9 @@ void init_index_binary(Rice::Module& m) {
   Rice::define_class_under<faiss::IndexBinaryIVF, faiss::IndexBinary>(m, "IndexBinaryIVF")
     .define_constructor(Rice::Constructor<faiss::IndexBinaryIVF, faiss::IndexBinary*, size_t, size_t>());
 
-  m.define_singleton_method(
+  m.define_singleton_function(
     "index_binary_factory",
-    *[](int d, const char *description) {
+    [](int d, const char *description) {
       return faiss::index_binary_factory(d, description);
     });
 }

data/ext/faiss/kmeans.cpp

@@ -1,36 +1,40 @@
 #include <faiss/Clustering.h>
-
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include <faiss/IndexFlat.h>
 
 #include "utils.h"
 
 void init_kmeans(Rice::Module& m) {
   Rice::define_class_under<faiss::Clustering>(m, "Kmeans")
     .define_constructor(Rice::Constructor<faiss::Clustering, int, int>())
+    .define_method(
+      "index",
+      [](Rice::Object self) {
+        return self.attr_get("@index");
+      })
     .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) {
-        float *centroids = new float[self.k * self.d];
-        for (size_t i = 0; i < self.centroids.size(); i++) {
-          centroids[i] = self.centroids[i];
-        }
-        return result(centroids, self.k * self.d);
+      "centroids",
+      [](faiss::Clustering &self) {
+        auto centroids = numo::SFloat({self.k, self.d});
+        memcpy(centroids.write_ptr(), self.centroids.data(), self.centroids.size() * sizeof(float));
+        return centroids;
       })
     .define_method(
-      "_train",
-      *[](faiss::Clustering &self, int64_t n, Rice::Object o, faiss::Index & index) {
-        const float *x = float_array(o);
-        self.train(n, x, index);
+      "train",
+      [](Rice::Object self, numo::SFloat objects) {
+        auto self_ptr = Rice::detail::From_Ruby<faiss::Clustering*>().convert(self.value());
+        auto n = check_shape(objects, self_ptr->d);
+        auto index = faiss::IndexFlatL2(self_ptr->d);
+        self.iv_set("@index", Rice::Object(Rice::detail::To_Ruby<faiss::IndexFlatL2>().convert(index)));
+        self_ptr->train(n, objects.read_ptr(), index);
       });
 }

data/ext/faiss/numo.hpp

@@ -0,0 +1,867 @@
+/*!
+ * Numo.hpp v0.1.0
+ * https://github.com/ankane/numo.hpp
+ * BSD-2-Clause License
+ */
+
+#pragma once
+
+#include <rice/rice.hpp>
+#include <numo/narray.h>
+
+namespace numo {
+  class NArray {
+  public:
+    NArray(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    NArray(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    VALUE value() const {
+      return this->_value;
+    }
+
+    size_t ndim() {
+      return RNARRAY_NDIM(this->_value);
+    }
+
+    size_t* shape() {
+      return RNARRAY_SHAPE(this->_value);
+    }
+
+    size_t size() {
+      return RNARRAY_SIZE(this->_value);
+    }
+
+    bool is_contiguous() {
+      return nary_check_contiguous(this->_value) == Qtrue;
+    }
+
+    operator Rice::Object() const {
+      return Rice::Object(this->_value);
+    }
+
+    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);
+    }
+
+    void* write_ptr() {
+      return 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);
+    }
+
+    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()));
+    }
+
+    VALUE _value;
+
+  private:
+    VALUE dtype() {
+      return numo_cNArray;
+    }
+  };
+
+  class SFloat: public NArray {
+  public:
+    SFloat(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    SFloat(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    SFloat(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const float* read_ptr() {
+      return reinterpret_cast<const float*>(NArray::read_ptr());
+    }
+
+    float* write_ptr() {
+      return reinterpret_cast<float*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cSFloat;
+    }
+  };
+
+  class DFloat: public NArray {
+  public:
+    DFloat(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    DFloat(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    DFloat(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const double* read_ptr() {
+      return reinterpret_cast<const double*>(NArray::read_ptr());
+    }
+
+    double* write_ptr() {
+      return reinterpret_cast<double*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cDFloat;
+    }
+  };
+
+  class Int8: public NArray {
+  public:
+    Int8(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    Int8(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    Int8(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const int8_t* read_ptr() {
+      return reinterpret_cast<const int8_t*>(NArray::read_ptr());
+    }
+
+    int8_t* write_ptr() {
+      return reinterpret_cast<int8_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cInt8;
+    }
+  };
+
+  class Int16: public NArray {
+  public:
+    Int16(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    Int16(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    Int16(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const int16_t* read_ptr() {
+      return reinterpret_cast<const int16_t*>(NArray::read_ptr());
+    }
+
+    int16_t* write_ptr() {
+      return reinterpret_cast<int16_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cInt16;
+    }
+  };
+
+  class Int32: public NArray {
+  public:
+    Int32(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    Int32(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    Int32(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const int32_t* read_ptr() {
+      return reinterpret_cast<const int32_t*>(NArray::read_ptr());
+    }
+
+    int32_t* write_ptr() {
+      return reinterpret_cast<int32_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cInt32;
+    }
+  };
+
+  class Int64: public NArray {
+  public:
+    Int64(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    Int64(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    Int64(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const int64_t* read_ptr() {
+      return reinterpret_cast<const int64_t*>(NArray::read_ptr());
+    }
+
+    int64_t* write_ptr() {
+      return reinterpret_cast<int64_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cInt64;
+    }
+  };
+
+  class UInt8: public NArray {
+  public:
+    UInt8(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    UInt8(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    UInt8(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const uint8_t* read_ptr() {
+      return reinterpret_cast<const uint8_t*>(NArray::read_ptr());
+    }
+
+    uint8_t* write_ptr() {
+      return reinterpret_cast<uint8_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cUInt8;
+    }
+  };
+
+  class UInt16: public NArray {
+  public:
+    UInt16(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    UInt16(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    UInt16(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const uint16_t* read_ptr() {
+      return reinterpret_cast<const uint16_t*>(NArray::read_ptr());
+    }
+
+    uint16_t* write_ptr() {
+      return reinterpret_cast<uint16_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cUInt16;
+    }
+  };
+
+  class UInt32: public NArray {
+  public:
+    UInt32(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    UInt32(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    UInt32(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const uint32_t* read_ptr() {
+      return reinterpret_cast<const uint32_t*>(NArray::read_ptr());
+    }
+
+    uint32_t* write_ptr() {
+      return reinterpret_cast<uint32_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cUInt32;
+    }
+  };
+
+  class UInt64: public NArray {
+  public:
+    UInt64(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    UInt64(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    UInt64(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const uint64_t* read_ptr() {
+      return reinterpret_cast<const uint64_t*>(NArray::read_ptr());
+    }
+
+    uint64_t* write_ptr() {
+      return reinterpret_cast<uint64_t*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cUInt64;
+    }
+  };
+
+  class SComplex: public NArray {
+  public:
+    SComplex(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    SComplex(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    SComplex(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cSComplex;
+    }
+  };
+
+  class DComplex: public NArray {
+  public:
+    DComplex(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    DComplex(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    DComplex(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cDComplex;
+    }
+  };
+
+  class Bit: public NArray {
+  public:
+    Bit(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    Bit(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    Bit(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cBit;
+    }
+  };
+
+  class RObject: public NArray {
+  public:
+    RObject(VALUE v) {
+      construct_value(this->dtype(), v);
+    }
+
+    RObject(Rice::Object o) {
+      construct_value(this->dtype(), o.value());
+    }
+
+    RObject(std::initializer_list<size_t> shape) {
+      construct_shape(this->dtype(), shape);
+    }
+
+    const VALUE* read_ptr() {
+      return reinterpret_cast<const VALUE*>(NArray::read_ptr());
+    }
+
+    VALUE* write_ptr() {
+      return reinterpret_cast<VALUE*>(NArray::write_ptr());
+    }
+
+  private:
+    VALUE dtype() {
+      return numo_cRObject;
+    }
+  };
+}
+
+namespace Rice::detail {
+  template<>
+  struct Type<numo::NArray>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::NArray>
+  {
+  public:
+    numo::NArray convert(VALUE x)
+    {
+      return numo::NArray(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::NArray>
+  {
+  public:
+    VALUE convert(const numo::NArray& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::SFloat>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::SFloat>
+  {
+  public:
+    numo::SFloat convert(VALUE x)
+    {
+      return numo::SFloat(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::SFloat>
+  {
+  public:
+    VALUE convert(const numo::SFloat& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::DFloat>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::DFloat>
+  {
+  public:
+    numo::DFloat convert(VALUE x)
+    {
+      return numo::DFloat(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::DFloat>
+  {
+  public:
+    VALUE convert(const numo::DFloat& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::Int8>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::Int8>
+  {
+  public:
+    numo::Int8 convert(VALUE x)
+    {
+      return numo::Int8(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::Int8>
+  {
+  public:
+    VALUE convert(const numo::Int8& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::Int16>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::Int16>
+  {
+  public:
+    numo::Int16 convert(VALUE x)
+    {
+      return numo::Int16(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::Int16>
+  {
+  public:
+    VALUE convert(const numo::Int16& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::Int32>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::Int32>
+  {
+  public:
+    numo::Int32 convert(VALUE x)
+    {
+      return numo::Int32(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::Int32>
+  {
+  public:
+    VALUE convert(const numo::Int32& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::Int64>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::Int64>
+  {
+  public:
+    numo::Int64 convert(VALUE x)
+    {
+      return numo::Int64(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::Int64>
+  {
+  public:
+    VALUE convert(const numo::Int64& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::UInt8>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::UInt8>
+  {
+  public:
+    numo::UInt8 convert(VALUE x)
+    {
+      return numo::UInt8(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::UInt8>
+  {
+  public:
+    VALUE convert(const numo::UInt8& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::UInt16>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::UInt16>
+  {
+  public:
+    numo::UInt16 convert(VALUE x)
+    {
+      return numo::UInt16(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::UInt16>
+  {
+  public:
+    VALUE convert(const numo::UInt16& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::UInt32>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::UInt32>
+  {
+  public:
+    numo::UInt32 convert(VALUE x)
+    {
+      return numo::UInt32(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::UInt32>
+  {
+  public:
+    VALUE convert(const numo::UInt32& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::UInt64>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::UInt64>
+  {
+  public:
+    numo::UInt64 convert(VALUE x)
+    {
+      return numo::UInt64(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::UInt64>
+  {
+  public:
+    VALUE convert(const numo::UInt64& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::SComplex>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::SComplex>
+  {
+  public:
+    numo::SComplex convert(VALUE x)
+    {
+      return numo::SComplex(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::SComplex>
+  {
+  public:
+    VALUE convert(const numo::SComplex& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::DComplex>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::DComplex>
+  {
+  public:
+    numo::DComplex convert(VALUE x)
+    {
+      return numo::DComplex(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::DComplex>
+  {
+  public:
+    VALUE convert(const numo::DComplex& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::Bit>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::Bit>
+  {
+  public:
+    numo::Bit convert(VALUE x)
+    {
+      return numo::Bit(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::Bit>
+  {
+  public:
+    VALUE convert(const numo::Bit& x) {
+      return x.value();
+    }
+  };
+
+  template<>
+  struct Type<numo::RObject>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<numo::RObject>
+  {
+  public:
+    numo::RObject convert(VALUE x)
+    {
+      return numo::RObject(x);
+    }
+  };
+
+  template<>
+  class To_Ruby<numo::RObject>
+  {
+  public:
+    VALUE convert(const numo::RObject& x) {
+      return x.value();
+    }
+  };
+}