tomoto 0.2.2 → 0.2.3

data/ext/tomoto/hpa.cpp

@@ -1,14 +1,14 @@
 #include <HPA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_hpa(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHPAModel, tomoto::IPAModel>(m, "HPA")
-    .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::HPAArgs args;
         args.k = k1;
         args.k2 = k2;
@@ -18,10 +18,10 @@ void init_hpa(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",
-      *[](tomoto::IHPAModel& self) {
+      [](tomoto::IHPAModel& self) {
         Array res;
         // use <= to return k+1 elements
         for (size_t i = 0; i <= self.getK(); i++) {

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();
       });
 }