numo-random 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18a6bedc77eb910e04462508a925d336fe2e5e8c29f9c159643adea1e0988a88
-  data.tar.gz: 728c52eb3e9f390cae89d149e6d4305228be5330e90fa39494ac0a1ffa546126
+  metadata.gz: 9c0f7c2bfe21c7c499f2d18453607b78ccd48bfea287336a3ce8ca4bee1a30e0
+  data.tar.gz: cef6d2005611cabe21606d3b9e3fe31b82ee9e34e909206c6b0b89b6fc78115d
 SHA512:
-  metadata.gz: cd851012b81e6cec4d4dc7e37113ca9c6d5e0a56604107bba201a67cc4935f3618f887285a0c745adf3ad6c25493bbe6bd5fe4af49cac08eead625cb0c6afa78
-  data.tar.gz: 88f85185352601de72dbf8889095e2603c0b581750c11d683eddab26ab313f30c1b38577a1a3a099d2dc6834d29e0fbe2e53052e05918e5de00648adfcf9930d
+  metadata.gz: 7e42a2ecae4e48173c0f96a8d5170bed05165c378289a3b84c1fdad56bd8dcc392b53596c1d3501ddf151bfdd6b10ae82032b6b6ca4f1f03a38e87e8ff83f418
+  data.tar.gz: 96f8de00675b3762ed859a5a9afef3fa8f2fe8a7d48562a3aae267d78caa963e9ddc6c514a6c14a0121b4ab1d633d370a04b6fd64551a60b46e03f73c94682b9

data/CHANGELOG.md

@@ -1,9 +1,11 @@
-## [Unreleased]
-- Bernoulli distribution.
-- Poisson distribution.
+## [0.4.0]
+- Add method for random number generation with bernoulli distribution: bernoulli, binomial, negative_binomial, and geometric.
 
-## [0.2.0]
+## [0.3.0]
+- Change native extension filename.
+- Add methods for random number generation with poisson distributions: poisson, exponential, gamma, gumbel, and weibull.
 
+## [0.2.0]
 - Add discrete method.
 
 ### Breaking Changes

data/ext/numo/random/{randomext.cpp → ext.cpp}

@@ -16,9 +16,9 @@
  * limitations under the License.
  */
 
-#include "randomext.hpp"
+#include "ext.hpp"
 
-extern "C" void Init_randomext(void) {
+extern "C" void Init_ext(void) {
   rb_require("numo/narray");
 
   VALUE rb_mNumoRandom = rb_define_module_under(mNumo, "Random");

data/ext/numo/random/{randomext.hpp → ext.hpp}

@@ -16,8 +16,8 @@
  * limitations under the License.
  */
 
-#ifndef NUMO_RANDOMEXT_HPP
-#define NUMO_RANDOMEXT_HPP 1
+#ifndef NUMO_RANDOM_EXT_HPP
+#define NUMO_RANDOM_EXT_HPP 1
 
 #include <ruby.h>
 
@@ -58,6 +58,14 @@ public:
     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, "binomial", RUBY_METHOD_FUNC(_numo_random_pcg64_binomial), -1);
+    rb_define_method(rb_cPCG64, "negative_binomial", RUBY_METHOD_FUNC(_numo_random_pcg64_negative_binomial), -1);
+    rb_define_method(rb_cPCG64, "geometric", RUBY_METHOD_FUNC(_numo_random_pcg64_geometric), -1);
+    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);
@@ -144,6 +152,352 @@ private:
     }
   }
 
+  // #binomial
+
+  template<typename T> static void _rand_binomial(VALUE& self, VALUE& x, const long n, const double& p) {
+    pcg64* ptr = get_pcg64(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_pcg64_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) {
+    pcg64* ptr = get_pcg64(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_pcg64_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) {
+    pcg64* ptr = get_pcg64(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_pcg64_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);
+    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 };
+    rand_opt_t<std::exponential_distribution<T>> opt = { exponential_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_exponential(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = { rb_intern("scale") };
+    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);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cSFloat && klass != numo_cDFloat) rb_raise(rb_eTypeError, "invalid NArray class, it must be DFloat or SFloat");
+
+    const double scale = kw_values[0] == Qundef ? 1.0 : NUM2DBL(kw_values[0]);
+    if (scale <= 0) rb_raise(rb_eArgError, "scale must be > 0");
+
+    const double lam = 1.0 / scale;
+    if (klass == numo_cSFloat) {
+      _rand_exponential<float>(self, x, lam);
+    } else {
+      _rand_exponential<double>(self, x, lam);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #gamma
+
+  template<typename T> static void _rand_gamma(VALUE& self, VALUE& x, const double& k, const double&scale) {
+    pcg64* ptr = get_pcg64(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 };
+    rand_opt_t<std::gamma_distribution<T>> opt = { gamma_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_gamma(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("k"), rb_intern("scale") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 1, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cSFloat && klass != numo_cDFloat) rb_raise(rb_eTypeError, "invalid NArray class, it must be DFloat or SFloat");
+
+    const double k = NUM2DBL(kw_values[0]);
+    if (k <= 0) rb_raise(rb_eArgError, "k must be > 0");
+    const double scale = kw_values[1] == Qundef ? 1.0 : NUM2DBL(kw_values[1]);
+    if (scale <= 0) rb_raise(rb_eArgError, "scale must be > 0");
+
+    if (klass == numo_cSFloat) {
+      _rand_gamma<float>(self, x, k, scale);
+    } else {
+      _rand_gamma<double>(self, x, k, scale);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #gumbel
+
+  template<typename T> static void _rand_gumbel(VALUE& self, VALUE& x, const double& loc, const double&scale) {
+    pcg64* ptr = get_pcg64(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 };
+    rand_opt_t<std::extreme_value_distribution<T>> opt = { extreme_value_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_gumbel(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("loc"), rb_intern("scale") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 0, 2, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cSFloat && klass != numo_cDFloat) rb_raise(rb_eTypeError, "invalid NArray class, it must be DFloat or SFloat");
+
+    const double loc = kw_values[0] == Qundef ? 0.0 : NUM2DBL(kw_values[0]);
+    const double scale = kw_values[1] == Qundef ? 1.0 : NUM2DBL(kw_values[1]);
+    if (scale <= 0) rb_raise(rb_eArgError, "scale must be > 0");
+
+    if (klass == numo_cSFloat) {
+      _rand_gumbel<float>(self, x, loc, scale);
+    } else {
+      _rand_gumbel<double>(self, x, loc, scale);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #poisson
+
+  template<typename T> static void _rand_poisson(VALUE& self, VALUE& x, const double& mean) {
+    pcg64* ptr = get_pcg64(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 };
+    rand_opt_t<std::poisson_distribution<T>> opt = { poisson_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_poisson(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    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);
+
+    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 mean = kw_values[0] == Qundef ? 0.0 : NUM2DBL(kw_values[0]);
+    if (mean <= 0.0) rb_raise(rb_eArgError, "mean must be > 0");
+
+    if (klass == numo_cInt8) {
+      _rand_poisson<int8_t>(self, x, mean);
+    } else if (klass == numo_cInt16) {
+      _rand_poisson<int16_t>(self, x, mean);
+    } else if (klass == numo_cInt32) {
+      _rand_poisson<int32_t>(self, x, mean);
+    } else if (klass == numo_cInt64) {
+      _rand_poisson<int64_t>(self, x, mean);
+    } else if (klass == numo_cUInt8) {
+      _rand_poisson<uint8_t>(self, x, mean);
+    } else if (klass == numo_cUInt16) {
+      _rand_poisson<uint16_t>(self, x, mean);
+    } else if (klass == numo_cUInt32) {
+      _rand_poisson<uint32_t>(self, x, mean);
+    } else if (klass == numo_cUInt64) {
+      _rand_poisson<uint64_t>(self, x, mean);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
+  // #weibull
+
+  template<typename T> static void _rand_weibull(VALUE& self, VALUE& x, const double& k, const double&scale) {
+    pcg64* ptr = get_pcg64(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 };
+    rand_opt_t<std::weibull_distribution<T>> opt = { weibull_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_weibull(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[2] = { rb_intern("k"), rb_intern("scale") };
+    VALUE kw_values[2] = { Qundef, Qundef };
+    rb_scan_args(argc, argv, "1:", &x, &kw_args);
+    rb_get_kwargs(kw_args, kw_table, 1, 1, kw_values);
+
+    const VALUE klass = rb_obj_class(x);
+    if (klass != numo_cSFloat && klass != numo_cDFloat) rb_raise(rb_eTypeError, "invalid NArray class, it must be DFloat or SFloat");
+
+    const double k = NUM2DBL(kw_values[0]);
+    if (k <= 0) rb_raise(rb_eArgError, "k must be > 0");
+    const double scale = kw_values[1] == Qundef ? 1.0 : NUM2DBL(kw_values[1]);
+    if (scale <= 0) rb_raise(rb_eArgError, "scale must be > 0");
+
+    if (klass == numo_cSFloat) {
+      _rand_weibull<float>(self, x, k, scale);
+    } else {
+      _rand_weibull<double>(self, x, k, scale);
+    }
+
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
   // #discrete
 
   template<typename T, typename P> static void _rand_discrete(VALUE& self, VALUE& x, const std::vector<P>& weight) {
@@ -491,4 +845,4 @@ const rb_data_type_t RbNumoRandomPCG64::pcg64_type = {
   RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-#endif /* NUMO_RANDOMEXT_HPP */
+#endif /* NUMO_RANDOM_EXT_HPP */

data/ext/numo/random/extconf.rb

@@ -26,4 +26,4 @@ $CXXFLAGS << " -std=c++11"
 $INCFLAGS << " -I$(srcdir)/src"
 $VPATH << "$(srcdir)/src"
 
-create_makefile("numo/random/randomext")
+create_makefile("numo/random/ext")

data/lib/numo/random/generator.rb

@@ -16,7 +16,7 @@ module Numo
     #   # Numo::DFloat#shape=[2,5]
     #   # [[1.90546, -0.543299, 0.673332, 0.759583, -0.40945],
     #   #  [0.334635, -0.0558342, 1.28115, 1.93644, -0.0689543]]
-    class Generator
+    class Generator # rubocop:disable Metrics/ClassLength
       # Returns random number generation algorithm.
       # @return [String]
       attr_accessor :algorithm
@@ -57,6 +57,171 @@ 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
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.exponential(shape: 100, scale: 2)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param scale [Float] scale parameter, lambda = 1.fdiv(scale).
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def exponential(shape:, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.exponential(x, scale: scale)
+        x
+      end
+
+      # Generates array consists of random values with a gamma distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.gamma(shape: 100, k: 9, scale: 0.5)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param k [Float] shape parameter.
+      # @param scale [Float] scale parameter.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def gamma(shape:, k:, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.gamma(x, k: k, scale: scale)
+        x
+      end
+
+      # Generates array consists of random values according to the Gumbel distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.gumbel(shape: 100, loc: 0.0, scale: 1.0)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param loc [Float] location parameter.
+      # @param scale [Float] scale parameter.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def gumbel(shape:, loc: 0.0, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.gumbel(x, loc: loc, scale: scale)
+        x
+      end
+
+      # Generates array consists of random values according to the Poisson distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   x = rng.poisson(shape: 1000, mean: 4)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param mean [Float] mean of poisson distribution.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def poisson(shape:, mean: 1.0, dtype: :int32)
+        x = klass(dtype).new(shape)
+        rng.poisson(x, mean: mean)
+        x
+      end
+
+      # Generates array consists of random values with the Weibull distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.weibull(shape: 100, k: 5, scale: 2)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param k [Float] shape parameter.
+      # @param scale [Float] scale parameter.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def weibull(shape:, k:, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.weibull(x, k: k, scale: scale)
+        x
+      end
+
       # Generates array consists of random integer values in the interval [0, n).
       #
       # @example

data/lib/numo/random/version.rb

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

data/lib/numo/random.rb

@@ -3,5 +3,5 @@
 require 'numo/narray'
 
 require_relative 'random/version'
-require_relative 'random/randomext'
+require_relative 'random/ext'
 require_relative 'random/generator'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-random
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-30 00:00:00.000000000 Z
+date: 2022-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -37,9 +37,9 @@ files:
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
+- ext/numo/random/ext.cpp
+- ext/numo/random/ext.hpp
 - ext/numo/random/extconf.rb
-- ext/numo/random/randomext.cpp
-- ext/numo/random/randomext.hpp
 - ext/numo/random/src/LICENSE.txt
 - ext/numo/random/src/pcg_extras.hpp
 - ext/numo/random/src/pcg_random.hpp