tomoto 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1cb95a96851ccd3d499ed38c9da531ce48588cf44c37ccc92bbfdc9277e0962
-  data.tar.gz: cadee081b1f0ea9cc37b75afd97e8ecebb32796cc335da2ff50e844c955a0e4a
+  metadata.gz: 1044b496120cf955a03d6dd184056c40572501a68043c3bd3d4cc17334caba3d
+  data.tar.gz: 7078dd4bdc562cae748ca89aa9b73d38d209d6a40a1e6d2acff0d8fba0c5a18b
 SHA512:
-  metadata.gz: f5154bfb71c0b8891953b97c8edf37a7fb70fcb2ab09c3f51126e14262c729dcdc4b82d2727a8601131e090a05efcd1958851d77b5e8e95b922fc9b1f44cedf6
-  data.tar.gz: f975f505493d41bc425e0d288762e97c83ffdb6c1812792bc2dca517c550f1508efef79a24bdde992d7acd3994d6566c27745b9bed806ea64dfa072d22c692a0
+  metadata.gz: ef9944cc3820397ef18bbca2e42d4a1a0d4b43dd283f3fac8e066478ecc78e74b4a2d32a6f3304203e22fad048ebdacc60637b7f51a42cf6fc73053613a3e77e
+  data.tar.gz: 8409a754f890f788b6bc33938420311917418cf62f7cfde572db307a85f4473835caa342583ee6e3a6d03f517d89f75714b468351fa50011dbd156a9547c4918

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.2.0 (2021-05-23)
+
+- Updated tomoto to 0.12.0
+- Dropped support for Ruby < 2.6
+
 ## 0.1.4 (2021-03-14)
 
 - Added `docs` method

data/ext/tomoto/ct.cpp

@@ -8,11 +8,15 @@ void init_ct(Rice::Module& m) {
   Rice::define_class_under<tomoto::ICTModel, tomoto::ILDAModel>(m, "CT")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+        tomoto::CTArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::ICTModel::create((tomoto::TermWeight)tw, k, alpha, eta, seed);
+        return tomoto::ICTModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_correlations",

data/ext/tomoto/dmr.cpp

@@ -9,11 +9,17 @@ void init_dmr(Rice::Module& m) {
   Rice::define_class_under<tomoto::IDMRModel, tomoto::ILDAModel>(m, "DMR")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float sigma, tomoto::Float eta, tomoto::Float alpha_epsilon, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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};
+        args.sigma = sigma;
+        args.eta = eta;
+        args.alphaEps = alpha_epsilon;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IDMRModel::create((tomoto::TermWeight)tw, k, alpha, sigma, eta, alpha_epsilon, seed);
+        return tomoto::IDMRModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/dt.cpp

@@ -10,11 +10,20 @@ void init_dt(Rice::Module& m) {
       "_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) {
         // Rice only supports 10 arguments
-        int seed = -1;
-        if (seed < 0) {
-          seed = std::random_device{}();
+        size_t seed = -1;
+        tomoto::DTArgs args;
+        args.k = k;
+        args.t = t;
+        args.alpha = {alphaVar};
+        args.eta = etaVar;
+        args.phi = phiVar;
+        args.shapeA = shapeA;
+        args.shapeB = shapeB;
+        args.shapeC = shapeC;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IDTModel::create((tomoto::TermWeight)tw, k, t, alphaVar, etaVar, phiVar, shapeA, shapeB, shapeC, 0, seed);
+        return tomoto::IDTModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/extconf.rb

@@ -2,7 +2,7 @@ require "mkmf-rice"
 
 abort "Missing stdc++" unless have_library("stdc++")
 
-$CXXFLAGS += " -std=c++11 -DEIGEN_MPL2_ONLY"
+$CXXFLAGS += " -std=c++14 -DEIGEN_MPL2_ONLY"
 
 $CXXFLAGS += " -march=native"
 

data/ext/tomoto/gdmr.cpp

@@ -8,17 +8,25 @@ void init_gdmr(Rice::Module& m) {
   Rice::define_class_under<tomoto::IGDMRModel, tomoto::IDMRModel>(m, "GDMR")
     .define_singleton_method(
       "_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, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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;
+        args.alpha = {alpha};
+        args.sigma = sigma;
+        args.sigma0 = sigma0;
+        args.eta = eta;
+        args.alphaEps = alpha_epsilon;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, k, degrees, alpha, sigma, sigma0, eta, alpha_epsilon, seed);
+        return tomoto::IGDMRModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",
-      *[](tomoto::IGDMRModel& self, std::vector<std::string> words, std::vector<tomoto::Float> metadata) {
+      *[](tomoto::IGDMRModel& self, std::vector<std::string> words, std::vector<tomoto::Float> numeric_metadata) {
         auto doc = buildDoc(words);
-        doc.misc["metadata"] = metadata;
+        doc.misc["numeric_metadata"] = numeric_metadata;
         return self.addDoc(doc);
       })
     .define_method(

data/ext/tomoto/hdp.cpp

@@ -8,11 +8,16 @@ void init_hdp(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHDPModel, tomoto::ILDAModel>(m, "HDP")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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};
+        args.eta = eta;
+        args.gamma = gamma;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IHDPModel::create((tomoto::TermWeight)tw, k, alpha, eta, gamma, seed);
+        return tomoto::IHDPModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "alpha",

data/ext/tomoto/hlda.cpp

@@ -8,11 +8,16 @@ void init_hlda(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHLDAModel, tomoto::ILDAModel>(m, "HLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t levelDepth, tomoto::Float alpha, tomoto::Float eta, tomoto::Float gamma, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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};
+        args.eta = eta;
+        args.gamma = gamma;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, levelDepth, alpha, eta, gamma, seed);
+        return tomoto::IHLDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "alpha",

data/ext/tomoto/hpa.cpp

@@ -8,11 +8,16 @@ void init_hpa(Rice::Module& m) {
   Rice::define_class_under<tomoto::IHPAModel, tomoto::IPAModel>(m, "HPA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, k1, k2, alpha, eta, seed);
+        return tomoto::IHPAModel::create((tomoto::TermWeight)tw, false, args);
       })
     .define_method(
       "alpha",

data/ext/tomoto/lda.cpp

@@ -34,11 +34,15 @@ void init_lda(Rice::Module& m) {
   Rice::define_class_under<tomoto::ILDAModel>(m, "LDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+        tomoto::LDAArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::ILDAModel::create((tomoto::TermWeight)tw, k, alpha, eta, seed);
+        return tomoto::ILDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/llda.cpp

@@ -8,11 +8,15 @@ void init_llda(Rice::Module& m) {
   Rice::define_class_under<tomoto::ILLDAModel, tomoto::ILDAModel>(m, "LLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](size_t tw, size_t k, tomoto::Float alpha, tomoto::Float eta, size_t seed) {
+        tomoto::LDAArgs args;
+        args.k = k;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::ILLDAModel::create((tomoto::TermWeight)tw, k, alpha, eta, seed);
+        return tomoto::ILLDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/mglda.cpp

@@ -9,7 +9,17 @@ void init_mglda(Rice::Module& m) {
     .define_singleton_method(
       "_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) {
-        return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, k_g, k_l, t, alpha_g, alpha_l, alpha_mg, alpha_ml, eta_g);
+        tomoto::MGLDAArgs args;
+        args.k = k_g;
+        args.kL = k_l;
+        args.t = t;
+        args.alpha = {alpha_g};
+        args.alphaL = {alpha_l};
+        args.alphaMG = alpha_mg;
+        args.alphaML = alpha_ml;
+        args.eta = eta_g;
+        // TODO more args
+        return tomoto::IMGLDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/pa.cpp

@@ -8,11 +8,16 @@ void init_pa(Rice::Module& m) {
   Rice::define_class_under<tomoto::IPAModel, tomoto::ILDAModel>(m, "PA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t k1, size_t k2, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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;
+        args.alpha = {alpha};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IPAModel::create((tomoto::TermWeight)tw, k1, k2, alpha, eta, seed);
+        return tomoto::IPAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "k1",

data/ext/tomoto/plda.cpp

@@ -8,11 +8,15 @@ void init_plda(Rice::Module& m) {
   Rice::define_class_under<tomoto::IPLDAModel, tomoto::ILLDAModel>(m, "PLDA")
     .define_singleton_method(
       "_new",
-      *[](size_t tw, size_t latent_topics, tomoto::Float alpha, tomoto::Float eta, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
+      *[](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};
+        args.eta = eta;
+        if (seed >= 0) {
+          args.seed = seed;
         }
-        return tomoto::IPLDAModel::create((tomoto::TermWeight)tw, latent_topics, 1, alpha, eta, seed);
+        return tomoto::IPLDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/ext/tomoto/slda.cpp

@@ -8,16 +8,24 @@ void init_slda(Rice::Module& m) {
   Rice::define_class_under<tomoto::ISLDAModel, tomoto::ILDAModel>(m, "SLDA")
     .define_singleton_method(
       "_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, int seed) {
-        if (seed < 0) {
-          seed = std::random_device{}();
-        }
+      *[](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));
         }
-        return tomoto::ISLDAModel::create((tomoto::TermWeight)tw, k, vars, alpha, eta, mu, nu_sq, glm_param, seed);
+        tomoto::SLDAArgs args;
+        args.k = k;
+        args.vars = vars;
+        args.alpha = {alpha};
+        args.eta = eta;
+        args.mu = mu;
+        args.nuSq = nu_sq;
+        args.glmParam = glm_param;
+        if (seed >= 0) {
+          args.seed = seed;
+        }
+        return tomoto::ISLDAModel::create((tomoto::TermWeight)tw, args);
       })
     .define_method(
       "_add_doc",

data/lib/tomoto/gdmr.rb

@@ -8,8 +8,8 @@ module Tomoto
       init_params(model, binding)
     end
 
-    def add_doc(doc, metadata: [])
-      _add_doc(prepare_doc(doc), metadata)
+    def add_doc(doc, numeric_metadata: [])
+      _add_doc(prepare_doc(doc), numeric_metadata)
     end
   end
 end

data/lib/tomoto/version.rb

@@ -1,3 +1,3 @@
 module Tomoto
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/vendor/EigenRand/EigenRand/Core.h

@@ -2,8 +2,8 @@
  * @file Core.h
  * @author bab2min (bab2min@gmail.com)
  * @brief 
- * @version 0.2.0
- * @date 2020-06-22
+ * @version 0.3.0
+ * @date 2020-10-07
  * 
  * @copyright Copyright (c) 2020
  * 
@@ -14,11 +14,15 @@
 #define EIGENRAND_CORE_H
 
 #include <EigenRand/RandUtils.h>
+
 #include <EigenRand/Dists/Basic.h>
 #include <EigenRand/Dists/Discrete.h>
 #include <EigenRand/Dists/NormalExp.h>
 #include <EigenRand/Dists/GammaPoisson.h>
 
+#include <EigenRand/MvDists/MvNormal.h>
+#include <EigenRand/MvDists/Multinomial.h>
+
 namespace Eigen
 {
 	/**
@@ -27,1112 +31,7 @@ namespace Eigen
 	 */
 	namespace Rand
 	{
-		template<typename Derived, typename Urng>
-		using RandBitsType = CwiseNullaryOp<internal::scalar_randbits_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates integers with random bits
-		 * 
-		 * @tparam Derived
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const RandBitsType<Derived, Urng> 
-			randBits(Index rows, Index cols, Urng&& urng) 
-		{
-			return { 
-				rows, cols, internal::scalar_randbits_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng)) 
-			};
-		}
-
-		/**
-		 * @brief generates integers with random bits
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const RandBitsType<Derived, Urng> 
-			randBitsLike(Derived& o, Urng&& urng)
-		{
-			return { 
-				o.rows(), o.cols(), internal::scalar_randbits_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng)) 
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using UniformIntType = CwiseNullaryOp<internal::scalar_uniform_int_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates integers with a given range `[min, max]`
-		 *
-		 * @tparam Derived a type of Eigen::DenseBase
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param min, max the range of integers being generated
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const UniformIntType<Derived, Urng> 
-			uniformInt(Index rows, Index cols, Urng&& urng, typename Derived::Scalar min, typename Derived::Scalar max) 
-		{
-			return {
-				rows, cols, internal::scalar_uniform_int_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), min, max)
-			};
-		}
-
-		/**
-		 * @brief generates integers with a given range `[min, max]`
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param min, max the range of integers being generated
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const UniformIntType<Derived, Urng> 
-			uniformIntLike(Derived& o, Urng&& urng, typename Derived::Scalar min, typename Derived::Scalar max)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_uniform_int_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), min, max)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using BalancedType = CwiseNullaryOp<internal::scalar_balanced_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals in a range `[-1, 1]`
-		 * 
-		 * @tparam Derived a type of Eigen::DenseBase
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const BalancedType<Derived, Urng>
-			balanced(Index rows, Index cols, Urng&& urng)
-		{
-			return {
-				rows, cols, internal::scalar_balanced_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-
-		/**
-		 * @brief generates reals in a range `[-1, 1]`
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const BalancedType<Derived, Urng> 
-			balancedLike(const Derived& o, Urng&& urng)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_balanced_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using UniformRealType = CwiseNullaryOp<internal::scalar_uniform_real_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals in a range `[0, 1)`
-		 * 
-		 * @tparam Derived a type of Eigen::DenseBase
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const UniformRealType<Derived, Urng> 
-			uniformReal(Index rows, Index cols, Urng&& urng)
-		{
-			return {
-				rows, cols, internal::scalar_uniform_real_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-
-		/**
-		 * @brief generates reals in a range `[0, 1)`
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const UniformRealType<Derived, Urng> 
-			uniformRealLike(Derived& o, Urng&& urng)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_uniform_real_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-		
-		template<typename Derived, typename Urng>
-		using NormalType = CwiseNullaryOp<internal::scalar_norm_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on a standard normal distribution (`mean` = 0, `stdev`=1)
-		 * 
-		 * @tparam Derived a type of Eigen::DenseBase
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const NormalType<Derived, Urng>
-			normal(Index rows, Index cols, Urng&& urng)
-		{
-			return {
-				rows, cols, internal::scalar_norm_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-
-		/**
-		 * @brief generates reals on a standard normal distribution (`mean` = 0, `stdev`=1)
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const NormalType<Derived, Urng>
-			normalLike(Derived& o, Urng&& urng)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_norm_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng))
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using Normal2Type = CwiseNullaryOp<internal::scalar_norm_dist2_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on a normal distribution with arbitrary `mean` and `stdev`.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param mean a mean value of the distribution
-		 * @param stdev a standard deviation value of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const Normal2Type<Derived, Urng>
-			normal(Index rows, Index cols, Urng&& urng, typename Derived::Scalar mean, typename Derived::Scalar stdev = 1)
-		{
-			return {
-				rows, cols, internal::scalar_norm_dist2_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean, stdev)
-			};
-		}
-
-		/**
-		 * @brief generates reals on a normal distribution with arbitrary `mean` and `stdev`.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param mean a mean value of the distribution
-		 * @param stdev a standard deviation value of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const Normal2Type<Derived, Urng>
-			normalLike(Derived& o, Urng&& urng, typename Derived::Scalar mean, typename Derived::Scalar stdev = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_norm_dist2_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean, stdev)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using LognormalType = CwiseNullaryOp<internal::scalar_lognorm_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on a lognormal distribution with arbitrary `mean` and `stdev`.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param mean a mean value of the distribution
-		 * @param stdev a standard deviation value of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const LognormalType<Derived, Urng>
-			lognormal(Index rows, Index cols, Urng&& urng, typename Derived::Scalar mean = 0, typename Derived::Scalar stdev = 1)
-		{
-			return {
-				rows, cols, internal::scalar_lognorm_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean, stdev)
-			};
-		}
-
-		/**
-		 * @brief generates reals on a lognormal distribution with arbitrary `mean` and `stdev`.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param mean a mean value of the distribution
-		 * @param stdev a standard deviation value of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const LognormalType<Derived, Urng>
-			lognormalLike(Derived& o, Urng&& urng, typename Derived::Scalar mean = 0, typename Derived::Scalar stdev = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_lognorm_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean, stdev)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using StudentTType = CwiseNullaryOp<internal::scalar_student_t_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the Student's t distribution with arbirtrary degress of freedom.
-		 *
-		 * @tparam Derived a type of Eigen::DenseBase
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param n degrees of freedom
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const StudentTType<Derived, Urng>
-			studentT(Index rows, Index cols, Urng&& urng, typename Derived::Scalar n = 1)
-		{
-			return {
-				rows, cols, internal::scalar_student_t_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), n)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the Student's t distribution with arbirtrary degress of freedom.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param n degrees of freedom
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const StudentTType<Derived, Urng>
-			studentTLike(Derived& o, Urng&& urng, typename Derived::Scalar n = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_student_t_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), n)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using ExponentialType = CwiseNullaryOp<internal::scalar_exp_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on an exponential distribution with arbitrary scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param lambda a scale parameter of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const ExponentialType<Derived, Urng>
-			exponential(Index rows, Index cols, Urng&& urng, typename Derived::Scalar lambda = 1)
-		{
-			return {
-				rows, cols, internal::scalar_exp_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), lambda)
-			};
-		}
-
-		/**
-		 * @brief generates reals on an exponential distribution with arbitrary scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param lambda a scale parameter of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const ExponentialType<Derived, Urng>
-			exponentialLike(Derived& o, Urng&& urng, typename Derived::Scalar lambda = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_exp_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), lambda)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using GammaType = CwiseNullaryOp<internal::scalar_gamma_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on a gamma distribution with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param alpha a shape parameter of the distribution
-		 * @param beta a scale parameter of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const GammaType<Derived, Urng>
-			gamma(Index rows, Index cols, Urng&& urng, typename Derived::Scalar alpha = 1, typename Derived::Scalar beta = 1)
-		{
-			return {
-				rows, cols, internal::scalar_gamma_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), alpha, beta)
-			};
-		}
-
-		/**
-		 * @brief generates reals on a gamma distribution with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param alpha a shape parameter of the distribution
-		 * @param beta a scale parameter of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const GammaType<Derived, Urng>
-			gammaLike(Derived& o, Urng&& urng, typename Derived::Scalar alpha = 1, typename Derived::Scalar beta = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_gamma_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), alpha, beta)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using WeibullType = CwiseNullaryOp<internal::scalar_weibull_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on a Weibull distribution with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param a a shape parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const WeibullType<Derived, Urng>
-			weibull(Index rows, Index cols, Urng&& urng, typename Derived::Scalar a = 1, typename Derived::Scalar b = 1)
-		{
-			return {
-				rows, cols, internal::scalar_weibull_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		/**
-		 * @brief generates reals on a Weibull distribution with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param a a shape parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const WeibullType<Derived, Urng>
-			weibullLike(Derived& o, Urng&& urng, typename Derived::Scalar a = 1, typename Derived::Scalar b = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_weibull_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using ExtremeValueType = CwiseNullaryOp<internal::scalar_extreme_value_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on an extreme value distribution 
-		 * (a.k.a Gumbel Type I, log-Weibull, Fisher-Tippett Type I) with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param a a location parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const ExtremeValueType<Derived, Urng>
-			extremeValue(Index rows, Index cols, Urng&& urng, typename Derived::Scalar a = 0, typename Derived::Scalar b = 1)
-		{
-			return {
-				rows, cols, internal::scalar_extreme_value_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		/**
-		 * @brief generates reals on an extreme value distribution 
-		 * (a.k.a Gumbel Type I, log-Weibull, Fisher-Tippett Type I) with arbitrary shape and scale parameter.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param a a location parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const ExtremeValueType<Derived, Urng>
-			extremeValueLike(Derived& o, Urng&& urng, typename Derived::Scalar a = 0, typename Derived::Scalar b = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_extreme_value_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using ChiSquaredType = CwiseNullaryOp<internal::scalar_chi_squared_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the Chi-squared distribution with arbitrary degrees of freedom.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param n the degrees of freedom of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const ChiSquaredType<Derived, Urng>
-			chiSquared(Index rows, Index cols, Urng&& urng, typename Derived::Scalar n = 1)
-		{
-			return {
-				rows, cols, internal::scalar_chi_squared_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), n)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the Chi-squared distribution with arbitrary degrees of freedom.
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param n the degrees of freedom of the distribution
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng>
-		inline const ChiSquaredType<Derived, Urng>
-			chiSquaredLike(Derived& o, Urng&& urng, typename Derived::Scalar n = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_chi_squared_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), n)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using CauchyType = CwiseNullaryOp<internal::scalar_cauchy_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the Cauchy distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param a a location parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const CauchyType<Derived, Urng>
-			cauchy(Index rows, Index cols, Urng&& urng, typename Derived::Scalar a = 0, typename Derived::Scalar b = 1)
-		{
-			return {
-				rows, cols, internal::scalar_cauchy_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the Cauchy distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param a a location parameter of the distribution
-		 * @param b a scale parameter of the distribution
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const CauchyType<Derived, Urng>
-			cauchyLike(Derived& o, Urng&& urng, typename Derived::Scalar a = 0, typename Derived::Scalar b = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_cauchy_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using FisherFType = CwiseNullaryOp<internal::scalar_fisher_f_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the Fisher's F distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param m degrees of freedom
-		 * @param n degrees of freedom
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const FisherFType<Derived, Urng>
-			fisherF(Index rows, Index cols, Urng&& urng, typename Derived::Scalar m = 1, typename Derived::Scalar n = 1)
-		{
-			return {
-				rows, cols, internal::scalar_fisher_f_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), m, n)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the Fisher's F distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param m degrees of freedom
-		 * @param n degrees of freedom
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const FisherFType<Derived, Urng>
-			fisherFLike(Derived& o, Urng&& urng, typename Derived::Scalar m = 1, typename Derived::Scalar n = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_fisher_f_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), m, n)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using BetaType = CwiseNullaryOp<internal::scalar_beta_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the beta distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param a,b shape parameter
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const BetaType<Derived, Urng>
-			beta(Index rows, Index cols, Urng&& urng, typename Derived::Scalar a = 1, typename Derived::Scalar b = 1)
-		{
-			return {
-				rows, cols, internal::scalar_beta_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the beta distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param a,b shape parameter
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const BetaType<Derived, Urng>
-			betaLike(Derived& o, Urng&& urng, typename Derived::Scalar a = 1, typename Derived::Scalar b = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_beta_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), a, b)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using DiscreteFType = CwiseNullaryOp<internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, float>, const Derived>;
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is float(23bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteFType<Derived, Urng>
-			discreteF(Index rows, Index cols, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is float(23bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteFType<Derived, Urng>
-			discreteFLike(Derived& o, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is float(23bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteFType<Derived, Urng>
-			discreteF(Index rows, Index cols, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is float(23bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteFType<Derived, Urng>
-			discreteFLike(Derived& o, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using DiscreteDType = CwiseNullaryOp<internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, double>, const Derived>;
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is double(52bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteDType<Derived, Urng>
-			discreteD(Index rows, Index cols, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, double>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is double(52bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteDType<Derived, Urng>
-			discreteDLike(Derived& o, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, double>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is double(52bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteDType<Derived, Urng>
-			discreteD(Index rows, Index cols, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, double>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is double(52bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteDType<Derived, Urng>
-			discreteDLike(Derived& o, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, double>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using DiscreteType = CwiseNullaryOp<internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, int32_t>, const Derived>;
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is int32(32bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteType<Derived, Urng>
-			discrete(Index rows, Index cols, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, int32_t>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is int32(32bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param first, last the range of elements defining the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename RealIter>
-		inline const DiscreteType<Derived, Urng>
-			discreteLike(Derived& o, Urng&& urng, RealIter first, RealIter last)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, int32_t>(std::forward<Urng>(urng), first, last)
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is int32(32bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteType<Derived, Urng>
-			discrete(Index rows, Index cols, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				rows, cols, internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, int32_t>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		/**
-		 * @brief generates random integers on the interval `[0, n)`, where the probability of each individual integer `i` is proportional to `w(i)`.
-		 * The data type used for calculation of probabilities is int32(32bit precision).
-		 * 
-		 * @tparam Derived 
-		 * @tparam Urng 
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param il an instance of `initializer_list` containing the numbers to use as weights. The type of the elements referred by `RealIter` must be convertible to `double`.
-		 * @return a random matrix expression of the same shape as `o` 
-		 */
-		template<typename Derived, typename Urng, typename Real>
-		inline const DiscreteType<Derived, Urng>
-			discreteLike(Derived& o, Urng&& urng, const std::initializer_list<Real>& il)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_discrete_dist_op<typename Derived::Scalar, Urng, int32_t>(std::forward<Urng>(urng), il.begin(), il.end())
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using PoissonType = CwiseNullaryOp<internal::scalar_poisson_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the Poisson distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param mean rate parameter
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const PoissonType<Derived, Urng>
-			poisson(Index rows, Index cols, Urng&& urng, double mean = 1)
-		{
-			return {
-				rows, cols, internal::scalar_poisson_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the Poisson distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param mean rate parameter
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const PoissonType<Derived, Urng>
-			poissonLike(Derived& o, Urng&& urng, double mean = 1)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_poisson_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), mean)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using BinomialType = CwiseNullaryOp<internal::scalar_binomial_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the binomial distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param trials the number of trials
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const BinomialType<Derived, Urng>
-			binomial(Index rows, Index cols, Urng&& urng, typename Derived::Scalar trials = 1, double p = 0.5)
-		{
-			return {
-				rows, cols, internal::scalar_binomial_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), trials, p)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the binomial distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param trials the number of trials
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const BinomialType<Derived, Urng>
-			binomialLike(Derived& o, Urng&& urng, typename Derived::Scalar trials = 1, double p = 0.5)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_binomial_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), trials, p)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using NegativeBinomialType = CwiseNullaryOp<internal::scalar_negative_binomial_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the negative binomial distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param trials the number of trial successes
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const NegativeBinomialType<Derived, Urng>
-			negativeBinomial(Index rows, Index cols, Urng&& urng, typename Derived::Scalar trials = 1, double p = 0.5)
-		{
-			return {
-				rows, cols, internal::scalar_negative_binomial_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), trials, p)
-			};
-		}
-
-		/**
-		 * @brief generates reals on the negative binomial distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param trials the number of trial successes
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const NegativeBinomialType<Derived, Urng>
-			negativeBinomialLike(Derived& o, Urng&& urng, typename Derived::Scalar trials = 1, double p = 0.5)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_negative_binomial_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), trials, p)
-			};
-		}
-
-		template<typename Derived, typename Urng>
-		using GeometricType = CwiseNullaryOp<internal::scalar_geometric_dist_op<typename Derived::Scalar, Urng>, const Derived>;
-
-		/**
-		 * @brief generates reals on the geometric distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param rows the number of rows being generated
-		 * @param cols the number of columns being generated
-		 * @param urng c++11-style random number generator
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression with a shape (`rows`, `cols`)
-		 */
-		template<typename Derived, typename Urng>
-		inline const GeometricType<Derived, Urng>
-			geometric(Index rows, Index cols, Urng&& urng, double p = 0.5)
-		{
-			return {
-				rows, cols, internal::scalar_geometric_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), p)
-			};
-		}
 
-		/**
-		 * @brief generates reals on the geometric distribution.
-		 *
-		 * @tparam Derived
-		 * @tparam Urng
-		 * @param o an instance of any type of Eigen::DenseBase
-		 * @param urng c++11-style random number generator
-		 * @param p probability of a trial generating true
-		 * @return a random matrix expression of the same shape as `o`
-		 */
-		template<typename Derived, typename Urng>
-		inline const GeometricType<Derived, Urng>
-			geometricLike(Derived& o, Urng&& urng, double p = 0.5)
-		{
-			return {
-				o.rows(), o.cols(), internal::scalar_geometric_dist_op<typename Derived::Scalar, Urng>(std::forward<Urng>(urng), p)
-			};
-		}
 	}
 }