numo-random 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d990f496714f1d2a594e3f9a919f65d4458d6e9ae455bbff9fc4a118aa059770
-  data.tar.gz: 1017db53d848fb8e3c4d6724b51527d7d46974d813a93a2eb623270f24edb919
+  metadata.gz: a4c6c4db2ffcb5672e571ad59dc94c36d51f87adb29007db4b9678b803840915
+  data.tar.gz: c1debe024fe523f28d97a83f7eaee51dc27cf51acfd1efa1cc44cd2994659c72
 SHA512:
-  metadata.gz: 7df9d692aa5222adb12ff53768eb804027333f381012e3c137232d847f05bc53514193f2c566092bceedc2ec863e14d100415a6a3fb70f1de08bbf8a78f89286
-  data.tar.gz: 153d4fb9f6fc18f24e29c14b3f519dadfb0e8f979a1d4b60c31eac667c54e2d75cdaa937700f6fce9e73dc97f368dc08a4b7f2a92f77a241b909825cc573627a
+  metadata.gz: 6364e78337ab7d87b0aa3cc18a2264992cb75ab15c65b0ce41065c78eacacbb96e21e55a5872a3878cb1ab143b4f8f7145ce4475e22eca725aef8a16fa0a8409
+  data.tar.gz: c3dfbd3d29761f951176395b2c48c596efbb998b3d1650484da908e576624557c60e8aabf64b015096aa0fb33780929c5a78b598a206ea659fdb4d75cea020f3

data/CHANGELOG.md

@@ -1,7 +1,15 @@
 ## [Unreleased]
-- Sampling distribution.
 - Bernoulli distribution.
-- Poisson distribution.
+
+## [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
+- Change to return array for all methods that fill array with random numbers in Generator class.
 
 ## [0.1.0]
 - Initial release.

data/README.md

@@ -33,14 +33,11 @@ require 'numo/gnuplot'
 
 require 'numo/random'
 
-# Prepareing array to be filled with random numbers.
-x = Numo::DFloat.new(5000, 2)
-
 # Creating random number generator.
 rng = Numo::Random::Generator.new(seed: 42)
 
 # Generating random numbers with a normal distribution.
-rng.normal(x, loc: 0.0, scale: 1.0)
+x = rng.normal(shape: [5000, 2], loc: 0.0, scale: 1.0)
 
 # Plotting the generated result.
 Numo.gnuplot do

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,12 @@ 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, "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);
@@ -143,6 +149,284 @@ private:
     }
   }
 
+  // #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[2] = { rb_intern("mean") };
+    VALUE kw_values[2] = { Qundef, 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) {
+    pcg64* ptr = get_pcg64(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 };
+    rand_opt_t<std::discrete_distribution<T>> opt = { discrete_dist, ptr };
+    na_ndloop3(&ndf, &opt, 1, x);
+  }
+
+  static VALUE _numo_random_pcg64_discrete(int argc, VALUE* argv, VALUE self) {
+    VALUE x = Qnil;
+    VALUE kw_args = Qnil;
+    ID kw_table[1] = { rb_intern("weight") };
+    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);
+
+    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");
+
+    VALUE w = kw_values[0];
+    VALUE w_klass = rb_obj_class(w);
+    if (w_klass != numo_cSFloat && w_klass != numo_cDFloat) rb_raise(rb_eTypeError, "weight must be Numo::DFloat or Numo::SFloat");
+
+    if (!RTEST(nary_check_contiguous(w))) w = nary_dup(w);
+    narray_t* w_nary;
+    GetNArray(w, w_nary);
+    if (NA_NDIM(w_nary) != 1) rb_raise(rb_eArgError, "weight must be 1-dimensional array");
+
+    const size_t w_len = NA_SHAPE(w_nary)[0];
+    if (w_len < 1) rb_raise(rb_eArgError, "length of weight must be > 0");
+
+    if (w_klass == numo_cSFloat) {
+      const float* w_ptr = (float*)na_get_pointer_for_read(w);
+      std::vector<float> w_vec(w_ptr, w_ptr + w_len);
+      if (klass == numo_cInt8) {
+        _rand_discrete<int8_t, float>(self, x, w_vec);
+      } else if (klass == numo_cInt16) {
+        _rand_discrete<int16_t, float>(self, x, w_vec);
+      } else if (klass == numo_cInt32) {
+        _rand_discrete<int32_t, float>(self, x, w_vec);
+      } else if (klass == numo_cInt64) {
+        _rand_discrete<int64_t, float>(self, x, w_vec);
+      } else if (klass == numo_cUInt8) {
+        _rand_discrete<uint8_t, float>(self, x, w_vec);
+      } else if (klass == numo_cUInt16) {
+        _rand_discrete<uint16_t, float>(self, x, w_vec);
+      } else if (klass == numo_cUInt32) {
+        _rand_discrete<uint32_t, float>(self, x, w_vec);
+      } else if (klass == numo_cUInt64) {
+        _rand_discrete<uint64_t, float>(self, x, w_vec);
+      }
+    } else {
+      const double* w_ptr = (double*)na_get_pointer_for_read(w);
+      std::vector<double> w_vec(w_ptr, w_ptr + w_len);
+      if (klass == numo_cInt8) {
+        _rand_discrete<int8_t, double>(self, x, w_vec);
+      } else if (klass == numo_cInt16) {
+        _rand_discrete<int16_t, double>(self, x, w_vec);
+      } else if (klass == numo_cInt32) {
+        _rand_discrete<int32_t, double>(self, x, w_vec);
+      } else if (klass == numo_cInt64) {
+        _rand_discrete<int64_t, double>(self, x, w_vec);
+      } else if (klass == numo_cUInt8) {
+        _rand_discrete<uint8_t, double>(self, x, w_vec);
+      } else if (klass == numo_cUInt16) {
+        _rand_discrete<uint16_t, double>(self, x, w_vec);
+      } else if (klass == numo_cUInt32) {
+        _rand_discrete<uint32_t, double>(self, x, w_vec);
+      } else if (klass == numo_cUInt64) {
+        _rand_discrete<uint64_t, double>(self, x, w_vec);
+      }
+    }
+
+    RB_GC_GUARD(w);
+    RB_GC_GUARD(x);
+    return Qnil;
+  }
+
   // #uniform
 
   template<typename T> static void _rand_uniform(VALUE& self, VALUE& x, const double& low, const double& high) {
@@ -407,4 +691,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

@@ -0,0 +1,342 @@
+# frozen_string_literal: true
+
+# Ruby/Numo (NUmerical MOdules)
+module Numo
+  # Numo::Random provides random number generation with several distributions for Numo::NArray.
+  module Random
+    # Generator is a class that generates random number with several distributions.
+    #
+    # @example
+    #   require 'numo/random'
+    #
+    #   rng = Numo::Random::Generator.new(seed: 496)
+    #   x = rng.uniform(shape: [2, 5], low: -1, high: 2)
+    #
+    #   p x
+    #   # 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 # rubocop:disable Metrics/ClassLength
+      # Returns random number generation algorithm.
+      # @return [String]
+      attr_accessor :algorithm
+
+      # 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)
+      end
+
+      # Returns the seed of random number generator.
+      #
+      # @return [Integer]
+      def seed
+        rng.seed
+      end
+
+      # Sets the seed of random number generator.
+      #
+      # @param val [Integer] random seed.
+      def seed=(val)
+        rng.seed = val
+      end
+
+      # Returns random number with uniform distribution in the half-open interval [0, 1).
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   v = rng.random
+      #
+      # @return [Float]
+      def random
+        rng.random
+      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
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new(seed: 42)
+      #   w = Numo::DFloat[0.1, 0.6, 0.2]
+      #   x = rng.discrete(shape: [3, 10], weight: w)
+      #
+      #   p x
+      #
+      #   # Numo::Int32#shape=[3,10]
+      #   # [[1, 1, 1, 1, 1, 1, 1, 1, 2, 1],
+      #   #  [0, 1, 0, 1, 1, 0, 1, 1, 2, 1],
+      #   #  [2, 1, 1, 1, 1, 2, 2, 1, 1, 2]]
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param weight [Numo::DFloat | Numo::SFloat] (shape: [n]) list of probabilities of each integer being generated.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::IntX | Numo::UIntX]
+      def discrete(shape:, weight:, dtype: :int32)
+        x = klass(dtype).new(shape)
+        rng.discrete(x, weight: weight)
+        x
+      end
+
+      # Generates array consists of uniformly distributed random values in the interval [low, high).
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.uniform(shape: 100, low: -1.5, high: 1.5)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param low [Float] lower boundary.
+      # @param high [Float] upper boundary.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def uniform(shape:, low: 0.0, high: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.uniform(x, low: low, high: high)
+        x
+      end
+
+      # Generates array consists of random values according to the Cauchy (Lorentz) distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.cauchy(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 cauchy(shape:, loc: 0.0, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.cauchy(x, loc: loc, scale: scale)
+        x
+      end
+
+      # Generates array consists of random values according to the Chi-squared distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.chisquare(shape: 100, df: 2.0)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param df [Float] degrees of freedom, must be > 0.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def chisquare(shape:, df:, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.chisquare(x, df: df)
+        x
+      end
+
+      # Generates array consists of random values according to the F-distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.f(shape: 100, dfnum: 2.0, dfden: 4.0)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param dfnum [Float] degrees of freedom in numerator, must be > 0.
+      # @param dfden [Float] degrees of freedom in denominator, must be > 0.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def f(shape:, dfnum:, dfden:, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.f(x, dfnum: dfnum, dfden: dfden)
+        x
+      end
+
+      # Generates array consists of random values according to a normal (Gaussian) distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.normal(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 normal(shape:, loc: 0.0, scale: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.normal(x, loc: loc, scale: scale)
+        x
+      end
+
+      # Generates array consists of random values according to a log-normal distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.lognormal(shape: 100, mean: 0.0, sigma: 1.0)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param mean [Float] mean of normal distribution.
+      # @param sigma [Float] standard deviation of normal distribution.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def lognormal(shape:, mean: 0.0, sigma: 1.0, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.lognormal(x, mean: mean, sigma: sigma)
+        x
+      end
+
+      # Generates array consists of random values according to the Student's t-distribution.
+      #
+      # @example
+      #   require 'numo/random'
+      #
+      #   rng = Numo::Random::Generator.new
+      #   x = rng.standard_t(shape: 100, df: 8.0)
+      #
+      # @param shape [Integer | Array<Integer>] size of random array.
+      # @param df [Float] degrees of freedom, must be > 0.
+      # @param dtype [Symbol] data type of random array.
+      # @return [Numo::DFloat | Numo::SFloat]
+      def standard_t(shape:, df:, dtype: :float64)
+        x = klass(dtype).new(shape)
+        rng.standard_t(x, df: df)
+        x
+      end
+
+      private
+
+      attr_reader :rng
+
+      def klass(dtype) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+        case dtype.to_sym
+        when :int8
+          Numo::Int8
+        when :int16
+          Numo::Int16
+        when :int32
+          Numo::Int32
+        when :int64
+          Numo::Int64
+        when :uint8
+          Numo::UInt8
+        when :uint16
+          Numo::UInt16
+        when :uint32
+          Numo::UInt32
+        when :uint64
+          Numo::UInt64
+        when :float32, :sfloat
+          Numo::SFloat
+        when :float64, :dfloat
+          Numo::DFloat
+        else
+          raise ArgumentError, "wrong dtype is given: #{dtype}"
+        end
+      end
+    end
+  end
+end

data/lib/numo/random/version.rb

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

data/lib/numo/random.rb

@@ -3,182 +3,5 @@
 require 'numo/narray'
 
 require_relative 'random/version'
-require_relative 'random/randomext'
-
-# Ruby/Numo (NUmerical MOdules)
-module Numo
-  # Numo::Random provides random number generation with several distributions for Numo::NArray.
-  module Random
-    # Generator is a class that generates random number with several distributions.
-    #
-    # @example
-    #   require 'numo/random'
-    #
-    #   x = Numo::DFloat.new(100)
-    #
-    #   rng = Numo::Random::Generator.new
-    #   rng.uniform(x, low: -1, high: 2)
-    class Generator
-      # Returns random number generation algorithm.
-      # @return [String]
-      attr_accessor :algorithm
-
-      # 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)
-      end
-
-      # Returns the seed of random number generator.
-      #
-      # @return [Integer]
-      def seed
-        rng.seed
-      end
-
-      # Sets the seed of random number generator.
-      #
-      # @param val [Integer] random seed.
-      def seed=(val)
-        rng.seed = val
-      end
-
-      # Returns random number with uniform distribution in the half-open interval [0, 1).
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   rng = Numo::Random::Generator.new
-      #   v = rng.random
-      #
-      # @return [Float]
-      def random
-        rng.random
-      end
-
-      # Fills given array with uniformly distributed random values in the interval [low, high).
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.uniform(x, low: -1.5, high: 1.5)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param low [Float] lower boundary.
-      # @param high [Float] upper boundary.
-      def uniform(x, low: 0.0, high: 1.0)
-        rng.uniform(x, low: low, high: high)
-      end
-
-      # Fills given array with random values according to the Cauchy (Lorentz) distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.cauchy(x, loc: 0.0, scale: 1.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param loc [Float] location parameter.
-      # @param scale [Float] scale parameter.
-      def cauchy(x, loc: 0.0, scale: 1.0)
-        rng.cauchy(x, loc: loc, scale: scale)
-      end
-
-      # Fills given array with random values according to the Chi-squared distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.chisquare(x, df: 2.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param df [Float] degrees of freedom, must be > 0.
-      def chisquare(x, df:)
-        rng.chisquare(x, df: df)
-      end
-
-      # Fills given array with random values according to the F-distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.f(x, dfnum: 2.0, dfden: 4.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param dfnum [Float] degrees of freedom in numerator, must be > 0.
-      # @param dfden [Float] degrees of freedom in denominator, must be > 0.
-      def f(x, dfnum:, dfden:)
-        rng.f(x, dfnum: dfnum, dfden: dfden)
-      end
-
-      # Fills given array with random values according to a normal (Gaussian) distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.normal(x, loc: 0.0, scale: 1.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param loc [Float] location parameter.
-      # @param scale [Float] scale parameter.
-      def normal(x, loc: 0.0, scale: 1.0)
-        rng.normal(x, loc: loc, scale: scale)
-      end
-
-      # Fills given array with random values according to a log-normal distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.lognormal(x, mean: 0.0, sigma: 1.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param mean [Float] mean of normal distribution.
-      # @param sigma [Float] standard deviation of normal distribution.
-      def lognormal(x, mean: 0.0, sigma: 1.0)
-        rng.lognormal(x, mean: mean, sigma: sigma)
-      end
-
-      # Fills given array with random values according to the Student's t-distribution.
-      #
-      # @example
-      #   require 'numo/random'
-      #
-      #   x = Numo::DFloat.new(100)
-      #
-      #   rng = Numo::Random::Generator.new
-      #   rng.standard_t(x, df: 8.0)
-      #
-      # @param x [Numo::DFloat | Numo::SFloat] array filled with random values.
-      # @param df [Float] degrees of freedom, must be > 0.
-      def standard_t(x, df:)
-        rng.standard_t(x, df: df)
-      end
-
-      private
-
-      attr_reader :rng
-    end
-  end
-end
+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.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-24 00:00:00.000000000 Z
+date: 2022-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -37,14 +37,15 @@ 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
 - ext/numo/random/src/pcg_uint128.hpp
 - lib/numo/random.rb
+- lib/numo/random/generator.rb
 - lib/numo/random/version.rb
 homepage: https://github.com/yoshoku/numo-random
 licenses:
@@ -53,7 +54,7 @@ metadata:
   homepage_uri: https://github.com/yoshoku/numo-random
   source_code_uri: https://github.com/yoshoku/numo-random
   changelog_uri: https://github.com/yoshoku/numo-random/blob/main/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/numo-random
+  documentation_uri: https://yoshoku.github.io/numo-random/doc/
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []