tomoto 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b7d2b9113c560c533a6ee514fd382116b100a1a0a89c410341f09601c579b524
-  data.tar.gz: 503cb06e8a36b0d5aa71dd5ff6cf8a67a9a6f66d804351197e89e92d26b3afe7
+  metadata.gz: e3e3aa3215e693030f3069cab0fd62686e9d28ad4df6e93ee2e9c7ba9e29286f
+  data.tar.gz: 98e4f18488132f6130bd9523d8540dd73626e8b3e5a58a1656ce3aa1ddf8234b
 SHA512:
-  metadata.gz: 587ed55f6006179f861019cfd91ec4b1e78bbebe27a582323ce77c5bb9d5b73979f103625a5c424f1eb76464e5a11b195cc6cbbd23c72e1054cebd046bed3849
-  data.tar.gz: 03fb68f340dc947f9ef5d25087731f447e7ec9e777d6e551768c5d8db719732af5a7f23ae5c3077d2de43f640b7cd1bc12a01ecf359926e327a5c6b296e36311
+  metadata.gz: 95b9d0697f58a9149c18cbbdcc7b93aa19dc7f335f12033fc80386a2ca6628bfc3c2a7a9c7299cd192459132f8d467663562de3da733cca00041da24361a6d9f
+  data.tar.gz: 9c0e12d32aedb8cb0689032f9b0fe54387b9b452a1e26b747137c4115e9813ea491fa09b6851b9e69ca6a3a86df159409d57322c3862b670ae3b3d4f8711469d

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.3.0 (2022-10-03)
+
+- Added precompiled gems for Linux and Mac
+- Updated tomoto to 0.12.3
+- Dropped support for Ruby < 2.7
+
+## 0.2.3 (2021-08-26)
+
+- Updated to Rice 4
+
 ## 0.2.2 (2021-08-23)
 
 - Reduced gem size

data/README.md

@@ -1,19 +1,17 @@
-# tomoto
+# tomoto.rb
 
 :tomato: [tomoto](https://github.com/bab2min/tomotopy) - high performance topic modeling - for Ruby
 
-[![Build Status](https://github.com/ankane/tomoto/workflows/build/badge.svg?branch=master)](https://github.com/ankane/tomoto/actions)
+[![Build Status](https://github.com/ankane/tomoto-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/tomoto-ruby/actions)
 
 ## Installation
 
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'tomoto'
+gem "tomoto"
 ```
 
-It can take 10-20 minutes to compile the extension.
-
 ## Getting Started
 
 Train a model
@@ -142,22 +140,22 @@ Supported values are `:default`, `:none`, `:copy_merge`, and `:partition`.
 
 ## History
 
-View the [changelog](https://github.com/ankane/tomoto/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/ankane/tomoto-ruby/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/tomoto/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/tomoto/pulls)
+- [Report bugs](https://github.com/ankane/tomoto-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/tomoto-ruby/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone --recursive https://github.com/ankane/tomoto.git
-cd tomoto
+git clone --recursive https://github.com/ankane/tomoto-ruby.git
+cd tomoto-ruby
 bundle install
 bundle exec rake compile
 bundle exec rake test

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/extconf.rb

@@ -1,10 +1,12 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
+$CXXFLAGS += " -std=c++17 $(optflags) -DEIGEN_MPL2_ONLY"
 
-$CXXFLAGS += " -std=c++14 -DEIGEN_MPL2_ONLY"
-
-$CXXFLAGS += " -march=native"
+unless ENV["RUBY_CC_VERSION"]
+  # AVX-512F not support yet
+  # https://github.com/bab2min/tomotopy/issues/188
+  $CXXFLAGS << " " << with_config("optflags", "-march=native -mno-avx512f")
+end
 
 apple_clang = RbConfig::CONFIG["CC_VERSION_MESSAGE"] =~ /apple clang/i
 
@@ -29,4 +31,4 @@ $srcs = Dir["{#{ext},#{tomoto}}/*.cpp"]
 $INCFLAGS += " -I#{tomoto} -I#{eigen} -I#{eigen_rand} -I#{variant}"
 $VPATH << tomoto
 
-create_makefile("tomoto/ext")
+create_makefile("tomoto/tomoto")

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

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++) {