midas-edge 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d21103c3d31faae0c5a22a3909c2594b9d406ca6d971927b59955821517b477
-  data.tar.gz: 07450a43b2ad27bda97545b813cc0766c55802e2ef565d1387de0a5f7307c04c
+  metadata.gz: 21c556323034482b687c06ff507a7af020c5bdacf48bf9bd9ebc5c691ea79b1c
+  data.tar.gz: c9686a23cf785e7cea85d2eb4bb41243a49eac3420697d0e7eaa1be39272e26d
 SHA512:
-  metadata.gz: 0db11f6d7de5d528d81b180b5e759ec36e794ebce62ddcf748c2db9f502ac0c4b6f95673b197f30c48564baeb36a6089b4f3ef599249070088a4057f03b57b51
-  data.tar.gz: a7a886546d177686b173e8fe2b70af54c67ce265095304190442d5bb740386082f673c58d43a1416540d5c8e2fb31440b863fe9447be621e73e727debd2dd22d
+  metadata.gz: d895acee325aa21bdedcf295eaeb8a2993f62f383a2979eb1de14328f7dc8002dd06df068b2753068b43ee0d0adbf104925edc2eeafdbf5dbd1bccf6d7ede50b
+  data.tar.gz: b2bc93ca791413e1eccab0a08d99d01a1bfeea05966b31a9ff05a003cf61d1c0b6a3eb28e197d3be33fe93d2af96c8e2fc3f42afb9517f2979b6422eb1b9c117

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.6.0 (2026-04-07)
+
+- Added `update` and `batch_update` methods
+- Moved `directed` option to `fit_predict` and `partial_fit_predict` methods
+- Removed dependency on `numo-narray`
+- Dropped support for Ruby < 3.3
+
 ## 0.5.1 (2026-02-07)
 
 - Added `partial_fit_predict` method

data/README.md

@@ -1,6 +1,6 @@
 # MIDAS Ruby
 
-[MIDAS](https://github.com/bhatiasiddharth/MIDAS) - edge stream anomaly detection - for Ruby
+[MIDAS](https://github.com/Stream-AD/MIDAS) - edge stream anomaly detection - for Ruby
 
 [![Build Status](https://github.com/ankane/midas-ruby/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/midas-ruby/actions)
 
@@ -14,67 +14,46 @@ gem "midas-edge"
 
 ## Getting Started
 
-Prep your data in the format `[source, destination, time]` (all integers) and sorted by time (ascending)
+Create a detector
 
 ```ruby
-data = [
-  [2, 3, 1],
-  [3, 4, 2],
-  [5, 9, 2],
-  [2, 3, 3]
-]
+midas = Midas::Detector.new
 ```
 
-Get anomaly scores
+Update with an event
 
 ```ruby
-midas = Midas.new
-scores = midas.fit_predict(data)
+score = midas.update(source_id, destination_id, time)
 ```
 
-Higher scores are more anomalous. There is [not currently](https://github.com/Stream-AD/MIDAS/issues/4) a defined threshold for anomalies.
+IDs should be integers and events should be ordered by time (ascending). Higher scores are more anomalous. There is [not currently](https://github.com/Stream-AD/MIDAS/issues/4) a defined threshold for anomalies.
 
 ## Parameters
 
 Pass parameters - default values below
 
 ```ruby
-Midas.new(
+Midas::Detector.new(
   rows: 2,           # number of hash functions
   buckets: 769,      # number of buckets
   alpha: 0.5,        # temporal decay factor
   threshold: nil,    # todo
   relations: true,   # whether to use MIDAS-R or MIDAS
-  directed: true,    # treat the graph as directed or undirected
   seed: 0            # random seed
 )
 ```
 
-## Data
-
-Data can be an array of arrays
-
-```ruby
-[[1, 2, 3], [4, 5, 6]]
-```
-
-Or a Numo array
-
-```ruby
-Numo::NArray.cast([[1, 2, 3], [4, 5, 6]])
-```
-
 ## Performance
 
 For large datasets, read data directly from files
 
 ```ruby
-midas.fit_predict("data.csv")
+midas.batch_update("data.csv")
 ```
 
 ## Resources
 
-- [MIDAS: Microcluster-Based Detector of Anomalies in Edge Streams](https://www.comp.nus.edu.sg/~sbhatia/assets/pdf/midas.pdf)
+- [MIDAS: Microcluster-Based Detector of Anomalies in Edge Streams](https://arxiv.org/pdf/1911.04464)
 
 ## History
 

data/ext/midas/ext.cpp

@@ -1,7 +1,8 @@
 // stdlib
-#include <cstdio>
-#include <iostream>
-#include <vector>
+#include <cstddef>
+#include <cstdlib>
+#include <fstream>
+#include <string>
 
 // midas
 #include <FilteringCore.hpp>
@@ -10,91 +11,42 @@
 
 // rice
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
-// numo
-#include "numo.hpp"
-
-template<typename T>
-void load_array(T& midas, Rice::Array input, bool directed, std::vector<float>& result) {
-  for (auto r : input) {
-    Rice::Array row(r);
-    if (row.size() != 3) {
-      throw Rice::Exception(rb_eArgError, "Bad shape");
-    }
-    int s = Rice::detail::From_Ruby<int>().convert(row[0].value());
-    int d = Rice::detail::From_Ruby<int>().convert(row[1].value());
-    int t = Rice::detail::From_Ruby<int>().convert(row[2].value());
-    result.push_back(midas(s, d, t));
-    if (!directed) {
-      result.push_back(midas(d, s, t));
-    }
-  }
-}
-
-template<typename T>
-void load_numo_array(T& midas, numo::Int32 input, bool directed, std::vector<float>& result) {
-  auto shape = input.shape();
-  if (input.ndim() == 1 && shape[0] == 0) {
-    return;
-  }
-  if (input.ndim() != 2 || shape[1] != 3) {
-    throw Rice::Exception(rb_eArgError, "Bad shape");
-  }
-
-  auto sz = input.size();
-  auto input_ptr = input.read_ptr();
-  for (size_t i = 0; i < sz; i += 3) {
-    int s = input_ptr[i];
-    int d = input_ptr[i + 1];
-    int t = input_ptr[i + 2];
-    result.push_back(midas(s, d, t));
-    if (!directed) {
-      result.push_back(midas(d, s, t));
-    }
-  }
-}
 
 // load_data from main.cpp
 // modified to throw std::runtime_error when cannot find file
 // instead of exiting
 template<typename T>
-void load_file(T& midas, Rice::String input_file, bool directed, std::vector<float>& result) {
-  FILE* infile = fopen(input_file.c_str(), "r");
-  if (infile == NULL) {
-    throw std::runtime_error("Could not read file: " + input_file.str());
+Rice::Array update_file(T& midas, Rice::String input_file, bool directed) {
+  std::ifstream infile(input_file.str());
+  if (!infile.is_open()) {
+    throw std::runtime_error{"Could not read file: " + input_file.str()};
   }
 
-  int s, d, t;
-  while (fscanf(infile, "%d,%d,%d", &s, &d, &t) == 3) {
-    result.push_back(midas(s, d, t));
-    if (!directed) {
-      result.push_back(midas(d, s, t));
+  Rice::Array result;
+  std::string line;
+
+  while (std::getline(infile, line)) {
+    size_t n = line.find(',');
+    if (n == std::string::npos) {
+      throw std::runtime_error{"Invalid line"};
     }
-  }
 
-  fclose(infile);
-}
+    size_t n2 = line.find(',', n + 1);
+    if (n2 == std::string::npos) {
+      throw std::runtime_error{"Invalid line"};
+    }
 
-template<typename T>
-Rice::Object fit_predict(T& midas, Rice::Object input, bool directed) {
-  std::vector<float> result;
-  if (input.is_a(rb_cString)) {
-    load_file(midas, input, directed, result);
-  // TODO uncomment in 0.6.0
-  // } else if (input.is_instance_of(rb_cArray)) {
-  //   load_array(midas, input, directed, result);
-  } else {
-    load_numo_array(midas, input, directed, result);
-  }
+    int s = std::stoi(line.substr(0, n));
+    int d = std::stoi(line.substr(n + 1, n2 - n - 1));
+    int t = std::stoi(line.substr(n2 + 1));
 
-  size_t n = result.size();
-  auto ary = numo::SFloat({n});
-  auto out = ary.write_ptr();
-  for (size_t i = 0; i < n; i++) {
-    out[i] = result[i];
+    result.push(midas(s, d, t), false);
+    if (!directed) {
+      result.push(midas(d, s, t), false);
+    }
   }
-  return ary;
+
+  return result;
 }
 
 extern "C"
@@ -106,30 +58,45 @@ void Init_ext() {
     .define_function(
       "_set_seed",
       [](int seed) {
-        srand(seed);
+        std::srand(seed);
       });
 
   Rice::define_class_under<MIDAS::NormalCore>(rb_mMidas, "NormalCore")
     .define_constructor(Rice::Constructor<MIDAS::NormalCore, int, int>())
     .define_method(
-      "fit_predict",
-      [](MIDAS::NormalCore& self, Rice::Object input, bool directed) {
-        return fit_predict(self, input, directed);
+      "update",
+      [](MIDAS::NormalCore& self, int source, int destination, int time) {
+        return self(source, destination, time);
+      })
+    .define_method(
+      "update_file",
+      [](MIDAS::NormalCore& self, Rice::String input, bool directed) {
+        return update_file(self, input, directed);
       });
 
   Rice::define_class_under<MIDAS::RelationalCore>(rb_mMidas, "RelationalCore")
     .define_constructor(Rice::Constructor<MIDAS::RelationalCore, int, int, float>())
     .define_method(
-      "fit_predict",
-      [](MIDAS::RelationalCore& self, Rice::Object input, bool directed) {
-        return fit_predict(self, input, directed);
+      "update",
+      [](MIDAS::RelationalCore& self, int source, int destination, int time) {
+        return self(source, destination, time);
+      })
+    .define_method(
+      "update_file",
+      [](MIDAS::RelationalCore& self, Rice::String input, bool directed) {
+        return update_file(self, input, directed);
       });
 
   Rice::define_class_under<MIDAS::FilteringCore>(rb_mMidas, "FilteringCore")
     .define_constructor(Rice::Constructor<MIDAS::FilteringCore, int, int, float, float>())
     .define_method(
-      "fit_predict",
-      [](MIDAS::FilteringCore& self, Rice::Object input, bool directed) {
-        return fit_predict(self, input, directed);
+      "update",
+      [](MIDAS::FilteringCore& self, int source, int destination, int time) {
+        return self(source, destination, time);
+      })
+    .define_method(
+      "update_file",
+      [](MIDAS::FilteringCore& self, Rice::String input, bool directed) {
+        return update_file(self, input, directed);
       });
 }

data/ext/midas/extconf.rb

@@ -1,15 +1,7 @@
 require "mkmf-rice"
-require "numo/narray"
 
 $CXXFLAGS << " -std=c++17 $(optflags)"
 
-numo = File.join(Gem.loaded_specs["numo-narray"].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)
-
-# for https://bugs.ruby-lang.org/issues/19005
-$LDFLAGS += " -Wl,-undefined,dynamic_lookup" if RbConfig::CONFIG["host_os"] =~ /darwin/i
-
 midas = File.expand_path("../../vendor/MIDAS/src", __dir__)
 abort "Midas not found" unless find_header("NormalCore.hpp", midas)
 

data/lib/midas/detector.rb

@@ -6,7 +6,6 @@ module Midas
       alpha: 0.5,
       threshold: nil,
       relations: true,
-      directed: true,
       seed: 0
     )
       @rows = rows
@@ -14,19 +13,39 @@ module Midas
       @alpha = alpha
       @threshold = threshold
       @relations = relations
-      @directed = directed
       @seed = seed
     end
 
-    def fit_predict(x)
-      @core = nil # reset core
-      partial_fit_predict(x)
+    def update(source, destination, time)
+      @core ||= core
+      @core.update(source, destination, time.to_i)
     end
 
-    # TODO better name
-    def partial_fit_predict(x)
-      @core ||= core
-      @core.fit_predict(x, @directed)
+    def batch_update(x, directed: true)
+      if x.is_a?(String)
+        @core ||= core
+        @core.update_file(x, directed)
+      else
+        x = x.to_a
+        result = []
+        x.each do |v|
+          if !v.is_a?(Array) || v.size != 3
+            raise ArgumentError, "Bad shape"
+          end
+          result << update(v[0], v[1], v[2])
+          result << update(v[1], v[0], v[2]) if !directed
+        end
+        result
+      end
+    end
+
+    # legacy
+    alias_method :partial_fit_predict, :batch_update
+
+    # legacy
+    def fit_predict(x, directed: true)
+      @core = nil # reset core
+      batch_update(x, directed:)
     end
 
     private

data/lib/midas/version.rb

@@ -1,3 +1,3 @@
 module Midas
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

data/lib/midas-edge.rb

@@ -1,6 +1,3 @@
-# dependencies
-require "numo/narray"
-
 # ext
 require "midas/ext"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: midas-edge
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -15,28 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.3.3
+        version: '4.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.3.3
-- !ruby/object:Gem::Dependency
-  name: numo-narray
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.8'
 email: andrew@ankane.org
 executables: []
 extensions:
@@ -49,7 +35,6 @@ 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
@@ -70,14 +55,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Edge stream anomaly detection for Ruby
 test_files: []

data/ext/midas/numo.hpp

@@ -1,867 +0,0 @@
-/*!
- * 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();
-    }
-  };
-}