umappp 0.2.3 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f50fd5a0af819b29f30afbf2cad8e059c679b9691b2c42a106724d7c9cb313e3
-  data.tar.gz: d4f583765cc15aec1f4102d35699208cac47df086cea14fd485eb99c15b8a027
+  metadata.gz: c68c5f7c5b926e85a0b1bff33b63b0ed7b8b85ce7d6d5bc2201cfe786257186e
+  data.tar.gz: 6dfad841a2bce23247f695794f9406ec5aa299050093aed7d1a9b1488b43f8aa
 SHA512:
-  metadata.gz: 9a505cbe40f4b059dc2af714759fe1cbcda70cd132fe08fe1e463a20e93c3fa3b8981152116b94e2f5e3ff1aa344959d0f815368c1838cef17cdcdfb6288dce6
-  data.tar.gz: 7798c54f1a7bd98fb3decc32ef779e945b41d3332bd2d3b5a0c58570c084840a2da5c0af57b185d4c57b93d3b49506cb65ac86d5ccb48ba9570ba013b4de71ef
+  metadata.gz: 3af57550e78807e3963268059ae67b2cf47adffd940eac9e4abdd928c981740c4fefa4e7a291b94494426f5d21111f06c712b98322ec03049efeb15ca094e5d7
+  data.tar.gz: 47a32499f18e625e79ca964c0b6ce008717404d7ae7e2cf00050a9de9dcb28e7ccf86c4d118013c82413584e9a6a92c0240405f569a522742cdf582afbe22b20

data/README.md

@@ -12,7 +12,7 @@
 
 - Ruby Umappp is a wrapper library for [C++ Umappp library](https://github.com/LTLA/umappp) created by Aaron Lun
 - Compatible with [yaumap](https://github.com/LTLA/yaumap)
-- Support [Numo::NArray](https://github.com/ruby-numo/numo-narray)
+- Support [Numo::NArray Alternative](https://github.com/yoshoku/numo-narray-alt)
 
 ## Installation
 
@@ -24,7 +24,7 @@ gem install umappp
 
 ## Usage
 
-This Gem provides the module `Umappp` and its singular method `Umappp.run()`. The first argument of `Umappp.run()` is a two-dimensional Ruby array or a two-dimensional Numo array. [Numo](https://github.com/ruby-numo/numo-narray) is a library for performing N-dimensional array computing like NumPy. The argument is converted to `Numo::SFloat`. SFloat is a single precision floating point number type of Numo::NArray.
+This Gem provides the module `Umappp` and its singular method `Umappp.run()`. The first argument of `Umappp.run()` is a two-dimensional Ruby array or a two-dimensional Numo array. [Numo::NArray Alternative](https://github.com/yoshoku/numo-narray-alt) is a library for performing N-dimensional array computing like NumPy. The argument is converted to `Numo::SFloat`. SFloat is a single precision floating point number type of Numo::NArray.
 
 ```ruby
 # Original high-dimensional data as two-dimensional Ruby array or Numo array

data/ext/umappp/extconf.rb

@@ -13,10 +13,13 @@ if have_library("omp") || have_library("gomp")
   $CXXFLAGS += " -fopenmp"
 end
 
-# numo-narray
-numo = File.join(Gem.loaded_specs["numo-narray"].require_path, "numo")
+# numo-narray-alt
+numo = File.join(Gem.loaded_specs["numo-narray-alt"].require_path, "numo")
 abort "Numo header not found" unless find_header("numo/narray.h", numo)
-abort "Numo library not found" if Gem.win_platform? && !find_library("narray", nil, numo)
+if Gem.win_platform?
+  narray_lib_dirs = [numo, File.join(numo, "narray")]
+  abort "Numo library not found" unless find_library("narray", nil, *narray_lib_dirs)
+end
 find_header("numo.hpp", File.expand_path("../../include", __dir__))
 
 dir_config "umap", vendor, vendor

data/ext/umappp/numo.hpp

@@ -1,450 +1,362 @@
 /*!
- * Numo.hpp v0.2.1
+ * Numo.hpp v0.3.1
  * https://github.com/ankane/numo.hpp
  * BSD-2-Clause License
  */
 
 #pragma once
 
+#include <cstddef>
+#include <cstdint>
+#include <initializer_list>
+
 #include <rice/rice.hpp>
+
 #include <numo/narray.h>
 
 namespace numo {
 
-class NArray {
+class NArray : public Rice::Object {
 public:
-  NArray(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
-
-  NArray(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  NArray(VALUE v) : NArray(dtype(), v) { }
 
-  VALUE value() const {
-    return this->_value;
-  }
+  NArray(Rice::Object o) : NArray(dtype(), o.value()) { }
 
   size_t ndim() const {
-    return RNARRAY_NDIM(this->_value);
+    return RNARRAY_NDIM(value());
   }
 
   size_t* shape() const {
-    return RNARRAY_SHAPE(this->_value);
+    return RNARRAY_SHAPE(value());
   }
 
-  size_t size() const {
-    return RNARRAY_SIZE(this->_value);
+  size_t shape(size_t n) const {
+    if (n >= ndim()) {
+      throw std::out_of_range{"index out of range"};
+    }
+    return shape()[n];
   }
 
-  bool is_contiguous() const {
-    return nary_check_contiguous(this->_value) == Qtrue;
+  size_t size() const {
+    return RNARRAY_SIZE(value());
   }
 
-  operator Rice::Object() const {
-    return Rice::Object(this->_value);
+  bool is_contiguous() const {
+    return Rice::detail::protect(nary_check_contiguous, value()) == Qtrue;
   }
 
   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(value())) {
+        set_value(nary_dup(value()));
+      }
+      return nary_get_pointer_for_read(value()) + nary_get_offset(value());
+    });
   }
 
   void* write_ptr() {
-    return nary_get_pointer_for_write(this->_value);
+    return Rice::detail::protect(nary_get_pointer_for_write, value());
   }
 
 protected:
-  NArray() { }
+  NArray(VALUE dtype, VALUE v) : Rice::Object(Rice::detail::protect(rb_funcall, dtype, rb_intern("cast"), 1, v)) { }
 
-  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()));
-  }
+  NArray(VALUE dtype, Rice::Object o) : NArray(dtype, o.value()) { }
 
-  VALUE _value;
+  // rb_narray_new doesn't modify shape, but not marked as const
+  NArray(VALUE dtype, std::initializer_list<size_t> shape) : Rice::Object(Rice::detail::protect(rb_narray_new, dtype, shape.size(), const_cast<size_t*>(shape.begin()))) { }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cNArray;
   }
 };
 
 class SFloat: public NArray {
 public:
-  SFloat(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  SFloat(VALUE v) : NArray(dtype(), v) { }
 
-  SFloat(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  SFloat(Rice::Object o) : NArray(dtype(), o) { }
 
-  SFloat(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  SFloat(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const float* read_ptr() {
-    return reinterpret_cast<const float*>(NArray::read_ptr());
+    return static_cast<const float*>(NArray::read_ptr());
   }
 
   float* write_ptr() {
-    return reinterpret_cast<float*>(NArray::write_ptr());
+    return static_cast<float*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cSFloat;
   }
 };
 
 class DFloat: public NArray {
 public:
-  DFloat(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  DFloat(VALUE v) : NArray(dtype(), v) { }
 
-  DFloat(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  DFloat(Rice::Object o) : NArray(dtype(), o) { }
 
-  DFloat(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  DFloat(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const double* read_ptr() {
-    return reinterpret_cast<const double*>(NArray::read_ptr());
+    return static_cast<const double*>(NArray::read_ptr());
   }
 
   double* write_ptr() {
-    return reinterpret_cast<double*>(NArray::write_ptr());
+    return static_cast<double*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cDFloat;
   }
 };
 
 class Int8: public NArray {
 public:
-  Int8(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  Int8(VALUE v) : NArray(dtype(), v) { }
 
-  Int8(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  Int8(Rice::Object o) : NArray(dtype(), o) { }
 
-  Int8(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  Int8(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const int8_t* read_ptr() {
-    return reinterpret_cast<const int8_t*>(NArray::read_ptr());
+    return static_cast<const int8_t*>(NArray::read_ptr());
   }
 
   int8_t* write_ptr() {
-    return reinterpret_cast<int8_t*>(NArray::write_ptr());
+    return static_cast<int8_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cInt8;
   }
 };
 
 class Int16: public NArray {
 public:
-  Int16(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  Int16(VALUE v) : NArray(dtype(), v) { }
 
-  Int16(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  Int16(Rice::Object o) : NArray(dtype(), o) { }
 
-  Int16(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  Int16(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const int16_t* read_ptr() {
-    return reinterpret_cast<const int16_t*>(NArray::read_ptr());
+    return static_cast<const int16_t*>(NArray::read_ptr());
   }
 
   int16_t* write_ptr() {
-    return reinterpret_cast<int16_t*>(NArray::write_ptr());
+    return static_cast<int16_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cInt16;
   }
 };
 
 class Int32: public NArray {
 public:
-  Int32(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  Int32(VALUE v) : NArray(dtype(), v) { }
 
-  Int32(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  Int32(Rice::Object o) : NArray(dtype(), o) { }
 
-  Int32(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  Int32(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const int32_t* read_ptr() {
-    return reinterpret_cast<const int32_t*>(NArray::read_ptr());
+    return static_cast<const int32_t*>(NArray::read_ptr());
   }
 
   int32_t* write_ptr() {
-    return reinterpret_cast<int32_t*>(NArray::write_ptr());
+    return static_cast<int32_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cInt32;
   }
 };
 
 class Int64: public NArray {
 public:
-  Int64(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  Int64(VALUE v) : NArray(dtype(), v) { }
 
-  Int64(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  Int64(Rice::Object o) : NArray(dtype(), o) { }
 
-  Int64(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  Int64(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const int64_t* read_ptr() {
-    return reinterpret_cast<const int64_t*>(NArray::read_ptr());
+    return static_cast<const int64_t*>(NArray::read_ptr());
   }
 
   int64_t* write_ptr() {
-    return reinterpret_cast<int64_t*>(NArray::write_ptr());
+    return static_cast<int64_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cInt64;
   }
 };
 
 class UInt8: public NArray {
 public:
-  UInt8(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  UInt8(VALUE v) : NArray(dtype(), v) { }
 
-  UInt8(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  UInt8(Rice::Object o) : NArray(dtype(), o) { }
 
-  UInt8(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  UInt8(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const uint8_t* read_ptr() {
-    return reinterpret_cast<const uint8_t*>(NArray::read_ptr());
+    return static_cast<const uint8_t*>(NArray::read_ptr());
   }
 
   uint8_t* write_ptr() {
-    return reinterpret_cast<uint8_t*>(NArray::write_ptr());
+    return static_cast<uint8_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cUInt8;
   }
 };
 
 class UInt16: public NArray {
 public:
-  UInt16(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  UInt16(VALUE v) : NArray(dtype(), v) { }
 
-  UInt16(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  UInt16(Rice::Object o) : NArray(dtype(), o) { }
 
-  UInt16(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  UInt16(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const uint16_t* read_ptr() {
-    return reinterpret_cast<const uint16_t*>(NArray::read_ptr());
+    return static_cast<const uint16_t*>(NArray::read_ptr());
   }
 
   uint16_t* write_ptr() {
-    return reinterpret_cast<uint16_t*>(NArray::write_ptr());
+    return static_cast<uint16_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cUInt16;
   }
 };
 
 class UInt32: public NArray {
 public:
-  UInt32(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  UInt32(VALUE v) : NArray(dtype(), v) { }
 
-  UInt32(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  UInt32(Rice::Object o) : NArray(dtype(), o) { }
 
-  UInt32(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  UInt32(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const uint32_t* read_ptr() {
-    return reinterpret_cast<const uint32_t*>(NArray::read_ptr());
+    return static_cast<const uint32_t*>(NArray::read_ptr());
   }
 
   uint32_t* write_ptr() {
-    return reinterpret_cast<uint32_t*>(NArray::write_ptr());
+    return static_cast<uint32_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cUInt32;
   }
 };
 
 class UInt64: public NArray {
 public:
-  UInt64(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  UInt64(VALUE v) : NArray(dtype(), v) { }
 
-  UInt64(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  UInt64(Rice::Object o) : NArray(dtype(), o) { }
 
-  UInt64(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  UInt64(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const uint64_t* read_ptr() {
-    return reinterpret_cast<const uint64_t*>(NArray::read_ptr());
+    return static_cast<const uint64_t*>(NArray::read_ptr());
   }
 
   uint64_t* write_ptr() {
-    return reinterpret_cast<uint64_t*>(NArray::write_ptr());
+    return static_cast<uint64_t*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cUInt64;
   }
 };
 
 class SComplex: public NArray {
 public:
-  SComplex(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  SComplex(VALUE v) : NArray(dtype(), v) { }
 
-  SComplex(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  SComplex(Rice::Object o) : NArray(dtype(), o) { }
 
-  SComplex(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  SComplex(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cSComplex;
   }
 };
 
 class DComplex: public NArray {
 public:
-  DComplex(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  DComplex(VALUE v) : NArray(dtype(), v) { }
 
-  DComplex(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  DComplex(Rice::Object o) : NArray(dtype(), o) { }
 
-  DComplex(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  DComplex(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cDComplex;
   }
 };
 
 class Bit: public NArray {
 public:
-  Bit(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  Bit(VALUE v) : NArray(dtype(), v) { }
 
-  Bit(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  Bit(Rice::Object o) : NArray(dtype(), o) { }
 
-  Bit(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  Bit(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cBit;
   }
 };
 
 class RObject: public NArray {
 public:
-  RObject(VALUE v) {
-    construct_value(this->dtype(), v);
-  }
+  RObject(VALUE v) : NArray(dtype(), v) { }
 
-  RObject(Rice::Object o) {
-    construct_value(this->dtype(), o.value());
-  }
+  RObject(Rice::Object o) : NArray(dtype(), o) { }
 
-  RObject(std::initializer_list<size_t> shape) {
-    construct_shape(this->dtype(), shape);
-  }
+  RObject(std::initializer_list<size_t> shape) : NArray(dtype(), shape) { }
 
   const VALUE* read_ptr() {
-    return reinterpret_cast<const VALUE*>(NArray::read_ptr());
+    return static_cast<const VALUE*>(NArray::read_ptr());
   }
 
   VALUE* write_ptr() {
-    return reinterpret_cast<VALUE*>(NArray::write_ptr());
+    return static_cast<VALUE*>(NArray::write_ptr());
   }
 
 private:
-  VALUE dtype() {
+  static VALUE dtype() {
     return numo_cRObject;
   }
 };
 
-}
+} // namespace numo
 
 namespace Rice::detail {
 
@@ -460,12 +372,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::NArray>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -506,12 +418,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -552,12 +464,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DFloat>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -598,12 +510,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -644,12 +556,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -690,12 +602,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -736,12 +648,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Int64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -782,12 +694,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt8>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -828,12 +740,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt16>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -874,12 +786,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt32>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -920,12 +832,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::UInt64>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -966,12 +878,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::SComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1012,12 +924,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::DComplex>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1058,12 +970,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::Bit>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1104,12 +1016,12 @@ public:
 
   explicit From_Ruby(Arg* arg) : arg_(arg) { }
 
-  Convertible is_convertible(VALUE value) {
+  double is_convertible(VALUE value) {
     switch (rb_type(value)) {
       case RUBY_T_DATA:
         return Data_Type<numo::RObject>::is_descendant(value) ? Convertible::Exact : Convertible::None;
       case RUBY_T_ARRAY:
-        return Convertible::Cast;
+        return Convertible::Exact;
       default:
         return Convertible::None;
     }
@@ -1138,4 +1050,4 @@ private:
   Arg* arg_ = nullptr;
 };
 
-}
+} // namespace Rice::detail

data/ext/umappp/umappp.cpp

@@ -5,6 +5,7 @@
 
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
+#include <ruby/thread.h>
 #include <exception>
 #include <string>
 #include "numo.hpp"

data/lib/umappp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Umappp
-  VERSION = "0.2.3"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: umappp
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.1
 platform: ruby
 authors:
 - kojix2
@@ -10,7 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: numo-narray
+  name: numo-narray-alt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -29,14 +29,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.5.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.5.0
+        version: '0'
 description: Umappp wrapper for Ruby
 email:
 - 2xijok@gmail.com
@@ -449,14 +449,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Umap for Ruby
 test_files: []