tomoto 0.2.2 → 0.3.0

data/ext/tomoto/lda.cpp

@@ -3,9 +3,7 @@
 
 #include <LDA.h>
 
-#include <rice/Class.hpp>
-#include <rice/Hash.hpp>
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
@@ -22,7 +20,7 @@ void init_lda(Rice::Module& m) {
   Rice::define_class_under<DocumentObject>(m, "Document")
     .define_method(
       "topics",
-      *[](DocumentObject& self) {
+      [](DocumentObject& self) {
         Rice::Hash res;
         auto topics = self.tm->getTopicsByDoc(self.doc);
         for (size_t i = 0; i < topics.size(); i++) {
@@ -32,9 +30,9 @@ void init_lda(Rice::Module& m) {
       });
 
   Rice::define_class_under<tomoto::ILDAModel>(m, "LDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
         tomoto::LDAArgs args;
         args.k = k;
         args.alpha = {alpha};
@@ -43,10 +41,10 @@ void init_lda(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::ILDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::ILDAModel& self, std::vector<std::string> words) {
+      [](tomoto::ILDAModel& self, std::vector<std::string> words) {
         return self.addDoc(buildDoc(words));
       })
     .define_method(
@@ -75,7 +73,7 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "alpha",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         Array res;
         for (size_t i = 0; i < self.getK(); i++) {
           res.push(self.getAlpha(i));
@@ -84,18 +82,18 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "burn_in",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getBurnInIteration();
       })
     .define_method(
       "burn_in=",
-      *[](tomoto::ILDAModel& self, size_t iteration) {
+      [](tomoto::ILDAModel& self, size_t iteration) {
         self.setBurnInIteration(iteration);
         return iteration;
       })
     .define_method(
       "_count_by_topics",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         Array res;
         for (auto const& v : self.getCountByTopic()) {
           res.push(v);
@@ -104,32 +102,33 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "docs",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         Array res;
         auto n = self.getNumDocs();
         for (size_t i = 0; i < n; i++) {
-          res.push(DocumentObject(self.getDoc(i), &self));
+          auto v = DocumentObject(self.getDoc(i), &self);
+          res.push(Object(Rice::detail::To_Ruby<DocumentObject>().convert(v)));
         }
         return res;
       })
     .define_method(
       "eta",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getEta();
       })
     .define_method(
       "global_step",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getGlobalStep();
       })
     .define_method(
       "k",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getK();
       })
     .define_method(
       "_load",
-      *[](tomoto::ILDAModel& self, const char* filename) {
+      [](tomoto::ILDAModel& self, const char* filename) {
         std::ifstream str{ filename, std::ios_base::binary };
         if (!str) throw std::runtime_error{ std::string("cannot open file '") + filename + std::string("'") };
         std::vector<uint8_t> extra_data;
@@ -137,48 +136,48 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "ll_per_word",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getLLPerWord();
       })
     .define_method(
       "num_docs",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getNumDocs();
       })
     .define_method(
       "num_vocabs",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getV();
       })
     .define_method(
       "num_words",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getN();
       })
     .define_method(
       "optim_interval",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getOptimInterval();
       })
     .define_method(
       "optim_interval=",
-      *[](tomoto::ILDAModel& self, size_t value) {
+      [](tomoto::ILDAModel& self, size_t value) {
         self.setOptimInterval(value);
         return value;
       })
     .define_method(
       "perplexity",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return self.getPerplexity();
       })
     .define_method(
       "_prepare",
-      *[](tomoto::ILDAModel& self, size_t minCnt, size_t minDf, size_t rmTop) {
+      [](tomoto::ILDAModel& self, size_t minCnt, size_t minDf, size_t rmTop) {
         self.prepare(true, minCnt, minDf, rmTop);
       })
     .define_method(
       "_removed_top_words",
-      *[](tomoto::ILDAModel& self, size_t rmTop) {
+      [](tomoto::ILDAModel& self, size_t rmTop) {
         Array res;
         auto dict = self.getVocabDict();
         size_t size = dict.size();
@@ -189,14 +188,14 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "_save",
-      *[](tomoto::ILDAModel& self, const char* filename, bool full) {
+      [](tomoto::ILDAModel& self, const char* filename, bool full) {
         std::ofstream str{ filename, std::ios_base::binary };
         std::vector<uint8_t> extra_data;
         self.saveModel(str, full, &extra_data);
       })
     .define_method(
       "_topic_words",
-      *[](tomoto::ILDAModel& self, size_t topicId, size_t topN) {
+      [](tomoto::ILDAModel& self, size_t topicId, size_t topN) {
         Rice::Hash res;
         for (auto const& v : self.getWordsByTopicSorted(topicId, topN)) {
           res[v.first] = v.second;
@@ -205,17 +204,17 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "_train",
-      *[](tomoto::ILDAModel& self, size_t iteration, size_t workers, size_t ps) {
+      [](tomoto::ILDAModel& self, size_t iteration, size_t workers, size_t ps) {
         self.train(iteration, workers, (tomoto::ParallelScheme)ps);
       })
     .define_method(
       "_tw",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         return (int)self.getTermWeight();
       })
     .define_method(
       "used_vocab_df",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto vocab = self.getVocabDf();
         Array res;
         for (size_t i = 0; i < self.getV(); i++) {
@@ -225,7 +224,7 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "used_vocab_freq",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto vocab = self.getVocabCf();
         Array res;
         for (size_t i = 0; i < self.getV(); i++) {
@@ -235,18 +234,20 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "used_vocabs",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto dict = self.getVocabDict();
         Array res;
         auto utf8 = Rice::Class(rb_cEncoding).call("const_get", "UTF_8");
         for (size_t i = 0; i < self.getV(); i++) {
-          res.push(to_ruby<std::string>(dict.toWord(i)).call("force_encoding", utf8));
+          VALUE value = Rice::detail::To_Ruby<std::string>().convert(dict.toWord(i));
+          Object obj(value);
+          res.push(obj.call("force_encoding", utf8));
         }
         return res;
       })
     .define_method(
       "vocab_df",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto vocab = self.getVocabDf();
         Array res;
         for (size_t i = 0; i < vocab.size(); i++) {
@@ -256,7 +257,7 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "vocab_freq",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto vocab = self.getVocabCf();
         Array res;
         for (size_t i = 0; i < vocab.size(); i++) {
@@ -266,12 +267,14 @@ void init_lda(Rice::Module& m) {
       })
     .define_method(
       "vocabs",
-      *[](tomoto::ILDAModel& self) {
+      [](tomoto::ILDAModel& self) {
         auto dict = self.getVocabDict();
         Array res;
         auto utf8 = Rice::Class(rb_cEncoding).call("const_get", "UTF_8");
         for (size_t i = 0; i < dict.size(); i++) {
-          res.push(to_ruby<std::string>(dict.toWord(i)).call("force_encoding", utf8));
+          VALUE value = Rice::detail::To_Ruby<std::string>().convert(dict.toWord(i));
+          Object obj(value);
+          res.push(obj.call("force_encoding", utf8));
         }
         return res;
       });

data/ext/tomoto/llda.cpp

@@ -1,14 +1,14 @@
 #include <LLDA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_llda(Rice::Module& m) {
   Rice::define_class_under<tomoto::ILLDAModel, tomoto::ILDAModel>(m, "LLDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
         tomoto::LDAArgs args;
         args.k = k;
         args.alpha = {alpha};
@@ -17,17 +17,17 @@ void init_llda(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::ILLDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::ILLDAModel& self, std::vector<std::string> words, std::vector<std::string> labels) {
+      [](tomoto::ILLDAModel& self, std::vector<std::string> words, std::vector<std::string> labels) {
         auto doc = buildDoc(words);
         doc.misc["labels"] = labels;
         return self.addDoc(doc);
       })
     .define_method(
       "topics_per_label",
-      *[](tomoto::ILLDAModel& self) {
+      [](tomoto::ILLDAModel& self) {
         return self.getNumTopicsPerLabel();
       });
 }

data/ext/tomoto/mglda.cpp

@@ -1,14 +1,14 @@
 #include <MGLDA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_mglda(Rice::Module& m) {
   Rice::define_class_under<tomoto::IMGLDAModel, tomoto::ILDAModel>(m, "MGLDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k_g, size_t k_l, size_t t, tomoto::Float alpha_g, tomoto::Float alpha_l, tomoto::Float alpha_mg, tomoto::Float alpha_ml, tomoto::Float eta_g) {
+      [](size_t tw, size_t k_g, size_t k_l, size_t t, tomoto::Float alpha_g, tomoto::Float alpha_l, tomoto::Float alpha_mg, tomoto::Float alpha_ml, tomoto::Float eta_g) {
         tomoto::MGLDAArgs args;
         args.k = k_g;
         args.kL = k_l;
@@ -20,62 +20,62 @@ void init_mglda(Rice::Module& m) {
         args.eta = eta_g;
         // TODO more args
         return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::IMGLDAModel& self, std::vector<std::string> words, std::string delimiter) {
+      [](tomoto::IMGLDAModel& self, std::vector<std::string> words, std::string delimiter) {
         auto doc = buildDoc(words);
         doc.misc["delimiter"] = delimiter;
         return self.addDoc(doc);
       })
     .define_method(
       "alpha_g",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getAlpha();
       })
     .define_method(
       "alpha_l",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getAlphaL();
       })
     .define_method(
       "alpha_mg",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getAlphaM();
       })
     .define_method(
       "alpha_ml",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getAlphaML();
       })
     .define_method(
       "eta_g",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getEta();
       })
     .define_method(
       "eta_l",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getEtaL();
       })
     .define_method(
       "gamma",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getGamma();
       })
     .define_method(
       "k_g",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getK();
       })
     .define_method(
       "k_l",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getKL();
       })
     .define_method(
       "t",
-      *[](tomoto::IMGLDAModel& self) {
+      [](tomoto::IMGLDAModel& self) {
         return self.getT();
       });
 }

data/ext/tomoto/pa.cpp

@@ -1,14 +1,14 @@
 #include <PA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_pa(Rice::Module& m) {
   Rice::define_class_under<tomoto::IPAModel, tomoto::ILDAModel>(m, "PA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+      [](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
         tomoto::PAArgs args;
         args.k = k1;
         args.k2 = k2;
@@ -18,15 +18,15 @@ void init_pa(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IPAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "k1",
-      *[](tomoto::IPAModel& self) {
+      [](tomoto::IPAModel& self) {
         return self.getK();
       })
     .define_method(
       "k2",
-      *[](tomoto::IPAModel& self) {
+      [](tomoto::IPAModel& self) {
         return self.getK2();
       });
 }

data/ext/tomoto/plda.cpp

@@ -1,14 +1,14 @@
 #include <PLDA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_plda(Rice::Module& m) {
   Rice::define_class_under<tomoto::IPLDAModel, tomoto::ILLDAModel>(m, "PLDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t latent_topics, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+      [](size_t tw, size_t latent_topics, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
         tomoto::PLDAArgs args;
         args.numLatentTopics = latent_topics;
         args.alpha = {alpha};
@@ -17,17 +17,17 @@ void init_plda(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IPLDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::IPLDAModel& self, std::vector<std::string> words, std::vector<std::string> labels) {
+      [](tomoto::IPLDAModel& self, std::vector<std::string> words, std::vector<std::string> labels) {
         auto doc = buildDoc(words);
         doc.misc["labels"] = labels;
         return self.addDoc(doc);
       })
     .define_method(
       "latent_topics",
-      *[](tomoto::IPLDAModel& self) {
+      [](tomoto::IPLDAModel& self) {
         return self.getNumLatentTopics();
       });
 }

data/ext/tomoto/slda.cpp

@@ -1,18 +1,18 @@
 #include <SLDA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_slda(Rice::Module& m) {
   Rice::define_class_under<tomoto::ISLDAModel, tomoto::ILDAModel>(m, "SLDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, Array rb_vars, tomoto::Float alpha, tomoto::Float eta, std::vector<tomoto::Float> mu, std::vector<tomoto::Float> nu_sq, std::vector<tomoto::Float> glm_param, size_t seed) {
+      [](size_t tw, size_t k, Array rb_vars, tomoto::Float alpha, tomoto::Float eta, std::vector<tomoto::Float> mu, std::vector<tomoto::Float> nu_sq, std::vector<tomoto::Float> glm_param, size_t seed) {
         std::vector<tomoto::ISLDAModel::GLM> vars;
         vars.reserve(rb_vars.size());
         for (auto const& v : rb_vars) {
-          vars.push_back((tomoto::ISLDAModel::GLM) from_ruby<int>(v));
+          vars.push_back((tomoto::ISLDAModel::GLM) Rice::detail::From_Ruby<int>().convert(v.value()));
         }
         tomoto::SLDAArgs args;
         args.k = k;
@@ -26,22 +26,22 @@ void init_slda(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::ISLDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::ISLDAModel& self, std::vector<std::string> words, std::vector<tomoto::Float> y) {
+      [](tomoto::ISLDAModel& self, std::vector<std::string> words, std::vector<tomoto::Float> y) {
         auto doc = buildDoc(words);
         doc.misc["y"] = y;
         return self.addDoc(doc);
       })
     .define_method(
       "f",
-      *[](tomoto::ISLDAModel& self) {
+      [](tomoto::ISLDAModel& self) {
         return self.getF();
       })
     .define_method(
       "_var_type",
-      *[](tomoto::ISLDAModel& self, size_t var_id) {
+      [](tomoto::ISLDAModel& self, size_t var_id) {
         if (var_id >= self.getF()) throw std::runtime_error{ "'var_id' must be < 'f'" };
         return self.getTypeOfVar(var_id) == tomoto::ISLDAModel::GLM::linear ? "l" : "b";
       });

data/ext/tomoto/{ext.cpp → tomoto.cpp}

@@ -1,4 +1,4 @@
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 void init_lda(Rice::Module& m);
 void init_ct(Rice::Module& m);
@@ -15,20 +15,20 @@ void init_plda(Rice::Module& m);
 void init_slda(Rice::Module& m);
 
 extern "C"
-void Init_ext()
+void Init_tomoto()
 {
   auto m = Rice::define_module("Tomoto")
-    .define_singleton_method(
+    .define_singleton_function(
       "isa",
-      *[]() {
+      []() {
         #ifdef __AVX2__
-          return "avx2";
+          return Rice::String("avx2");
         #elif defined(__AVX__)
-          return "avx";
+          return Rice::String("avx");
         #elif defined(__SSE2__) || defined(__x86_64__) || defined(_WIN64)
-          return "sse2";
+          return Rice::String("sse2");
         #else
-          return "none";
+          return Rice::String("none");
         #endif
       });
 

data/ext/tomoto/utils.h

@@ -1,80 +1,26 @@
 #pragma once
 
-#include <rice/Array.hpp>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
 
 using Rice::Array;
 using Rice::Object;
 
-template<>
-inline
-Object to_ruby<std::vector<tomoto::Float>>(std::vector<tomoto::Float> const & x)
+namespace Rice::detail
 {
-  Array res;
-  for (auto const& v : x) {
-    res.push(v);
-  }
-  return res;
-}
-
-template<>
-inline
-Object to_ruby<std::vector<uint32_t>>(std::vector<uint32_t> const & x)
-{
-  Array res;
-  for (auto const& v : x) {
-    res.push(v);
-  }
-  return res;
-}
-
-template<>
-inline
-Object to_ruby<std::vector<uint64_t>>(std::vector<uint64_t> const & x)
-{
-  Array res;
-  for (auto const& v : x) {
-    res.push(v);
-  }
-  return res;
-}
-
-template<>
-inline
-std::vector<std::string> from_ruby<std::vector<std::string>>(Object x)
-{
-  Array a = Array(x);
-  std::vector<std::string> res;
-  res.reserve(a.size());
-  for (auto const& v : a) {
-    res.push_back(from_ruby<std::string>(v));
-  }
-  return res;
-}
-
-template<>
-inline
-std::vector<tomoto::Float> from_ruby<std::vector<tomoto::Float>>(Object x)
-{
-  Array a = Array(x);
-  std::vector<tomoto::Float> res;
-  res.reserve(a.size());
-  for (auto const& v : a) {
-    res.push_back(from_ruby<tomoto::Float>(v));
-  }
-  return res;
-}
-
-template<>
-inline
-std::vector<uint64_t> from_ruby<std::vector<uint64_t>>(Object x)
-{
-  Array a = Array(x);
-  std::vector<uint64_t> res;
-  res.reserve(a.size());
-  for (auto const& v : a) {
-    res.push_back(from_ruby<uint64_t>(v));
-  }
-  return res;
+  template<typename T>
+  class To_Ruby<std::vector<T>>
+  {
+  public:
+    VALUE convert(std::vector<T> const & x)
+    {
+      auto a = rb_ary_new2(x.size());
+      for (const auto& v : x) {
+        detail::protect(rb_ary_push, a, To_Ruby<T>().convert(v));
+      }
+      return a;
+    }
+  };
 }
 
 inline tomoto::RawDoc buildDoc(std::vector<std::string>& words) {

data/lib/tomoto/version.rb

@@ -1,3 +1,3 @@
 module Tomoto
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/tomoto.rb

@@ -1,5 +1,9 @@
 # ext
-require "tomoto/ext"
+begin
+  require "tomoto/#{RUBY_VERSION.to_f}/tomoto"
+rescue LoadError
+  require "tomoto/tomoto"
+end
 
 # modules
 require "tomoto/ct"