tomoto 0.1.0

data/vendor/EigenRand/EigenRand/RandUtils.h

@@ -0,0 +1,413 @@
+/**
+ * @file RandUtils.h
+ * @author bab2min (bab2min@gmail.com)
+ * @brief 
+ * @version 0.2.0
+ * @date 2020-06-22
+ * 
+ * @copyright Copyright (c) 2020
+ * 
+ */
+
+#ifndef EIGENRAND_RAND_UTILS_H
+#define EIGENRAND_RAND_UTILS_H
+
+#include <EigenRand/MorePacketMath.h>
+#include <EigenRand/PacketFilter.h>
+#include <EigenRand/PacketRandomEngine.h>
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Packet, typename Rng,
+			typename RngResult = typename std::remove_reference<Rng>::type::result_type,
+			Rand::RandomEngineType reType = Rand::GetRandomEngineType<
+			typename std::remove_reference<Rng>::type
+		>::value>
+		struct RawbitsMaker;
+
+		template<typename PacketType, typename Rng>
+		struct UniformRealUtils;
+
+		template<typename PacketType, typename Rng>
+		struct RandUtils : public UniformRealUtils<PacketType, Rng>
+		{
+			EIGEN_STRONG_INLINE PacketType balanced(Rng& rng)
+			{
+				return psub(pmul(this->zero_to_one(rng), pset1<PacketType>(2)), pset1<PacketType>(1));
+			}
+
+			EIGEN_STRONG_INLINE PacketType nonzero_uniform_real(Rng& rng)
+			{
+				constexpr auto epsilon = std::numeric_limits<typename unpacket_traits<PacketType>::type>::epsilon() / 8;
+				return padd(this->uniform_real(rng), pset1<PacketType>(epsilon));
+			}
+		};
+
+		EIGEN_STRONG_INLINE uint32_t collect_upper8bits(uint32_t a, uint32_t b, uint32_t c)
+		{
+			return ((a & 0xFF000000) >> 24) | ((b & 0xFF000000) >> 16) | ((c & 0xFF000000) >> 8);
+		}
+	}
+}
+
+#ifdef EIGEN_VECTORIZE_AVX
+#include <immintrin.h>
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Rng>
+		struct RawbitsMaker<Packet4i, Rng, Packet8i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet4i rawbits(Rng& rng)
+			{
+				return rng.half();
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_34(Rng& rng)
+			{
+				return rng.half();
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				return rng.half();
+			}
+		};
+
+		template<typename Rng>
+		struct RawbitsMaker<Packet8i, Rng, Packet4i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet8i rawbits(Rng& rng)
+			{
+				return _mm256_insertf128_si256(_mm256_castsi128_si256(rng()), rng(), 1);
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_34(Rng& rng)
+			{
+				return _mm256_insertf128_si256(_mm256_castsi128_si256(rng()), rng(), 1);
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				return rng();
+			}
+		};
+
+		template<typename Rng, typename RngResult>
+		struct RawbitsMaker<Packet8i, Rng, RngResult, Rand::RandomEngineType::scalar>
+		{
+			EIGEN_STRONG_INLINE Packet8i rawbits(Rng& rng)
+			{
+				if (sizeof(decltype(rng())) == 8)
+				{
+					return _mm256_set_epi64x(rng(), rng(), rng(), rng());
+				}
+				else
+				{
+					return _mm256_set_epi32(rng(), rng(), rng(), rng(),
+						rng(), rng(), rng(), rng());
+				}
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_34(Rng& rng)
+			{
+				Packet8i p;
+				if (sizeof(decltype(rng())) == 8)
+				{
+#ifdef EIGEN_VECTORIZE_AVX2
+					p = _mm256_setr_epi64x(rng(), rng(), rng(), 0);
+					p = _mm256_permutevar8x32_epi32(p, _mm256_setr_epi32(0, 1, 2, 7, 3, 4, 5, 7));
+					p = _mm256_shuffle_epi8(p, _mm256_setr_epi8(
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11,
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11
+					));
+
+#else
+					auto v = rng();
+					p = _mm256_setr_epi64x(rng(), v, rng(), v >> 32);
+					Packet4i p1, p2, o = _mm_setr_epi8(
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11);
+					split_two(p, p1, p2);
+					p = combine_two(_mm_shuffle_epi8(p1, o), _mm_shuffle_epi8(p2, o));
+#endif
+				}
+				else
+				{
+					p = _mm256_setr_epi32(rng(), rng(), rng(), 0, rng(), rng(), rng(), 0);
+#ifdef EIGEN_VECTORIZE_AVX2
+					p = _mm256_shuffle_epi8(p, _mm256_setr_epi8(
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11,
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11
+					));
+#else
+					Packet4i p1, p2, o = _mm_setr_epi8(
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11);
+					split_two(p, p1, p2);
+					p = combine_two(_mm_shuffle_epi8(p1, o), _mm_shuffle_epi8(p2, o));
+#endif
+				}
+				return p;
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				if (sizeof(decltype(rng())) == 8)
+				{
+					return _mm_set_epi64x(rng(), rng());
+				}
+				else
+				{
+					return _mm_set_epi32(rng(), rng(), rng(), rng());
+				}
+			}
+		};
+
+		template<typename Rng>
+		struct RawbitsMaker<Packet8i, Rng, Packet8i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet8i rawbits(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet8i rawbits_34(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				return rng.half();
+			}
+		};
+
+#ifndef EIGEN_VECTORIZE_AVX2
+		template<>
+		EIGEN_STRONG_INLINE Packet8f bit_to_ur_float<Packet8i>(const Packet8i& x)
+		{
+			const Packet4i lower = pset1<Packet4i>(0x7FFFFF),
+				upper = pset1<Packet4i>(127 << 23);
+			const Packet8f one = pset1<Packet8f>(1);
+
+			Packet4i x1, x2;
+			split_two(x, x1, x2);
+
+			return psub(reinterpret_to_float(
+				combine_two(por(pand(x1, lower), upper), por(pand(x2, lower), upper)
+				)), one);
+		}
+
+		template<>
+		EIGEN_STRONG_INLINE Packet4d bit_to_ur_double<Packet8i>(const Packet8i& x)
+		{
+			const Packet4i lower = pseti64<Packet4i>(0xFFFFFFFFFFFFFull),
+				upper = pseti64<Packet4i>(1023ull << 52);
+			const Packet4d one = pset1<Packet4d>(1);
+
+			Packet4i x1, x2;
+			split_two(x, x1, x2);
+
+			return psub(reinterpret_to_double(
+				combine_two(por(pand(x1, lower), upper), por(pand(x2, lower), upper)
+				)), one);
+		}
+#endif
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet8f, Rng> : public RawbitsMaker<Packet8i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet8f zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm256_cvtepi32_ps(pand(this->rawbits(rng), pset1<Packet8i>(0x7FFFFFFF))),
+					pset1<Packet8f>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet8f uniform_real(Rng& rng)
+			{
+				return bit_to_ur_float(this->rawbits_34(rng));
+			}
+		};
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet4d, Rng> : public RawbitsMaker<Packet8i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet4d zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm256_cvtepi32_pd(pand(this->rawbits_half(rng), pset1<Packet4i>(0x7FFFFFFF))),
+					pset1<Packet4d>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet4d uniform_real(Rng& rng)
+			{
+				return bit_to_ur_double(this->rawbits(rng));
+			}
+		};
+	}
+}
+#endif
+
+#ifdef EIGEN_VECTORIZE_SSE2
+#include <xmmintrin.h>
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Rng, typename RngResult>
+		struct RawbitsMaker<Packet4i, Rng, RngResult, Rand::RandomEngineType::scalar>
+		{
+			EIGEN_STRONG_INLINE Packet4i rawbits(Rng& rng)
+			{
+				if (sizeof(RngResult) == 8)
+				{
+					return _mm_set_epi64x(rng(), rng());
+				}
+				else
+				{
+					return _mm_set_epi32(rng(), rng(), rng(), rng());
+				}
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_34(Rng& rng)
+			{
+				if (sizeof(RngResult) == 8)
+				{
+					return _mm_set_epi64x(rng(), rng());
+				}
+				else
+				{
+#ifdef EIGEN_VECTORIZE_SSSE3
+					Packet4i p = _mm_setr_epi32(rng(), rng(), rng(), 0);
+					return _mm_shuffle_epi8(p, _mm_setr_epi8(
+						0, 1, 2, 3,
+						4, 5, 6, 7,
+						8, 9, 10, 11,
+						3, 7, 11, 11));
+#else
+					return _mm_set_epi32(rng(), rng(), rng(), rng());
+#endif
+				}
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				if (sizeof(decltype(rng())) == 8)
+				{
+					return _mm_set_epi64x(0, rng());
+				}
+				else
+				{
+					return _mm_setr_epi32(rng(), rng(), 0, 0);
+				}
+			}
+		};
+
+		template<typename Rng>
+		struct RawbitsMaker<Packet4i, Rng, Packet4i, Rand::RandomEngineType::packet>
+		{
+			EIGEN_STRONG_INLINE Packet4i rawbits(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_34(Rng& rng)
+			{
+				return rng();
+			}
+
+			EIGEN_STRONG_INLINE Packet4i rawbits_half(Rng& rng)
+			{
+				return rng();
+			}
+		};
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet4f, Rng> : public RawbitsMaker<Packet4i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet4f zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm_cvtepi32_ps(pand(this->rawbits(rng), pset1<Packet4i>(0x7FFFFFFF))),
+					pset1<Packet4f>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet4f uniform_real(Rng& rng)
+			{
+				return bit_to_ur_float(this->rawbits_34(rng));
+			}
+		};
+
+		template<typename Rng>
+		struct UniformRealUtils<Packet2d, Rng> : public RawbitsMaker<Packet4i, Rng>
+		{
+			EIGEN_STRONG_INLINE Packet2d zero_to_one(Rng& rng)
+			{
+				return pdiv(_mm_cvtepi32_pd(pand(this->rawbits_half(rng), pset1<Packet4i>(0x7FFFFFFF))),
+					pset1<Packet2d>(0x7FFFFFFF));
+			}
+
+			EIGEN_STRONG_INLINE Packet2d uniform_real(Rng& rng)
+			{
+				return bit_to_ur_double(this->rawbits(rng));
+			}
+		};
+	}
+}
+#endif
+
+namespace Eigen
+{
+	namespace internal
+	{
+		template<typename Scalar, typename Rng>
+		struct scalar_base_rng
+		{
+			static_assert(
+				Rand::IsScalarRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value ||
+				Rand::IsPacketRandomEngine<
+				typename std::remove_reference<Rng>::type
+				>::value, "Rng must satisfy RandomNumberEngine");
+
+			Rng rng;
+
+			scalar_base_rng(const Rng& _rng) : rng{ _rng }
+			{
+			}
+
+			scalar_base_rng(const scalar_base_rng& o)
+				: rng{ o.rng }
+			{
+			}
+
+			scalar_base_rng(scalar_base_rng&& o)
+				: rng{ std::move(o.rng) }
+			{
+			}
+		};
+	}
+}
+
+#endif

data/vendor/EigenRand/EigenRand/doc.h

@@ -0,0 +1,220 @@
+/**
+ @mainpage EigenRand : The Fastest C++11-compatible random distribution generator for Eigen
+ 
+ EigenRand is a header-only library for [Eigen](http://eigen.tuxfamily.org/index.php?title=Main_Page), providing vectorized random number engines and vectorized random distribution generators. 
+ Since the classic Random functions of Eigen relies on an old C function `rand()`, 
+ there is no way to control random numbers and no guarantee for quality of generated numbers. 
+ In addition, Eigen's Random is slow because rand() is hard to vectorize.
+ 
+ EigenRand provides a variety of random distribution functions similar to C++11 standard's random functions, 
+ which can be vectorized and easily integrated into Eigen's expressions of Matrix and Array.
+ 
+ You can get 5~10 times speed by just replacing old Eigen's Random 
+ or unvectorizable c++11 random number generators with EigenRand.
+ 
+ EigenRand currently supports only x86-64 architecture (SSE, AVX, AVX2).
+
+ EigenRand is distributed under the MIT License.
+
+ If you want to contribute or report bugs, please visit Github repository https://github.com/bab2min/EigenRand.
+ 
+
+ - @link getting_started Getting Started @endlink
+ - @link list_of_supported_distribution List of Supported Random Distribution @endlink
+ - @link performance Performance @endlink
+
+ @page getting_started Getting Started
+
+ @section getting_started_1 Installation
+
+ You can install EigenRand by just downloading the source codes from [the repository](https://github.com/bab2min/EigenRand/releases). 
+ Since EigenRand is a header-only library like Eigen, none of binaries needs to be installed. 
+ All you need is [Eigen 3.3.7](http://eigen.tuxfamily.org/index.php?title=Main_Page) and C++11 compiler.
+
+ @section getting_started_2 Simple Random Matrix Generators
+ @code
+ #include <iostream>
+ #include <Eigen/Dense>
+ #include <EigenRand/EigenRand>
+
+ using namespace Eigen;
+
+ int main()
+ {
+   // Initialize random number generator with seed=42 for following codes.
+   // Or you can use C++11 RNG such as std::mt19937 or std::ranlux48.
+   Rand::Vmt19937_64 urng{ 42 };
+
+   // this will generate 4x4 real matrix with range [-1, 1]
+   MatrixXf mat = Rand::balanced<MatrixXf>(4, 4, urng);
+   std::cout << mat << std::endl;
+
+   // this will generate 10x10 real 2d array on the normal distribution
+   ArrayXXf arr = Rand::normal<ArrayXXf>(10, 10, urng);
+   std::cout << arr << std::endl;
+
+   return 0;
+ }
+ @endcode
+
+ @section getting_started_3 Random Matrix Functions with suffix '-Like'
+ Basically, in order to call each random distribution function of EigenRand, template parameters must be passed following the dense matrix or array type to be created.
+ But, if you have an instance of Eigen::Matrix or Eigen::Array already, you can use -Like function to generate a random matrix or array with the same type and shape.
+ @code
+ #include <iostream>
+ #include <Eigen/Dense>
+ #include <EigenRand/EigenRand>
+
+ using namespace Eigen;
+
+ int main()
+ {
+   Rand::Vmt19937_64 urng{ 42 };
+
+   MatrixXf mat{ 10, 10 };
+   // this will generate a random matrix in MatrixXf type with the shape (10, 10)
+   // note: it doesn't change mat at all.
+   Rand::balancedLike(mat, urng);
+
+   // if you want to assign a random matrix into itself, use assignment operator.
+   mat = Rand::balancedLike(mat, urng);
+   std::cout << mat << std::endl;
+   return 0;
+ }
+ @endcode
+
+ Every random distribution function has its corresponding -Like function.
+
+ * @page list_of_supported_distribution List of Supported Random Distribution
+ * 
+ * 
+ @section list_of_supported_distribution_1 Random Distributions for Real types
+
+| Function | Scalar Type | Description | Equivalent to |
+|:---:|:---:|:---:|:---:|
+| `Eigen::Rand::balanced` | float, double | generates real values in the [-1, 1] range | `Eigen::DenseBase<Ty>::Random` for floating point types |
+| `Eigen::Rand::cauchy` | float, double | generates real values on the [Cauchy distribution](https://en.wikipedia.org/wiki/Cauchy_distribution). | `std::cauchy_distribution` |
+| `Eigen::Rand::chiSquared` | float, double | generates real values on a [chi-squared distribution](https://en.wikipedia.org/wiki/Chi-squared_distribution). | `std::chi_squared_distribution` |
+| `Eigen::Rand::exponential` | float, double | generates real values on an [exponential distribution](https://en.wikipedia.org/wiki/Exponential_distribution). | `std::exponential_distribution` |
+| `Eigen::Rand::extremeValue` | float, double | generates real values on an [extreme value distribution](https://en.wikipedia.org/wiki/Generalized_extreme_value_distribution). | `std::extreme_value_distribution` |
+| `Eigen::Rand::fisherF` | float, double | generates real values on the [Fisher's F distribution](https://en.wikipedia.org/wiki/F_distribution). | `std::fisher_f_distribution` |
+| `Eigen::Rand::gamma` | float, double | generates real values on a [gamma distribution](https://en.wikipedia.org/wiki/Gamma_distribution). | `std::gamma_distribution` |
+| `Eigen::Rand::lognormal` | float, double | generates real values on a [lognormal distribution](https://en.wikipedia.org/wiki/Lognormal_distribution). | `std::lognormal_distribution` |
+| `Eigen::Rand::normal` | float, double | generates real values on a [normal distribution](https://en.wikipedia.org/wiki/Normal_distribution). | `std::normal_distribution` |
+| `Eigen::Rand::studentT` | float, double | generates real values on the [Student's t distribution](https://en.wikipedia.org/wiki/Student%27s_t-distribution). | `std::student_t_distribution` |
+| `Eigen::Rand::uniformReal` | float, double | generates real values in the `[-1, 0)` range. | `std::generate_canonical` |
+| `Eigen::Rand::weibull` | float, double | generates real values on the [Weibull distribution](https://en.wikipedia.org/wiki/Weibull_distribution). | `std::weibull_distribution` |
+
+ @section list_of_supported_distribution_2 Random Distributions for Integer Types
+
+| Function | Scalar Type | Description | Equivalent to |
+|:---:|:---:|:---:|:---:|
+| `Eigen::Rand::binomial` | int | generates integers on a [binomial distribution](https://en.wikipedia.org/wiki/Binomial_distribution). | `std::binomial_distribution` |
+| `Eigen::Rand::discrete` | int | generates random integers on a discrete distribution. | `std::discrete_distribution` |
+| `Eigen::Rand::geometric` | int | generates integers on a [geometric distribution](https://en.wikipedia.org/wiki/Geometric_distribution). | `std::geometric_distribution` |
+| `Eigen::Rand::negativeBinomial` | int | generates integers on a [negative binomial distribution](https://en.wikipedia.org/wiki/Negative_binomial_distribution). | `std::negative_binomial_distribution` |
+| `Eigen::Rand::poisson` | int | generates integers on the [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution). | `std::poisson_distribution` |
+| `Eigen::Rand::randBits` | int | generates integers with random bits. | `Eigen::DenseBase<Ty>::Random` for integer types |
+| `Eigen::Rand::uniformInt` | int | generates integers in the `[min, max]` range. | `std::uniform_int_distribution` |
+
+ @section list_of_supported_distribution_3 Random Number Engines
+
+|  | Description | Equivalent to |
+|:---:|:---:|:---:|
+| `Eigen::Rand::Vmt19937_64` | a vectorized version of Mersenne Twister algorithm. It generates two 64bit random integers simultaneously with SSE2 and four integers with AVX2. | `std::mt19937_64` |
+
+ * 
+ * @page performance Performance
+ * 
+ * The following result is a measure of the time in seconds it takes to generate 1M random numbers. It shows the average of 20 times.
+
+ @section performance_1 Intel(R) Xeon(R) Platinum 8171M CPU @ 2.60GHz (Ubuntu 16.04, gcc7.5)
+
+|  | C++ std (or Eigen) | EigenRand (No Vect.) | EigenRand (SSE2) | EigenRand (SSSE3) | EigenRand (AVX) | EigenRand (AVX2) |
+|---|---:|---:|---:|---:|---:|---:|
+| `balanced`* | 9.0 | 5.9 | 1.5 | 1.4 | 1.3 | 0.9 |
+| `balanced`(double)* | 8.7 | 6.4 | 3.3 | 2.9 | 1.7 | 1.7 |
+| `binomial(20, 0.5)` | 400.8 | 118.5 | 32.7 | 36.6 | 30.0 | 22.7 |
+| `binomial(50, 0.01)` | 71.7 | 22.5 | 7.7 | 8.3 | 7.9 | 6.6 |
+| `binomial(100, 0.75)` | 340.5 | 454.5 | 91.7 | 111.5 | 106.3 | 86.4 |
+| `cauchy` | 36.1 | 54.4 | 6.1 | 7.1 | 4.7 | 3.9 |
+| `chiSquared` | 80.5 | 249.5 | 64.6 | 58.0 | 29.4 | 28.8 |
+| `discrete`(int32) | - | 14.0 | 2.9 | 2.6 | 2.4 | 1.7 |
+| `discrete`(fp32) | - | 21.9 | 4.3 | 4.0 | 3.6 | 3.0 |
+| `discrete`(fp64) | 72.4 | 21.4 | 6.9 | 6.5 | 4.9 | 3.7 |
+| `exponential` | 31.0 | 25.3 | 5.5 | 5.3 | 3.3 | 2.9 |
+| `extremeValue` | 66.0 | 60.1 | 11.9 | 10.7 | 6.5 | 5.8 |
+| `fisherF(1, 1)` | 178.1 | 35.1 | 33.2 | 39.3 | 22.9 | 18.7 |
+| `fisherF(5, 5)` | 141.8 | 415.2 | 136.47 | 172.4 | 92.4 | 74.9 |
+| `gamma(0.2, 1)` | 207.8 | 211.4 | 54.6 | 51.2 | 26.9 | 27.0 |
+| `gamma(5, 3)` | 80.9 | 60.0 | 14.3 | 13.3 | 11.4 | 8.0 |
+| `gamma(10.5, 1)` | 81.1 | 248.6 | 63.3 | 58.5 | 29.2 | 28.4 |
+| `geometric` | 43.0 | 22.4 | 6.7 | 7.4 | 5.8 |  |
+| `lognormal` | 66.3 | 55.4 | 12.8 | 11.8 | 6.2 | 6.2 |
+| `negativeBinomial(10, 0.5)` | 312.0 | 301.4 | 82.9 | 100.6 | 95.3 | 77.9 |
+| `negativeBinomial(20, 0.25)` | 483.4 | 575.9 | 125.0 | 158.2 | 148.4 | 119.5 |
+| `normal(0, 1)` | 38.1 | 28.5 | 6.8 | 6.2 | 3.8 | 3.7 |
+| `normal(2, 3)` | 37.6 | 29.0 | 7.3 | 6.6 | 4.0 | 3.9 |
+| `poisson(1)` | 31.8 | 25.2 | 9.8 | 10.8 | 9.7 | 8.2 |
+| `poisson(16)` | 231.8 | 274.1 | 66.2 | 80.7 | 74.4 | 64.2 |
+| `randBits` | 5.2 | 5.4 | 1.4 | 1.3 | 1.1 | 1.0 |
+| `studentT(1)` | 122.7 | 120.1 | 15.3 | 19.2 | 12.6 | 9.4 |
+| `studentT(20)` | 102.2 | 111.1 | 15.4 | 19.2 | 12.2 | 9.4 |
+| `uniformInt(0~63)` | 22.4 | 4.7 | 1.7 | 1.6 | 1.4 | 1.1 |
+| `uniformInt(0~100k)` | 21.8 | 10.1 | 6.2 | 6.7 | 6.6 | 5.4 |
+| `uniformReal` | 12.9 | 5.7 | 1.4 | 1.2 | 1.4 | 0.7 |
+| `weibull` | 41.0 | 35.8 | 17.7 | 15.5 | 8.5 | 8.5 |
+
+* Since there is no equivalent class to `balanced` in C++11 std, we used Eigen::DenseBase::Random instead.
+
+|  | C++ std | EigenRand (No Vect.) | EigenRand (SSE2) | EigenRand (SSSE3) | EigenRand (AVX) | EigenRand (AVX2) |
+|---|---:|---:|---:|---:|---:|---:|
+| Mersenne Twister(int32) | 4.7 | 5.6 | 4.0 | 3.7 | 3.5 | 3.6 |
+| Mersenne Twister(int64) | 5.4 | 5.3 | 4.0 | 3.9 | 3.4 | 2.6 |
+
+ @section performance_2 AMD Ryzen 7 3700x CPU @ 3.60GHz (Windows 10, MSVC2017)
+
+|  | C++ std (or Eigen) | EigenRand (SSE2) | EigenRand (AVX) | EigenRand (AVX2) |
+|---|---:|---:|---:|---:|
+| `balanced`* | 20.8 | 1.9 | 2.0 | 1.4 |
+| `balanced`(double)* | 21.7 | 4.1 | 2.7 | 3.0 |
+| `binomial(20, 0.5)` | 416.0 | 27.7 | 28.9 | 29.1 |
+| `binomial(50, 0.01)` | 37.8 | 6.3 | 6.0 | 6.6 |
+| `binomial(100, 0.75)` | 309.1 | 72.4 | 66.0 | 67.0 |
+| `cauchy` | 42.2 | 4.8 | 5.1 | 2.7 |
+| `chiSquared` | 153.8 | 33.5 | 21.2 | 17.0 |
+| `discrete`(int32) | - | 2.4 | 2.3 | 2.5 |
+| `discrete`(fp32) | - | 2.6 | 2.3 | 3.5 |
+| `discrete`(fp64) | 55.8 | 5.1 | 4.7 | 4.3 |
+| `exponential` | 33.4 | 6.4 | 2.8 | 2.2 |
+| `extremeValue` | 39.4 | 7.8 | 4.6 | 4.0 |
+| `fisherF(1, 1)` | 103.9 | 25.3 | 14.9 | 11.7 |
+| `fisherF(5, 5)` | 295.7 | 85.5 | 58.3 | 44.8 |
+| `gamma(0.2, 1)` | 128.8 | 31.9 | 18.3 | 15.8 |
+| `gamma(5, 3)` | 156.1 | 9.7 | 8.0 | 5.0 |
+| `gamma(10.5, 1)` | 148.5 | 33.1 | 21.1 | 17.2 |
+| `geometric` | 27.1 | 6.6 | 4.3 | 4.1 |
+| `lognormal` | 104.0 | 6.6 | 4.7 | 3.5 |
+| `negativeBinomial(10, 0.5)` | 462.1 | 60.0 | 56.4 | 58.6 |
+| `negativeBinomial(20, 0.25)` | 357.6 | 84.5 | 80.6 | 78.4 |
+| `normal(0, 1)` | 48.8 | 4.2 | 3.7 | 2.3 |
+| `normal(2, 3)` | 48.8 | 4.5 | 3.8 | 2.4 |
+| `poisson(1)` | 46.4 | 7.9 | 7.4 | 8.2 |
+| `poisson(16)` | 192.4 | 43.2 | 40.4 | 40.9 |
+| `randBits` | 4.2 | 1.7 | 1.5 | 1.8 |
+| `studentT(1)` | 107.0 | 12.3 | 6.8 | 5.7 |
+| `studentT(20)` | 107.1 | 12.3 | 6.8 | 5.8 |
+| `uniformInt(0~63)` | 31.2 | 1.1 | 1.0 | 1.2 |
+| `uniformInt(0~100k)` | 27.7 | 5.6 | 5.6 | 5.4 |
+| `uniformReal` | 30.7 | 1.1 | 1.0 | 0.6 |
+| `weibull` | 46.5 | 10.6 | 6.4 | 5.2 |
+
+* Since there is no equivalent class to `balanced` in C++11 std, we used Eigen::DenseBase::Random instead.
+
+|  | C++ std | EigenRand (SSE2) | EigenRand (AVX) | EigenRand (AVX2) |
+|---|---:|---:|---:|---:|
+| Mersenne Twister(int32) | 5.0 | 3.4 | 3.4 | 3.3 |
+| Mersenne Twister(int64) | 5.1 | 3.9 | 3.9 | 3.3 |
+
+ * 
+ */