numo-random 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4c6c4db2ffcb5672e571ad59dc94c36d51f87adb29007db4b9678b803840915
-  data.tar.gz: c1debe024fe523f28d97a83f7eaee51dc27cf51acfd1efa1cc44cd2994659c72
+  metadata.gz: d9c0d26c2b1751451a84c8b53c6e38b9257a82ff7d2c3479bd94d7311cfb1628
+  data.tar.gz: ae9262ff84d81abb58af7d4856e0936160c33f3a824818515878ae97ce3c9ea0
 SHA512:
-  metadata.gz: 6364e78337ab7d87b0aa3cc18a2264992cb75ab15c65b0ce41065c78eacacbb96e21e55a5872a3878cb1ab143b4f8f7145ce4475e22eca725aef8a16fa0a8409
-  data.tar.gz: c3dfbd3d29761f951176395b2c48c596efbb998b3d1650484da908e576624557c60e8aabf64b015096aa0fb33780929c5a78b598a206ea659fdb4d75cea020f3
+  metadata.gz: f153a0090d65b3ee39d5f8cde36a3669e0d12b6e4f84c56045156c42c2f5fe7dfe3de7b6d649c994bafec730ff8bbcaff09e9befa6aba04e9b5fd0d77dae8d91
+  data.tar.gz: 27af398428b05b955c690f36d948112329484f47146631b2a4f58ef60551a84039144c387e96ad49ee0d13815225930100659823ece1040fb59898e73c13dc0d

data/CHANGELOG.md

@@ -1,5 +1,18 @@
-## [Unreleased]
-- Bernoulli distribution.
+## [0.5.0]
+- Support 32-bit PCG and Mersenne Twister.
+
+```ruby
+require 'numo/random'
+
+# specify the pseudo random number generation algorithm by setting the algorithm argument of constructor.
+rng = Numo::Random::Generator.new(algorithm: 'pcg32')
+rng = Numo::Random::Generator.new(algorithm: 'pcg64') # default
+rng = Numo::Random::Generator.new(algorithm: 'mt32')
+rng = Numo::Random::Generator.new(algorithm: 'mt64')
+```
+
+## [0.4.0]
+- Add method for random number generation with bernoulli distribution: bernoulli, binomial, negative_binomial, and geometric.
 
 ## [0.3.0]
 - Change native extension filename.

data/README.md

@@ -50,6 +50,32 @@ end
 ![normal2d.png](https://user-images.githubusercontent.com/5562409/197376738-ee8d2b12-1902-4a12-bcf3-757461f2f2db.png)
 
 
+An example of generating random numbers according to the Poisson distribution:
+
+```ruby
+require 'numo/narray'
+require 'numo/gnuplot'
+
+require 'numo/random'
+
+# Creating random number generator.
+rng = Numo::Random::Generator.new(seed: 9)
+
+# Generating random numbers with Poisson distribution.
+x = rng.poisson(shape: 10000, mean: 12)
+
+# Plotting the generated result.
+h = x.bincount
+
+Numo.gnuplot do
+  set(terminal: 'png')
+  set(output: 'poisson2d.png')
+  plot(h, with: 'boxes')
+end
+```
+
+![poisson2d.png](https://user-images.githubusercontent.com/5562409/201478863-61d31eb8-7c0b-4406-b255-fff29187a16a.png)
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/numo-random.

data/ext/numo/random/ext.cpp

@@ -22,5 +22,8 @@ extern "C" void Init_ext(void) {
   rb_require("numo/narray");
 
   VALUE rb_mNumoRandom = rb_define_module_under(mNumo, "Random");
-  RbNumoRandomPCG64::define_class(rb_mNumoRandom);
+  RbNumoRandomPCG32::define_class(rb_mNumoRandom, "PCG32");
+  RbNumoRandomPCG64::define_class(rb_mNumoRandom, "PCG64");
+  RbNumoRandomMT32::define_class(rb_mNumoRandom, "MT32");
+  RbNumoRandomMT64::define_class(rb_mNumoRandom, "MT64");
 }

data/ext/numo/random/ext.hpp

@@ -28,71 +28,74 @@
 
 #include <pcg_random.hpp>
 
-class RbNumoRandomPCG64 {
+template<class Rng, class Impl> class RbNumoRandom {
 public:
-  static VALUE numo_random_pcg64_alloc(VALUE self) {
-    pcg64* ptr = (pcg64*)ruby_xmalloc(sizeof(pcg64));
-    new (ptr) pcg64();
-    return TypedData_Wrap_Struct(self, &pcg64_type, ptr);
+  // static const rb_data_type_t rng_type;
+
+  static VALUE numo_random_alloc(VALUE self) {
+    Rng* ptr = (Rng*)ruby_xmalloc(sizeof(Rng));
+    new (ptr) Rng();
+    return TypedData_Wrap_Struct(self, &Impl::rng_type, ptr);
   }
 
-  static void numo_random_pcg64_free(void* ptr) {
-    ((pcg64*)ptr)->~pcg64();
+  static void numo_random_free(void* ptr) {
+    ((Rng*)ptr)->~Rng();
     ruby_xfree(ptr);
   }
 
-  static size_t numo_random_pcg64_size(const void* ptr) {
-    return sizeof(*((pcg64*)ptr));
+  static size_t numo_random_size(const void* ptr) {
+    return sizeof(*((Rng*)ptr));
   }
 
-  static pcg64* get_pcg64(VALUE self) {
-    pcg64* ptr;
-    TypedData_Get_Struct(self, pcg64, &pcg64_type, ptr);
+  static Rng* get_rng(VALUE self) {
+    Rng* ptr;
+    TypedData_Get_Struct(self, Rng, &Impl::rng_type, ptr);
     return ptr;
   }
 
-  static VALUE define_class(VALUE rb_mNumoRandom) {
-    VALUE rb_cPCG64 = rb_define_class_under(rb_mNumoRandom, "PCG64", rb_cObject);
-    rb_define_alloc_func(rb_cPCG64, numo_random_pcg64_alloc);
-    rb_define_method(rb_cPCG64, "initialize", RUBY_METHOD_FUNC(_numo_random_pcg64_init), -1);
-    rb_define_method(rb_cPCG64, "seed=", RUBY_METHOD_FUNC(_numo_random_pcg64_set_seed), 1);
-    rb_define_method(rb_cPCG64, "seed", RUBY_METHOD_FUNC(_numo_random_pcg64_get_seed), 0);
-    rb_define_method(rb_cPCG64, "random", RUBY_METHOD_FUNC(_numo_random_pcg64_random), 0);
-    rb_define_method(rb_cPCG64, "exponential", RUBY_METHOD_FUNC(_numo_random_pcg64_exponential), -1);
-    rb_define_method(rb_cPCG64, "gamma", RUBY_METHOD_FUNC(_numo_random_pcg64_gamma), -1);
-    rb_define_method(rb_cPCG64, "gumbel", RUBY_METHOD_FUNC(_numo_random_pcg64_gumbel), -1);
-    rb_define_method(rb_cPCG64, "poisson", RUBY_METHOD_FUNC(_numo_random_pcg64_poisson), -1);
-    rb_define_method(rb_cPCG64, "weibull", RUBY_METHOD_FUNC(_numo_random_pcg64_weibull), -1);
-    rb_define_method(rb_cPCG64, "discrete", RUBY_METHOD_FUNC(_numo_random_pcg64_discrete), -1);
-    rb_define_method(rb_cPCG64, "uniform", RUBY_METHOD_FUNC(_numo_random_pcg64_uniform), -1);
-    rb_define_method(rb_cPCG64, "cauchy", RUBY_METHOD_FUNC(_numo_random_pcg64_cauchy), -1);
-    rb_define_method(rb_cPCG64, "chisquare", RUBY_METHOD_FUNC(_numo_random_pcg64_chisquare), -1);
-    rb_define_method(rb_cPCG64, "f", RUBY_METHOD_FUNC(_numo_random_pcg64_f), -1);
-    rb_define_method(rb_cPCG64, "normal", RUBY_METHOD_FUNC(_numo_random_pcg64_normal), -1);
-    rb_define_method(rb_cPCG64, "lognormal", RUBY_METHOD_FUNC(_numo_random_pcg64_lognormal), -1);
-    rb_define_method(rb_cPCG64, "standard_t", RUBY_METHOD_FUNC(_numo_random_pcg64_standard_t), -1);
-    return rb_cPCG64;
+  static VALUE define_class(VALUE rb_mNumoRandom, const char* class_name) {
+    VALUE rb_cRng = rb_define_class_under(rb_mNumoRandom, class_name, rb_cObject);
+    rb_define_alloc_func(rb_cRng, numo_random_alloc);
+    rb_define_method(rb_cRng, "initialize", RUBY_METHOD_FUNC(_numo_random_init), -1);
+    rb_define_method(rb_cRng, "seed=", RUBY_METHOD_FUNC(_numo_random_set_seed), 1);
+    rb_define_method(rb_cRng, "seed", RUBY_METHOD_FUNC(_numo_random_get_seed), 0);
+    rb_define_method(rb_cRng, "random", RUBY_METHOD_FUNC(_numo_random_random), 0);
+    rb_define_method(rb_cRng, "binomial", RUBY_METHOD_FUNC(_numo_random_binomial), -1);
+    rb_define_method(rb_cRng, "negative_binomial", RUBY_METHOD_FUNC(_numo_random_negative_binomial), -1);
+    rb_define_method(rb_cRng, "geometric", RUBY_METHOD_FUNC(_numo_random_geometric), -1);
+    rb_define_method(rb_cRng, "exponential", RUBY_METHOD_FUNC(_numo_random_exponential), -1);
+    rb_define_method(rb_cRng, "gamma", RUBY_METHOD_FUNC(_numo_random_gamma), -1);
+    rb_define_method(rb_cRng, "gumbel", RUBY_METHOD_FUNC(_numo_random_gumbel), -1);
+    rb_define_method(rb_cRng, "poisson", RUBY_METHOD_FUNC(_numo_random_poisson), -1);
+    rb_define_method(rb_cRng, "weibull", RUBY_METHOD_FUNC(_numo_random_weibull), -1);
+    rb_define_method(rb_cRng, "discrete", RUBY_METHOD_FUNC(_numo_random_discrete), -1);
+    rb_define_method(rb_cRng, "uniform", RUBY_METHOD_FUNC(_numo_random_uniform), -1);
+    rb_define_method(rb_cRng, "cauchy", RUBY_METHOD_FUNC(_numo_random_cauchy), -1);
+    rb_define_method(rb_cRng, "chisquare", RUBY_METHOD_FUNC(_numo_random_chisquare), -1);
+    rb_define_method(rb_cRng, "f", RUBY_METHOD_FUNC(_numo_random_f), -1);
+    rb_define_method(rb_cRng, "normal", RUBY_METHOD_FUNC(_numo_random_normal), -1);
+    rb_define_method(rb_cRng, "lognormal", RUBY_METHOD_FUNC(_numo_random_lognormal), -1);
+    rb_define_method(rb_cRng, "standard_t", RUBY_METHOD_FUNC(_numo_random_standard_t), -1);
+    return rb_cRng;
   }
 
 private:
-  static const rb_data_type_t pcg64_type;
-
   // #initialize
 
-  static VALUE _numo_random_pcg64_init(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_init(int argc, VALUE* argv, VALUE self) {
     VALUE kw_args = Qnil;
     ID kw_table[1] = { rb_intern("seed") };
     VALUE kw_values[1] = { Qundef };
     rb_scan_args(argc, argv, ":", &kw_args);
     rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     if (kw_values[0] == Qundef || NIL_P(kw_values[0])) {
       std::random_device rd;
       const unsigned int seed = rd();
-      new (ptr) pcg64(seed);
+      new (ptr) Rng(seed);
       rb_iv_set(self, "seed", UINT2NUM(seed));
     } else {
-      new (ptr) pcg64(NUM2LONG(kw_values[0]));
+      new (ptr) Rng(NUM2LONG(kw_values[0]));
       rb_iv_set(self, "seed", kw_values[0]);
     }
     return Qnil;
@@ -100,23 +103,23 @@ private:
 
   // #seed=
 
-  static VALUE _numo_random_pcg64_set_seed(VALUE self, VALUE seed) {
-    get_pcg64(self)->seed(NUM2LONG(seed));
+  static VALUE _numo_random_set_seed(VALUE self, VALUE seed) {
+    get_rng(self)->seed(NUM2LONG(seed));
     rb_iv_set(self, "seed", seed);
     return Qnil;
   }
 
   // #seed
 
-  static VALUE _numo_random_pcg64_get_seed(VALUE self) {
+  static VALUE _numo_random_get_seed(VALUE self) {
     return rb_iv_get(self, "seed");
   }
 
   // #random
 
-  static VALUE _numo_random_pcg64_random(VALUE self) {
+  static VALUE _numo_random_random(VALUE self) {
     std::uniform_real_distribution<double> uniform_dist(0, 1);
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     const double x = uniform_dist(*ptr);
     return DBL2NUM(x);
   }
@@ -125,7 +128,7 @@ private:
 
   template<class D> struct rand_opt_t {
     D dist;
-    pcg64* rnd;
+    Rng* rnd;
   };
 
   template<class D, typename T> static void _iter_rand(na_loop_t* const lp) {
@@ -149,10 +152,161 @@ private:
     }
   }
 
+  // #binomial
+
+  template<typename T> static void _rand_binomial(VALUE& self, VALUE& x, const long n, const double& p) {
+    Rng* ptr = get_rng(self);
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+    std::binomial_distribution<T> binomial_dist(n, p);
+    ndfunc_t ndf = { _iter_rand<std::binomial_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
+    rand_opt_t<std::binomial_distribution<T>> opt = { binomial_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_binomial(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("n"), rb_intern("p") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cInt8 && klass != numo_cInt16 && klass != numo_cInt32 && klass != numo_cInt64
+        && klass != numo_cUInt8 && klass != numo_cUInt16 && klass != numo_cUInt32 && klass != numo_cUInt64)
+      rb_raise(rb_eTypeError, "invalid NArray class, it must be integer typed array");
+
+    const long n = NUM2LONG(kw_values[0]);
+    const double p = NUM2DBL(kw_values[1]);
+    if (n < 0) rb_raise(rb_eArgError, "n must be a non-negative value");
+    if (p < 0.0 || p > 1.0) rb_raise(rb_eArgError, "p must be >= 0 and <= 1");
+
+    if (klass == numo_cInt8) {
+      _rand_binomial<int8_t>(self, x, n, p);
+    } else if (klass == numo_cInt16) {
+      _rand_binomial<int16_t>(self, x, n, p);
+    } else if (klass == numo_cInt32) {
+      _rand_binomial<int32_t>(self, x, n, p);
+    } else if (klass == numo_cInt64) {
+      _rand_binomial<int64_t>(self, x, n, p);
+    } else if (klass == numo_cUInt8) {
+      _rand_binomial<uint8_t>(self, x, n, p);
+    } else if (klass == numo_cUInt16) {
+      _rand_binomial<uint16_t>(self, x, n, p);
+    } else if (klass == numo_cUInt32) {
+      _rand_binomial<uint32_t>(self, x, n, p);
+    } else if (klass == numo_cUInt64) {
+      _rand_binomial<uint64_t>(self, x, n, p);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #negative_binomial
+
+  template<typename T> static void _rand_negative_binomial(VALUE& self, VALUE& x, const long n, const double& p) {
+    Rng* ptr = get_rng(self);
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+    std::negative_binomial_distribution<T> negative_binomial_dist(n, p);
+    ndfunc_t ndf = { _iter_rand<std::negative_binomial_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
+    rand_opt_t<std::negative_binomial_distribution<T>> opt = { negative_binomial_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_negative_binomial(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("n"), rb_intern("p") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 2, 0, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cInt8 && klass != numo_cInt16 && klass != numo_cInt32 && klass != numo_cInt64
+        && klass != numo_cUInt8 && klass != numo_cUInt16 && klass != numo_cUInt32 && klass != numo_cUInt64)
+      rb_raise(rb_eTypeError, "invalid NArray class, it must be integer typed array");
+
+    const long n = NUM2LONG(kw_values[0]);
+    const double p = NUM2DBL(kw_values[1]);
+    if (n < 0) rb_raise(rb_eArgError, "n must be a non-negative value");
+    if (p <= 0.0 || p > 1.0) rb_raise(rb_eArgError, "p must be > 0 and <= 1");
+
+    if (klass == numo_cInt8) {
+      _rand_negative_binomial<int8_t>(self, x, n, p);
+    } else if (klass == numo_cInt16) {
+      _rand_negative_binomial<int16_t>(self, x, n, p);
+    } else if (klass == numo_cInt32) {
+      _rand_negative_binomial<int32_t>(self, x, n, p);
+    } else if (klass == numo_cInt64) {
+      _rand_negative_binomial<int64_t>(self, x, n, p);
+    } else if (klass == numo_cUInt8) {
+      _rand_negative_binomial<uint8_t>(self, x, n, p);
+    } else if (klass == numo_cUInt16) {
+      _rand_negative_binomial<uint16_t>(self, x, n, p);
+    } else if (klass == numo_cUInt32) {
+      _rand_negative_binomial<uint32_t>(self, x, n, p);
+    } else if (klass == numo_cUInt64) {
+      _rand_negative_binomial<uint64_t>(self, x, n, p);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #geometric
+
+  template<typename T> static void _rand_geometric(VALUE& self, VALUE& x, const double& p) {
+    Rng* ptr = get_rng(self);
+    ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
+    std::geometric_distribution<T> geometric_dist(p);
+    ndfunc_t ndf = { _iter_rand<std::geometric_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
+    rand_opt_t<std::geometric_distribution<T>> opt = { geometric_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_geometric(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = { rb_intern("p") };
+    VALUE kw_values[1] = { Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 0, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cInt8 && klass != numo_cInt16 && klass != numo_cInt32 && klass != numo_cInt64
+        && klass != numo_cUInt8 && klass != numo_cUInt16 && klass != numo_cUInt32 && klass != numo_cUInt64)
+      rb_raise(rb_eTypeError, "invalid NArray class, it must be integer typed array");
+
+    const double p = NUM2DBL(kw_values[0]);
+    if (p <= 0.0 || p >= 1.0) rb_raise(rb_eArgError, "p must be > 0 and < 1");
+
+    if (klass == numo_cInt8) {
+      _rand_geometric<int8_t>(self, x,  p);
+    } else if (klass == numo_cInt16) {
+      _rand_geometric<int16_t>(self, x, p);
+    } else if (klass == numo_cInt32) {
+      _rand_geometric<int32_t>(self, x, p);
+    } else if (klass == numo_cInt64) {
+      _rand_geometric<int64_t>(self, x, p);
+    } else if (klass == numo_cUInt8) {
+      _rand_geometric<uint8_t>(self, x, p);
+    } else if (klass == numo_cUInt16) {
+      _rand_geometric<uint16_t>(self, x, p);
+    } else if (klass == numo_cUInt32) {
+      _rand_geometric<uint32_t>(self, x, p);
+    } else if (klass == numo_cUInt64) {
+      _rand_geometric<uint64_t>(self, x, p);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
   // #exponential
 
   template<typename T> static void _rand_exponential(VALUE& self, VALUE& x, const double& lam) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::exponential_distribution<T> exponential_dist(lam);
     ndfunc_t ndf = { _iter_rand<std::exponential_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -160,7 +314,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_exponential(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_exponential(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[1] = { rb_intern("scale") };
@@ -188,7 +342,7 @@ private:
   // #gamma
 
   template<typename T> static void _rand_gamma(VALUE& self, VALUE& x, const double& k, const double&scale) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::gamma_distribution<T> gamma_dist(k, scale);
     ndfunc_t ndf = { _iter_rand<std::gamma_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -196,7 +350,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_gamma(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_gamma(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("k"), rb_intern("scale") };
@@ -225,7 +379,7 @@ private:
   // #gumbel
 
   template<typename T> static void _rand_gumbel(VALUE& self, VALUE& x, const double& loc, const double&scale) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::extreme_value_distribution<T> extreme_value_dist(loc, scale);
     ndfunc_t ndf = { _iter_rand<std::extreme_value_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -233,7 +387,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_gumbel(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_gumbel(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("loc"), rb_intern("scale") };
@@ -261,7 +415,7 @@ private:
   // #poisson
 
   template<typename T> static void _rand_poisson(VALUE& self, VALUE& x, const double& mean) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::poisson_distribution<T> poisson_dist(mean);
     ndfunc_t ndf = { _iter_rand<std::poisson_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -269,11 +423,11 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_poisson(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_poisson(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
-    ID kw_table[2] = { rb_intern("mean") };
-    VALUE kw_values[2] = { Qundef, Qundef };
+    ID kw_table[1] = { rb_intern("mean") };
+    VALUE kw_values[1] = { Qundef };
     rb_scan_args(argc, argv, "1:", &x, &kw_args);
     rb_get_kwargs(kw_args, kw_table, 0, 1, kw_values);
 
@@ -310,7 +464,7 @@ private:
   // #weibull
 
   template<typename T> static void _rand_weibull(VALUE& self, VALUE& x, const double& k, const double&scale) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::weibull_distribution<T> weibull_dist(k, scale);
     ndfunc_t ndf = { _iter_rand<std::weibull_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -318,7 +472,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_weibull(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_weibull(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("k"), rb_intern("scale") };
@@ -347,7 +501,7 @@ private:
   // #discrete
 
   template<typename T, typename P> static void _rand_discrete(VALUE& self, VALUE& x, const std::vector<P>& weight) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::discrete_distribution<T> discrete_dist(weight.begin(), weight.end());
     ndfunc_t ndf = { _iter_rand<std::discrete_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -355,7 +509,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_discrete(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_discrete(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[1] = { rb_intern("weight") };
@@ -430,7 +584,7 @@ private:
   // #uniform
 
   template<typename T> static void _rand_uniform(VALUE& self, VALUE& x, const double& low, const double& high) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::uniform_real_distribution<T> uniform_dist(low, high);
     ndfunc_t ndf = { _iter_rand<std::uniform_real_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -438,7 +592,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_uniform(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_uniform(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("low"), rb_intern("high") };
@@ -466,7 +620,7 @@ private:
   // #cauchy
 
   template<typename T> static void _rand_cauchy(VALUE& self, VALUE& x, const double& loc, const double& scale) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::cauchy_distribution<T> cauchy_dist(loc, scale);
     ndfunc_t ndf = { _iter_rand<std::cauchy_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -474,7 +628,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_cauchy(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_cauchy(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("loc"), rb_intern("scale") };
@@ -502,7 +656,7 @@ private:
   // #chisqure
 
   template<typename T> static void _rand_chisquare(VALUE& self, VALUE& x, const double& df) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::chi_squared_distribution<T> chisquare_dist(df);
     ndfunc_t ndf = { _iter_rand<std::chi_squared_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -510,7 +664,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_chisquare(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_chisquare(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[1] = { rb_intern("df") };
@@ -537,7 +691,7 @@ private:
   // #f
 
   template<typename T> static void _rand_f(VALUE& self, VALUE& x, const double& dfnum, const double& dfden) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::fisher_f_distribution<T> f_dist(dfnum, dfden);
     ndfunc_t ndf = { _iter_rand<std::fisher_f_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -545,7 +699,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_f(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_f(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("dfnum"), rb_intern("dfden") };
@@ -574,7 +728,7 @@ private:
   // #normal
 
   template<typename T> static void _rand_normal(VALUE& self, VALUE& x, const double& loc, const double& scale) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::normal_distribution<T> normal_dist(loc, scale);
     ndfunc_t ndf = { _iter_rand<std::normal_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -582,7 +736,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_normal(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_normal(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("loc"), rb_intern("scale") };
@@ -610,7 +764,7 @@ private:
   // #lognormal
 
   template<typename T> static void _rand_lognormal(VALUE& self, VALUE& x, const double& mean, const double& sigma) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::lognormal_distribution<T> lognormal_dist(mean, sigma);
     ndfunc_t ndf = { _iter_rand<std::lognormal_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -618,7 +772,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_lognormal(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_lognormal(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[2] = { rb_intern("mean"), rb_intern("sigma") };
@@ -646,7 +800,7 @@ private:
   // #standard_t
 
   template<typename T> static void _rand_t(VALUE& self, VALUE& x, const double& df) {
-    pcg64* ptr = get_pcg64(self);
+    Rng* ptr = get_rng(self);
     ndfunc_arg_in_t ain[1] = { { OVERWRITE, 0 } };
     std::student_t_distribution<T> t_dist(df);
     ndfunc_t ndf = { _iter_rand<std::student_t_distribution<T>, T>, FULL_LOOP, 1, 0, ain, 0 };
@@ -654,7 +808,7 @@ private:
     na_ndloop3(&ndf, &opt, 1, x);
   }
 
-  static VALUE _numo_random_pcg64_standard_t(int argc, VALUE* argv, VALUE self) {
+  static VALUE _numo_random_standard_t(int argc, VALUE* argv, VALUE self) {
     VALUE x = Qnil;
     VALUE kw_args = Qnil;
     ID kw_table[1] = { rb_intern("df") };
@@ -679,16 +833,72 @@ private:
   }
 };
 
-const rb_data_type_t RbNumoRandomPCG64::pcg64_type = {
+class RbNumoRandomPCG32 : public RbNumoRandom<pcg32, RbNumoRandomPCG32> {
+public:
+  static const rb_data_type_t rng_type;
+};
+
+const rb_data_type_t RbNumoRandomPCG32::rng_type = {
+  "RbNumoRandomPCG32",
+  {
+    NULL,
+    RbNumoRandomPCG32::numo_random_free,
+    RbNumoRandomPCG32::numo_random_size
+  },
+  NULL,
+  NULL,
+  0
+};
+
+class RbNumoRandomPCG64 : public RbNumoRandom<pcg64, RbNumoRandomPCG64> {
+public:
+  static const rb_data_type_t rng_type;
+};
+
+const rb_data_type_t RbNumoRandomPCG64::rng_type = {
   "RbNumoRandomPCG64",
   {
     NULL,
-    RbNumoRandomPCG64::numo_random_pcg64_free,
-    RbNumoRandomPCG64::numo_random_pcg64_size
+    RbNumoRandomPCG64::numo_random_free,
+    RbNumoRandomPCG64::numo_random_size
+  },
+  NULL,
+  NULL,
+  0
+};
+
+class RbNumoRandomMT32 : public RbNumoRandom<std::mt19937, RbNumoRandomMT32> {
+public:
+  static const rb_data_type_t rng_type;
+};
+
+const rb_data_type_t RbNumoRandomMT32::rng_type = {
+  "RbNumoRandomMT32",
+  {
+    NULL,
+    RbNumoRandomMT32::numo_random_free,
+    RbNumoRandomMT32::numo_random_size
+  },
+  NULL,
+  NULL,
+  0
+};
+
+class RbNumoRandomMT64 : public RbNumoRandom<std::mt19937_64, RbNumoRandomMT64> {
+public:
+  static const rb_data_type_t rng_type;
+};
+
+const rb_data_type_t RbNumoRandomMT64::rng_type = {
+  "RbNumoRandomMT64",
+  {
+    NULL,
+    RbNumoRandomMT64::numo_random_free,
+    RbNumoRandomMT64::numo_random_size
   },
   NULL,
   NULL,
-  RUBY_TYPED_FREE_IMMEDIATELY
+  0
 };
 
 #endif /* NUMO_RANDOM_EXT_HPP */

data/lib/numo/random/generator.rb

@@ -24,10 +24,21 @@ module Numo
       # Creates a new random number generator.
       #
       # @param seed [Integer] random seed used to initialize the random number generator.
-      # @param algorithm [String] random number generation algorithm.
-      def initialize(seed: nil, algorithm: 'pcg64') # rubocop:disable Lint/UnusedMethodArgument
-        @algorithm = 'pcg64'
-        @rng = PCG64.new(seed: seed)
+      # @param algorithm [String] random number generation algorithm ('mt32', 'mt64', 'pcg32', and 'pcg64').
+      def initialize(seed: nil, algorithm: 'pcg64') # rubocop:disable Metrics/MethodLength
+        @algorithm = algorithm.to_s
+        @rng = case @algorithm
+               when 'mt32'
+                 MT32.new(seed: seed)
+               when 'mt64'
+                 MT64.new(seed: seed)
+               when 'pcg32'
+                 PCG32.new(seed: seed)
+               when 'pcg64'
+                 PCG64.new(seed: seed)
+               else
+                 raise ArgumentError, "Numo::Random::Generator does not support '#{@algorithm}' algorithm"
+               end
       end
 
       # Returns the seed of random number generator.
@@ -57,6 +68,78 @@ module Numo
         rng.random
       end
 
+      # Generates array consists of random values according to the Bernoulli distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   x = rng.bernoulli(shape: 1000, p: 0.4)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param p [Float] probability of success.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def bernoulli(shape:, p:, dtype: :int32)
+        binomial(shape: shape, n: 1, p: p, dtype: dtype)
+      end
+
+      # Generates array consists of random values according to a binomial distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   x = rng.binomial(shape: 1000, n: 10, p: 0.4)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param n [Integer] number of trials.
+      # @param p [Float] probability of success.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def binomial(shape:, n:, p:, dtype: :int32)
+        x = klass(dtype).new(shape)
+        rng.binomial(x, n: n, p: p)
+        x
+      end
+
+      # Generates array consists of random values according to a negative binomial distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   x = rng.negative_binomial(shape: 1000, n: 10, p: 0.4)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param n [Integer] number of trials.
+      # @param p [Float] probability of success.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def negative_binomial(shape:, n:, p:, dtype: :int32)
+        x = klass(dtype).new(shape)
+        rng.negative_binomial(x, n: n, p: p)
+        x
+      end
+
+      # Generates array consists of random values according to a geometric distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   x = rng.geometric(shape: 1000, p: 0.4)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param p [Float] probability of success on each trial.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def geometric(shape:, p:, dtype: :int32)
+        x = klass(dtype).new(shape)
+        rng.geometric(x, p: p)
+        x
+      end
+
       # Generates array consists of random values with an exponential distribution.
       #
       # @example

data/lib/numo/random/version.rb

@@ -3,6 +3,6 @@
 module Numo
   module Random
     # The version of Numo::Random you install.
-    VERSION = '0.3.0'
+    VERSION = '0.5.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-random
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.5.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-11-05 00:00:00.000000000 Z
+date: 2022-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray