midas-edge 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26505328048e0f4f78f7bba8bf8a9362fa2937623c199770b252ccead21e1cef
-  data.tar.gz: 52b93dd03d32c353533b10efa459a149f67242d1430e786d0487a29974231807
+  metadata.gz: 21c556323034482b687c06ff507a7af020c5bdacf48bf9bd9ebc5c691ea79b1c
+  data.tar.gz: c9686a23cf785e7cea85d2eb4bb41243a49eac3420697d0e7eaa1be39272e26d
 SHA512:
-  metadata.gz: 1075c67b8cbe336ac737d694464877a461251984ed3e22704cd87a3e9d04f29be262c38d030960243a28d9b6e327d7ea1615987c757976534526f7cedb265a84
-  data.tar.gz: efba3c9e2def1feae8ced454c46a3a68d1285fd8fca53f230d967f57da61c47176e6319ed21b0925ff85750f12bd1e215382e87fe3eb592902e61ba481700414
+  metadata.gz: d895acee325aa21bdedcf295eaeb8a2993f62f383a2979eb1de14328f7dc8002dd06df068b2753068b43ee0d0adbf104925edc2eeafdbf5dbd1bccf6d7ede50b
+  data.tar.gz: b2bc93ca791413e1eccab0a08d99d01a1bfeea05966b31a9ff05a003cf61d1c0b6a3eb28e197d3be33fe93d2af96c8e2fc3f42afb9517f2979b6422eb1b9c117

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## 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
+- Reduced memory usage
+
 ## 0.5.0 (2025-04-03)
 
 - Dropped support for Ruby < 3.2

data/NOTICE.txt

@@ -1,5 +1,5 @@
 Copyright 2020 Rui Liu (liurui39660) and Siddharth Bhatia (bhatiasiddharth)
-Copyright 2020-2023 Andrew Kane
+Copyright 2020-2026 Andrew Kane
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

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/bhatiasiddharth/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,6 +1,8 @@
 // stdlib
-#include <iostream>
-#include <vector>
+#include <cstddef>
+#include <cstdlib>
+#include <fstream>
+#include <string>
 
 // midas
 #include <FilteringCore.hpp>
@@ -9,121 +11,92 @@
 
 // rice
 #include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
-// 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) {
-    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 {
-    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]);
-    }
-  }
-}
 
 // 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, 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.str());
+template<typename T>
+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;
+  Rice::Array result;
+  std::string line;
 
-  if (directed) {
-    while (fscanf(infile, "%d,%d,%d", &s, &d, &t) == 3) {
-      src.push_back(s);
-      dst.push_back(d);
-      times.push_back(t);
+  while (std::getline(infile, line)) {
+    size_t n = line.find(',');
+    if (n == std::string::npos) {
+      throw std::runtime_error{"Invalid line"};
     }
-  } else {
-    while (fscanf(infile, "%d,%d,%d", &s, &d, &t) == 3) {
-      src.push_back(s);
-      dst.push_back(d);
-      times.push_back(t);
 
-      src.push_back(d);
-      dst.push_back(s);
-      times.push_back(t);
+    size_t n2 = line.find(',', n + 1);
+    if (n2 == std::string::npos) {
+      throw std::runtime_error{"Invalid line"};
     }
-  }
-
-  fclose(infile);
-}
 
-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();
+    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));
 
-  auto ary = numo::SFloat({n});
-  auto result = ary.write_ptr();
-
-  if (!std::isnan(threshold)) {
-    MIDAS::FilteringCore midas(num_rows, num_buckets, threshold, factor);
-    for (size_t i = 0; i < n; i++) {
-      result[i] = midas(src[i], dst[i], times[i]);
-    }
-  } else if (relations) {
-    MIDAS::RelationalCore midas(num_rows, num_buckets, factor);
-    for (size_t i = 0; i < n; i++) {
-      result[i] = midas(src[i], dst[i], times[i]);
-    }
-  } else {
-    MIDAS::NormalCore midas(num_rows, num_buckets);
-    for (size_t i = 0; i < n; i++) {
-      result[i] = midas(src[i], dst[i], times[i]);
+    result.push(midas(s, d, t), false);
+    if (!directed) {
+      result.push(midas(d, s, t), false);
     }
   }
 
-  return ary;
+  return result;
 }
 
 extern "C"
 void Init_ext() {
   auto rb_mMidas = Rice::define_module("Midas");
 
+  // TODO make seed part of Core classes
   Rice::define_class_under(rb_mMidas, "Detector")
     .define_function(
-      "_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;
-        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);
+      "_set_seed",
+      [](int seed) {
+        std::srand(seed);
+      });
+
+  Rice::define_class_under<MIDAS::NormalCore>(rb_mMidas, "NormalCore")
+    .define_constructor(Rice::Constructor<MIDAS::NormalCore, int, int>())
+    .define_method(
+      "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(
+      "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(
+      "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

@@ -1,17 +1,64 @@
 module Midas
   class Detector
-    def initialize(rows: 2, buckets: 769, alpha: 0.5, threshold: nil, relations: true, directed: true, seed: 0)
+    def initialize(
+      rows: 2,
+      buckets: 769,
+      alpha: 0.5,
+      threshold: nil,
+      relations: true,
+      seed: 0
+    )
       @rows = rows
       @buckets = buckets
       @alpha = alpha
       @threshold = threshold
       @relations = relations
-      @directed = directed
       @seed = seed
     end
 
-    def fit_predict(x)
-      _fit_predict(x, @rows, @buckets, @alpha, @threshold || Float::NAN, @relations, @directed, @seed)
+    def update(source, destination, time)
+      @core ||= core
+      @core.update(source, destination, time.to_i)
+    end
+
+    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
+
+    def core
+      _set_seed(@seed)
+      if @threshold && !@threshold.to_f.nan?
+        FilteringCore.new(@rows, @buckets, @threshold, @alpha)
+      elsif @relations
+        RelationalCore.new(@rows, @buckets, @alpha)
+      else
+        NormalCore.new(@rows, @buckets)
+      end
     end
   end
 end

data/lib/midas/version.rb

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

data/lib/midas-edge.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: midas-edge
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Andrew Kane
 bindir: bin
 cert_chain: []
-date: 2025-04-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -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: 3.6.2
+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();
-    }
-  };
-}