midas-edge 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d4056b117cffbbbf0e5f9f97988789f9b2d53fc78753122ce7a03a45f532eff
-  data.tar.gz: f218bd317db9c4b3a792924e4312e35d84233bcb81198ea0a8f2a2551ef83452
+  metadata.gz: 464c47984f7e61fc4e726a0e4499a56a91d0294ff1b1c2d28f65795d11a7b78b
+  data.tar.gz: 38cc5f7c6a671fc5508c36ae546c92219eb2eba51499b4ff4bf1036acf33d444
 SHA512:
-  metadata.gz: eede2417d3bce099af436eee2fb97497675c7056ae7adf5b496cfaf7e170533242a32f0dcda017c58847eb279af48f2dc1b61bff0bab81e0397250f8200518ed
-  data.tar.gz: 5b2bf24281919ae2f80f460bb7566bdf9d25b8bec145f2b43e59c8abb24a4f30e62c0d5ac2a8b6ecb8561d76e993a0facd6b0b2f177c3cee476daf2809bc4f7c
+  metadata.gz: 44251431f027cf89f46b3c1f51fcc73e72bfe5ae28121e2cf0f6292e622cfc9994fc343452947827c19505ecf5335dd9a22a46280c77dc4914a8e4ec61b21557
+  data.tar.gz: c925fffbd5e8dca94c90f7eb1a5607cc569373e37797d6971eabf022181fb72eaf7c11d23aeee01707c899a0a76663e8897906a93df5f947276b5cda034b85e1

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.1 (2021-05-23)
+
+- Improved performance
+
 ## 0.3.0 (2021-05-17)
 
 - Updated to Rice 4

data/ext/midas/ext.cpp

@@ -11,21 +11,39 @@
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
 
-void load_str(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, const std::string& input, bool directed) {
-  int* input_ptr = (int*) input.data();
-  size_t n = input.size() / sizeof(int);
+// numo
+#include "numo.hpp"
+
+void load_array(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, numo::Int32 input, bool directed) {
+  auto shape = input.shape();
+  if (input.ndim() != 2 || shape[1] != 3) {
+    throw Rice::Exception(rb_eArgError, "Bad shape");
+  }
+
+  auto input_ptr = input.read_ptr();
+  auto n = shape[0];
+  auto sz = input.size();
 
   if (directed) {
-    for (size_t i = 0; i < n; i += 3) {
+    src.reserve(n);
+    dst.reserve(n);
+    times.reserve(n);
+
+    for (size_t i = 0; i < sz; i += 3) {
       src.push_back(input_ptr[i]);
       dst.push_back(input_ptr[i + 1]);
       times.push_back(input_ptr[i + 2]);
     }
   } else {
-    for (size_t i = 0; i < n; i += 3) {
+    src.reserve(n * 2);
+    dst.reserve(n * 2);
+    times.reserve(n * 2);
+
+    for (size_t i = 0; i < sz; i += 3) {
       src.push_back(input_ptr[i]);
       dst.push_back(input_ptr[i + 1]);
       times.push_back(input_ptr[i + 2]);
+
       src.push_back(input_ptr[i + 1]);
       dst.push_back(input_ptr[i]);
       times.push_back(input_ptr[i + 2]);
@@ -36,15 +54,15 @@ void load_str(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& ti
 // load_data from main.cpp
 // modified to throw std::runtime_error when cannot find file
 // instead of exiting
-void load_file(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, const std::string& input_file, bool undirected) {
+void load_file(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, Rice::String input_file, bool directed) {
   FILE* infile = fopen(input_file.c_str(), "r");
   if (infile == NULL) {
-    throw std::runtime_error("Could not read file: " + input_file);
+    throw std::runtime_error("Could not read file: " + input_file.str());
   }
 
   int s, d, t;
 
-  if (undirected == false) {
+  if (directed) {
     while (fscanf(infile, "%d,%d,%d", &s, &d, &t) == 3) {
       src.push_back(s);
       dst.push_back(d);
@@ -55,6 +73,7 @@ void load_file(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& t
       src.push_back(s);
       dst.push_back(d);
       times.push_back(t);
+
       src.push_back(d);
       dst.push_back(s);
       times.push_back(t);
@@ -64,11 +83,12 @@ void load_file(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& t
   fclose(infile);
 }
 
-std::string fit_predict(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, int num_rows, int num_buckets, float factor, float threshold, bool relations, int seed) {
+Rice::Object fit_predict(std::vector<int>& src, std::vector<int>& dst, std::vector<int>& times, int num_rows, int num_buckets, float factor, float threshold, bool relations, int seed) {
   srand(seed);
   size_t n = src.size();
-  std::vector<float> result;
-  result.reserve(n);
+
+  auto ary = numo::SFloat({n});
+  auto result = ary.write_ptr();
 
   if (!std::isnan(threshold)) {
     MIDAS::FilteringCore midas(num_rows, num_buckets, threshold, factor);
@@ -87,8 +107,7 @@ std::string fit_predict(std::vector<int>& src, std::vector<int>& dst, std::vecto
     }
   }
 
-  // std::string copies data
-  return std::string((char*) result.data(), sizeof(float) / sizeof(char) * n);
+  return ary;
 }
 
 extern "C"
@@ -97,17 +116,14 @@ void Init_ext() {
 
   Rice::define_class_under(rb_mMidas, "Detector")
     .define_function(
-      "_fit_predict_str",
-      [](const std::string& input, int num_rows, int num_buckets, float factor, float threshold, bool relations, bool directed, int seed) {
-        std::vector<int> src, dst, times;
-        load_str(src, dst, times, input, directed);
-        return fit_predict(src, dst, times, num_rows, num_buckets, factor, threshold, relations, seed);
-      })
-    .define_function(
-      "_fit_predict_file",
-      [](const std::string& input, int num_rows, int num_buckets, float factor, float threshold, bool relations, bool directed, int seed) {
+      "_fit_predict",
+      [](Rice::Object input, int num_rows, int num_buckets, float factor, float threshold, bool relations, bool directed, int seed) {
         std::vector<int> src, dst, times;
-        load_file(src, dst, times, input, !directed);
+        if (input.is_a(rb_cString)) {
+          load_file(src, dst, times, input, directed);
+        } else {
+          load_array(src, dst, times, input, directed);
+        }
         return fit_predict(src, dst, times, num_rows, num_buckets, factor, threshold, relations, seed);
       });
 }

data/ext/midas/extconf.rb

@@ -1,8 +1,12 @@
 require "mkmf-rice"
 
-$CXXFLAGS << " -std=c++17"
+$CXXFLAGS << " -std=c++17 $(optflags)"
+
+numo = $LOAD_PATH.find { |v| File.exist?("#{v}/numo/numo/narray.h") }
+abort "Numo header not found" unless numo && find_header("numo/narray.h", "#{numo}/numo")
+abort "Numo library not found" if Gem.win_platform? && !find_library("narray", nil, "#{numo}/numo")
 
 midas = File.expand_path("../../vendor/MIDAS/src", __dir__)
-$INCFLAGS << " -I#{midas}"
+abort "Midas not found" unless find_header("NormalCore.hpp", midas)
 
 create_makefile("midas/ext")

data/ext/midas/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();
+    }
+  };
+}

data/lib/midas/detector.rb

@@ -11,18 +11,7 @@ module Midas
     end
 
     def fit_predict(x)
-      threshold = @threshold || Float::NAN
-      result =
-        if x.is_a?(String)
-          _fit_predict_file(x, @rows, @buckets, @alpha, threshold, @relations, @directed, @seed)
-        else
-          x = Numo::Int32.cast(x) unless x.is_a?(Numo::NArray)
-          x = x.cast_to(Numo::Int32) unless x.is_a?(Numo::Int32)
-          raise ArgumentError, "Bad shape: #{x.shape}" unless x.rank == 2 && x.shape[1] == 3
-          _fit_predict_str(x.to_binary, @rows, @buckets, @alpha, threshold, @relations, @directed, @seed)
-        end
-
-      Numo::SFloat.from_binary(result)
+      _fit_predict(x, @rows, @buckets, @alpha, @threshold || Float::NAN, @relations, @directed, @seed)
     end
   end
 end

data/lib/midas/version.rb

@@ -1,3 +1,3 @@
 module Midas
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: midas-edge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-17 00:00:00.000000000 Z
+date: 2021-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -51,6 +51,7 @@ files:
 - README.md
 - ext/midas/ext.cpp
 - ext/midas/extconf.rb
+- ext/midas/numo.hpp
 - lib/midas-edge.rb
 - lib/midas/detector.rb
 - lib/midas/version.rb