tomoto 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7d2b9113c560c533a6ee514fd382116b100a1a0a89c410341f09601c579b524
-  data.tar.gz: 503cb06e8a36b0d5aa71dd5ff6cf8a67a9a6f66d804351197e89e92d26b3afe7
+  metadata.gz: a68366fa033b16f1a3c5ce77d1c62cd523dda6f873fb24cf25619706a7a0086f
+  data.tar.gz: 347f7c8c8cce63da9b5f922267123811bc1333ebdb685bbbb10b906fda24eeee
 SHA512:
-  metadata.gz: 587ed55f6006179f861019cfd91ec4b1e78bbebe27a582323ce77c5bb9d5b73979f103625a5c424f1eb76464e5a11b195cc6cbbd23c72e1054cebd046bed3849
-  data.tar.gz: 03fb68f340dc947f9ef5d25087731f447e7ec9e777d6e551768c5d8db719732af5a7f23ae5c3077d2de43f640b7cd1bc12a01ecf359926e327a5c6b296e36311
+  metadata.gz: 72adc8f9e3fe3e9d04e3841d4ff9386d3f2bef710adaa0fa2e0406284eb814cff55e0603e3b3c3b344893011dc20ab9d17de68fbaceff48c73fc9b6e506971e2
+  data.tar.gz: 6ec20a814092d056917b5f1b455019a676f8ac54161c3a0f487670dbbba5ae8dbdf6ab634c17c4770ccbdbcd4be9b12304ccc92f6ed0279ee48eb2fe36a035c9

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.2.3 (2021-08-26)
+
+- Updated to Rice 4
+
 ## 0.2.2 (2021-08-23)
 
 - Reduced gem size

data/ext/tomoto/ct.cpp

@@ -1,14 +1,14 @@
 #include <CT.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_ct(Rice::Module& m) {
   Rice::define_class_under<tomoto::ICTModel, tomoto::ILDAModel>(m, "CT")
-    .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::CTArgs args;
         args.k = k;
         args.alpha = {alpha};
@@ -17,42 +17,42 @@ void init_ct(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::ICTModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_correlations",
-      *[](tomoto::ICTModel& self, tomoto::Tid topic_id) {
+      [](tomoto::ICTModel& self, tomoto::Tid topic_id) {
         return self.getCorrelationTopic(topic_id);
       })
     .define_method(
       "num_beta_sample",
-      *[](tomoto::ICTModel& self) {
+      [](tomoto::ICTModel& self) {
         return self.getNumBetaSample();
       })
     .define_method(
       "num_beta_sample=",
-      *[](tomoto::ICTModel& self, size_t value) {
+      [](tomoto::ICTModel& self, size_t value) {
         self.setNumBetaSample(value);
         return value;
       })
     .define_method(
       "num_tmn_sample",
-      *[](tomoto::ICTModel& self) {
+      [](tomoto::ICTModel& self) {
         return self.getNumTMNSample();
       })
     .define_method(
       "num_tmn_sample=",
-      *[](tomoto::ICTModel& self, size_t value) {
+      [](tomoto::ICTModel& self, size_t value) {
         self.setNumTMNSample(value);
         return value;
       })
     .define_method(
       "_prior_cov",
-      *[](tomoto::ICTModel& self) {
+      [](tomoto::ICTModel& self) {
         return self.getPriorCov();
       })
     .define_method(
       "prior_mean",
-      *[](tomoto::ICTModel& self) {
+      [](tomoto::ICTModel& self) {
         return self.getPriorMean();
       });
 }

data/ext/tomoto/dmr.cpp

@@ -1,15 +1,14 @@
 #include <DMR.h>
 
-#include <rice/Class.hpp>
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_dmr(Rice::Module& m) {
   Rice::define_class_under<tomoto::IDMRModel, tomoto::ILDAModel>(m, "DMR")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
         tomoto::DMRArgs args;
         args.k = k;
         args.alpha = {alpha};
@@ -20,49 +19,51 @@ void init_dmr(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IDMRModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::IDMRModel& self, std::vector<std::string> words, std::string metadata) {
+      [](tomoto::IDMRModel& self, std::vector<std::string> words, std::string metadata) {
         auto doc = buildDoc(words);
         doc.misc["metadata"] = metadata;
         return self.addDoc(doc);
       })
     .define_method(
       "alpha_epsilon",
-      *[](tomoto::IDMRModel& self) {
+      [](tomoto::IDMRModel& self) {
         return self.getAlphaEps();
       })
     .define_method(
       "alpha_epsilon=",
-      *[](tomoto::IDMRModel& self, tomoto::Float value) {
+      [](tomoto::IDMRModel& self, tomoto::Float value) {
         self.setAlphaEps(value);
         return value;
       })
     .define_method(
       "f",
-      *[](tomoto::IDMRModel& self) {
+      [](tomoto::IDMRModel& self) {
         return self.getF();
       })
     .define_method(
       "_lambdas",
-      *[](tomoto::IDMRModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IDMRModel& self, tomoto::Tid topic_id) {
         return self.getLambdaByTopic(topic_id);
       })
     .define_method(
       "metadata_dict",
-      *[](tomoto::IDMRModel& self) {
+      [](tomoto::IDMRModel& self) {
         auto dict = self.getMetadataDict();
         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;
       })
     .define_method(
       "sigma",
-      *[](tomoto::IDMRModel& self) {
+      [](tomoto::IDMRModel& self) {
         return self.getSigma();
       });
 }

data/ext/tomoto/dt.cpp

@@ -1,14 +1,14 @@
 #include <DT.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_dt(Rice::Module& m) {
   Rice::define_class_under<tomoto::IDTModel, tomoto::ILDAModel>(m, "DT")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, size_t t, tomoto::Float alphaVar, tomoto::Float etaVar, tomoto::Float phiVar, tomoto::Float shapeA, tomoto::Float shapeB, tomoto::Float shapeC) {
+      [](size_t tw, size_t k, size_t t, tomoto::Float alphaVar, tomoto::Float etaVar, tomoto::Float phiVar, tomoto::Float shapeA, tomoto::Float shapeB, tomoto::Float shapeC) {
         // Rice only supports 10 arguments
         size_t seed = -1;
         tomoto::DTArgs args;
@@ -24,17 +24,17 @@ void init_dt(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IDTModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::IDTModel& self, std::vector<std::string> words, uint32_t timepoint) {
+      [](tomoto::IDTModel& self, std::vector<std::string> words, uint32_t timepoint) {
         auto doc = buildDoc(words);
         doc.misc["timepoint"] = timepoint;
         return self.addDoc(doc);
       })
     .define_method(
       "alpha",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         Array res;
         for (size_t i = 0; i < self.getK(); i++) {
           Array res2;
@@ -47,45 +47,45 @@ void init_dt(Rice::Module& m) {
       })
     .define_method(
       "lr_a",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         return self.getShapeA();
       })
     .define_method(
       "lr_a=",
-      *[](tomoto::IDTModel& self, tomoto::Float value) {
+      [](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeA(value);
         return value;
       })
     .define_method(
       "lr_b",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         return self.getShapeB();
       })
     .define_method(
       "lr_b=",
-      *[](tomoto::IDTModel& self, tomoto::Float value) {
+      [](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeB(value);
         return value;
       })
     .define_method(
       "lr_c",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         return self.getShapeC();
       })
     .define_method(
       "lr_c=",
-      *[](tomoto::IDTModel& self, tomoto::Float value) {
+      [](tomoto::IDTModel& self, tomoto::Float value) {
         self.setShapeC(value);
         return value;
       })
     .define_method(
       "num_docs_by_timepoint",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         return self.getNumDocsByT();
       })
     .define_method(
       "num_timepoints",
-      *[](tomoto::IDTModel& self) {
+      [](tomoto::IDTModel& self) {
         return self.getT();
       });
 }

data/ext/tomoto/ext.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);
@@ -18,17 +18,17 @@ extern "C"
 void Init_ext()
 {
   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/extconf.rb

@@ -1,8 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
-
-$CXXFLAGS += " -std=c++14 -DEIGEN_MPL2_ONLY"
+$CXXFLAGS += " -std=c++17 $(optflags) -DEIGEN_MPL2_ONLY"
 
 $CXXFLAGS += " -march=native"
 

data/ext/tomoto/gdmr.cpp

@@ -1,14 +1,14 @@
 #include <GDMR.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_gdmr(Rice::Module& m) {
   Rice::define_class_under<tomoto::IGDMRModel, tomoto::IDMRModel>(m, "GDMR")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, std::vector<uint64_t> degrees, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float sigma0, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
+      [](size_t tw, size_t k, std::vector<uint64_t> degrees, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float sigma0, tomoto::Float eta, tomoto::Float alpha_epsilon, size_t seed) {
         tomoto::GDMRArgs args;
         args.k = k;
         args.degrees = degrees;
@@ -21,22 +21,22 @@ void init_gdmr(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "_add_doc",
-      *[](tomoto::IGDMRModel& self, std::vector<std::string> words, std::vector<tomoto::Float> numeric_metadata) {
+      [](tomoto::IGDMRModel& self, std::vector<std::string> words, std::vector<tomoto::Float> numeric_metadata) {
         auto doc = buildDoc(words);
         doc.misc["numeric_metadata"] = numeric_metadata;
         return self.addDoc(doc);
       })
     .define_method(
       "degrees",
-      *[](tomoto::IGDMRModel& self) {
+      [](tomoto::IGDMRModel& self) {
         return self.getFs();
       })
     .define_method(
       "sigma0",
-      *[](tomoto::IGDMRModel& self) {
+      [](tomoto::IGDMRModel& self) {
         return self.getSigma0();
       });
 }

data/ext/tomoto/hdp.cpp

@@ -1,14 +1,14 @@
 #include <HDP.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_hdp(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHDPModel, tomoto::ILDAModel>(m, "HDP")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
+      [](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
         tomoto::HDPArgs args;
         args.k = k;
         args.alpha = {alpha};
@@ -18,30 +18,30 @@ void init_hdp(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IHDPModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",
-      *[](tomoto::IHDPModel& self) {
+      [](tomoto::IHDPModel& self) {
         return self.getAlpha();
       })
     .define_method(
       "gamma",
-      *[](tomoto::IHDPModel& self) {
+      [](tomoto::IHDPModel& self) {
         return self.getGamma();
       })
     .define_method(
       "live_k",
-      *[](tomoto::IHDPModel& self) {
+      [](tomoto::IHDPModel& self) {
         return self.getLiveK();
       })
     .define_method(
       "live_topic?",
-      *[](tomoto::IHDPModel& self, size_t tid) {
+      [](tomoto::IHDPModel& self, size_t tid) {
         return self.isLiveTopic(tid);
       })
     .define_method(
       "num_tables",
-      *[](tomoto::IHDPModel& self) {
+      [](tomoto::IHDPModel& self) {
         return self.getTotalTables();
       });
 }

data/ext/tomoto/hlda.cpp

@@ -1,14 +1,14 @@
 #include <HLDA.h>
 
-#include <rice/Module.hpp>
+#include <rice/rice.hpp>
 
 #include "utils.h"
 
 void init_hlda(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHLDAModel, tomoto::ILDAModel>(m, "HLDA")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new",
-      *[](size_t tw, size_t levelDepth, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
+      [](size_t tw, size_t levelDepth, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, size_t seed) {
         tomoto::HLDAArgs args;
         args.k = levelDepth;
         args.alpha = {alpha};
@@ -18,10 +18,10 @@ void init_hlda(Rice::Module& m) {
           args.seed = seed;
         }
         return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, args);
-      })
+      }, Rice::Return().takeOwnership())
     .define_method(
       "alpha",
-      *[](tomoto::IHLDAModel& self) {
+      [](tomoto::IHLDAModel& self) {
         Array res;
         for (size_t i = 0; i < self.getLevelDepth(); i++) {
           res.push(self.getAlpha(i));
@@ -30,42 +30,42 @@ void init_hlda(Rice::Module& m) {
       })
     .define_method(
       "_children_topics",
-      *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
         return self.getChildTopicId(topic_id);
       })
     .define_method(
       "depth",
-      *[](tomoto::IHLDAModel& self) {
+      [](tomoto::IHLDAModel& self) {
         return self.getLevelDepth();
       })
     .define_method(
       "gamma",
-      *[](tomoto::IHLDAModel& self) {
+      [](tomoto::IHLDAModel& self) {
         return self.getGamma();
       })
     .define_method(
       "_level",
-      *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
         return self.getLevelOfTopic(topic_id);
       })
     .define_method(
       "live_k",
-      *[](tomoto::IHLDAModel& self) {
+      [](tomoto::IHLDAModel& self) {
         return self.getLiveK();
       })
     .define_method(
       "_live_topic?",
-      *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
         return self.isLiveTopic(topic_id);
       })
     .define_method(
       "_num_docs_of_topic",
-      *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
         return self.getNumDocsOfTopic(topic_id);
       })
     .define_method(
       "_parent_topic",
-      *[](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
+      [](tomoto::IHLDAModel& self, tomoto::Tid topic_id) {
         return self.getParentTopicId(topic_id);
       });
 }