enumerable-statistics 2.0.1 → 2.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e593e551f4f9b857a009db71093abab619e96680c4d15fc0eaa3a96c6e622bd4
-  data.tar.gz: eb449c789843e7e3e2c435890b8a9281d49cb6cdaad4ebbfc979b959413f617f
+  metadata.gz: 815b5f1b539e61935a709b7f859aeae73dd379959d8aa5e56551b650d20c7abc
+  data.tar.gz: be09795e4203a023e23a20b99c2bdd051ace5292ea7c67d6000cda0c3ed7c822
 SHA512:
-  metadata.gz: 8866ba9d47c0715b82ffe7370b1fe8f683e1c1a17fd2dfee50db06c536cfa25b469bbf94a0f23c24ce2179c9d81203b761f8d17beadf113752b4f89490a48a2f
-  data.tar.gz: 942e4dacc202cef906e631c38d9450045f9712ffed811b35f7f28fafeecc0e92f70196b0d8d8053423266d60210a1f556ed600d4c2c2b0ee5320aa97830cab47
+  metadata.gz: 3b2af05ed047b86529af90b7c18091d04055b1ded985614a6e4c7422706bd1453bb993a3b84e4b2821c8ff725efc62edb09505e1f3e59865faa71921296cd45d
+  data.tar.gz: 97d2f6044a4ebb1a1ca4d068f999192c3255bf8213262c6d038007404be79ca36cc6eaeefab0830e0aa45a658d4e083024ad3a116040ee75e9acbda31984b69a

data/.github/workflows/ci.yml

@@ -0,0 +1,64 @@
+name: CI
+
+on:
+- push
+
+jobs:
+  cruby:
+    name: Test
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+        - ubuntu-latest
+        - macos-latest
+        - windows-latest
+        ruby:
+        - 3.3
+        - 3.2
+        - 3.1
+        - 3.0
+        - 2.7
+        - 2.6
+        - 2.5
+        - 2.4
+        - debug
+        exclude:
+        - os: macos-latest
+          ruby: 2.5
+        - os: macos-latest
+          ruby: 2.4
+        - os: windows-latest
+          ruby: debug
+
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Setup Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+
+    - name: Detect installable bundler version
+      run: |
+        case "${{ matrix.ruby }}" in
+          2.7|2.6) bundler_version="2.4.22" ;;
+          2.5|2.4) bundler_version="2.3.27" ;;
+          *)       bundler_version="" ;;
+        esac
+        echo "bundler_version=$bundler_version" >> $GITHUB_ENV
+      shell: bash
+
+    - run: gem install bundler${bundler_version:+ -v $bundler_version}
+      shell: bash
+
+    - run: bundle install
+
+    - run: rake --trace compile
+
+    - run: rake build
+    - run: gem install pkg/*gem
+
+    - run: rake

data/CHANGELOG.md

@@ -1,3 +1,35 @@
+# 2.0.8
+
+- Prohibit the use of both `nbins` and `edges` kwargs simultaneously in the `histogram` method.
+- Support `skip_na` kwarg in `sum` and related methods.
+- Support Ruby 3.4+.
+
+# 2.0.7
+
+- Fix the bug of histogram with bin range that is smaller than value range
+
+# 2.0.6
+
+- Add edges parameter in histogram
+- Rename parameter in histogram to fix typo: `weight` to `weights`
+
+# 2.0.5
+
+- Add weighted histogram support
+
+# 2.0.4
+
+- Add `find_min`, `find_max`, `argmin`, `argmax` methods
+- Fix `nbin=:auto` case in `histogram` method
+
+# 2.0.3
+
+- Ractor-safe version
+
+# 2.0.2
+
+- Support Ruby 3.0
+
 # 2.0.1
 
 - Fix a bug of `histogram` (#9)

data/Rakefile

@@ -8,7 +8,14 @@ Rake::ExtensionTask.new('enumerable/statistics/extension')
 
 directory 'lib/enumerable/statistics'
 
+desc "Run test"
+task :test do
+  ruby("test/run-test.rb")
+end
+task :test => :compile
+
 RSpec::Core::RakeTask.new(:spec)
+task :spec => :compile
 
 task :bench do
   puts "# sum\n"
@@ -20,3 +27,5 @@ task :bench do
   puts "# variance\n"
   system('benchmark-driver bench/variance.yml')
 end
+
+task default: [:test, :spec]

data/enumerable-statistics.gemspec

@@ -27,10 +27,11 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.4'
 
-  spec.add_development_dependency "bundler", ">= 1.17.2"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rake-compiler", ">= 0.9.8"
   spec.add_development_dependency "rspec", ">= 3.4"
+  spec.add_development_dependency "test-unit"
   spec.add_development_dependency "fuubar"
   spec.add_development_dependency "yard"
   spec.add_development_dependency "benchmark-driver"

data/ext/enumerable/statistics/extension/array_ext.c

@@ -0,0 +1,60 @@
+#include <ruby/ruby.h>
+
+static VALUE
+ary_find_max(VALUE ary)
+{
+  const long n = RARRAY_LEN(ary);
+  if (n == 0) {
+    return Qnil;
+  }
+
+  long imax = 0;
+  VALUE max = RARRAY_AREF(ary, imax);
+
+  long i;
+  for (i = 1; i < n; ++i) {
+    VALUE v = RARRAY_AREF(ary, i);
+    if (RTEST(rb_funcall(v, '>', 1, max))) {
+      imax = i;
+      max = v;
+    }
+  }
+
+  return rb_assoc_new(max, LONG2NUM(imax));
+}
+
+static VALUE
+ary_find_min(VALUE ary)
+{
+  const long n = RARRAY_LEN(ary);
+  if (n == 0) {
+    return Qnil;
+  }
+
+  long imin = 0;
+  VALUE min = RARRAY_AREF(ary, imin);
+
+  long i;
+  for (i = 1; i < n; ++i) {
+    VALUE v = RARRAY_AREF(ary, i);
+    if (RTEST(rb_funcall(v, '<', 1, min))) {
+      imin = i;
+      min = v;
+    }
+  }
+
+  return rb_assoc_new(min, LONG2NUM(imin));
+}
+
+void
+Init_array_extension(void)
+{
+  VALUE mEnumerableStatistics = rb_const_get_at(rb_cObject, rb_intern("EnumerableStatistics"));
+  VALUE mArrayExtension = rb_const_get_at(mEnumerableStatistics, rb_intern("ArrayExtension"));
+
+  rb_undef_method(mArrayExtension, "find_max");
+  rb_define_method(mArrayExtension, "find_max", ary_find_max, 0);
+
+  rb_undef_method(mArrayExtension, "find_min");
+  rb_define_method(mArrayExtension, "find_min", ary_find_min, 0);
+}

data/ext/enumerable/statistics/extension/statistics.c

@@ -44,7 +44,7 @@ struct RRational {
 #endif
 
 #ifndef RRATIONAL
-# define RRATIONAL(obj) (R_CAST(RRational)(obj))
+# define RRATIONAL(obj) ((struct RRational *)(obj))
 #endif
 
 #ifndef RRATIONAL_SET_NUM
@@ -64,7 +64,7 @@ struct RComplex {
 #endif
 
 #ifndef RCOMPLEX
-# define RCOMPLEX(obj) (R_CAST(RComplex)(obj))
+# define RCOMPLEX(obj) ((struct RComplex *)(obj))
 #endif
 
 #ifndef RCOMPLEX_SET_REAL
@@ -96,11 +96,14 @@ static VALUE half_in_rational;
 static ID idPow, idPLUS, idMINUS, idSTAR, idDIV, idGE;
 static ID id_eqeq_p, id_idiv, id_negate, id_to_f, id_cmp, id_nan_p;
 static ID id_each, id_real_p, id_sum, id_population, id_closed, id_edge;
+static ID id_skip_na;
 
-static VALUE sym_left, sym_right;
+static VALUE sym_auto, sym_left, sym_right, sym_sturges;
 
 static VALUE cHistogram;
 
+static VALUE orig_enum_sum, orig_ary_sum;
+
 inline static VALUE
 f_add(VALUE x, VALUE y)
 {
@@ -135,7 +138,7 @@ complex_new(VALUE klass, VALUE real, VALUE imag)
 {
   assert(!RB_TYPE_P(real, T_COMPLEX));
 
-  NEWOBJ_OF(obj, struct RComplex, klass, T_COMPLEX | (RGENGC_WB_PROTECTED_COMPLEX ? FL_WB_PROTECTED : 0));
+  VALUE obj = rb_get_alloc_func(klass)(klass);
 
   RCOMPLEX_SET_REAL(obj, real);
   RCOMPLEX_SET_IMAG(obj, imag);
@@ -535,9 +538,11 @@ f_gcd(VALUE x, VALUE y)
 inline static VALUE
 nurat_s_new_internal(VALUE klass, VALUE num, VALUE den)
 {
-  NEWOBJ_OF(obj, struct RRational, klass, T_RATIONAL | (RGENGC_WB_PROTECTED_RATIONAL ? FL_WB_PROTECTED : 0));
+  VALUE obj = rb_get_alloc_func(klass)(klass);
+
   RRATIONAL_SET_NUM(obj, num);
   RRATIONAL_SET_DEN(obj, den);
+
   return (VALUE)obj;
 }
 
@@ -632,39 +637,67 @@ rb_rational_plus(VALUE self, VALUE other)
 }
 #endif
 
-/* call-seq:
- *    ary.sum
- *
- * Calculate the sum of the values in `ary`.
- * This method utilizes
- * [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
- * to compensate the result precision when the `ary` includes Float values.
- *
- * Note that This library does not redefine `sum` method introduced in Ruby 2.4.
- *
- * @return [Number] A summation value
- */
-static VALUE
-ary_sum(int argc, VALUE* argv, VALUE ary)
+static inline int
+is_na(VALUE v)
+{
+  if (NIL_P(v))
+    return 1;
+
+  if (RB_FLOAT_TYPE_P(v) && isnan(RFLOAT_VALUE(v)))
+    return 1;
+
+  if (rb_respond_to(v, id_nan_p) && RTEST(rb_funcall(v, id_nan_p, 0)))
+    return 1;
+
+  return 0;
+}
+
+static int opt_skip_na(VALUE opts)
+{
+  VALUE skip_na = Qfalse;
+
+  if (!NIL_P(opts)) {
+#ifdef HAVE_RB_GET_KWARGS
+    ID kwargs = id_skip_na;
+    rb_get_kwargs(opts, &kwargs, 0, 1, &skip_na);
+#else
+    VALUE val = rb_hash_aref(opts, ID2SYM(id_skip_na));
+    skip_na = NIL_P(val) ? skip_na : val;
+#endif
+  }
+
+  return RTEST(skip_na);
+}
+
+VALUE
+ary_calculate_sum(VALUE ary, VALUE init, int skip_na, long *na_count_out)
 {
   VALUE e, v, r;
   long i, n;
   int block_given;
-
-  if (rb_scan_args(argc, argv, "01", &v) == 0)
-    v = LONG2FIX(0);
+  long na_count = 0;
 
   block_given = rb_block_given_p();
 
-  if (RARRAY_LEN(ary) == 0)
-    return v;
+  if (RARRAY_LEN(ary) == 0) {
+    if (na_count_out != NULL) {
+      *na_count_out = 0;
+    }
+    return init;
+  }
 
   n = 0;
   r = Qundef;
+  v = init;
   for (i = 0; i < RARRAY_LEN(ary); i++) {
     e = RARRAY_AREF(ary, i);
     if (block_given)
       e = rb_yield(e);
+    if (skip_na && is_na(e)) {
+      ++na_count;
+      continue;
+    }
+
     if (FIXNUM_P(e)) {
       n += FIX2LONG(e); /* should not overflow long type */
       if (!FIXABLE(n)) {
@@ -688,7 +721,7 @@ ary_sum(int argc, VALUE* argv, VALUE ary)
     v = rb_fix_plus(LONG2FIX(n), v);
   if (r != Qundef)
     v = rb_rational_plus(r, v);
-  return v;
+  goto finish;
 
 not_exact:
   if (n != 0)
@@ -708,6 +741,11 @@ not_exact:
       e = RARRAY_AREF(ary, i);
       if (block_given)
         e = rb_yield(e);
+      if (skip_na && is_na(e)) {
+        ++na_count;
+        continue;
+      }
+
       if (RB_FLOAT_TYPE_P(e))
         has_float_value:
           x = RFLOAT_VALUE(e);
@@ -725,7 +763,9 @@ not_exact:
       c = (t - f) - y;
       f = t;
     }
-    return DBL2NUM(f);
+
+    v = DBL2NUM(f);
+    goto finish;
 
   not_float:
     v = DBL2NUM(f);
@@ -736,13 +776,53 @@ not_exact:
     e = RARRAY_AREF(ary, i);
     if (block_given)
       e = rb_yield(e);
+    if (skip_na && is_na(e)) {
+      ++na_count;
+      continue;
+    }
   has_some_value:
     v = rb_funcall(v, idPLUS, 1, e);
   }
 
+finish:
+  if (na_count_out != NULL) {
+    *na_count_out = na_count;
+  }
   return v;
 }
 
+/* call-seq:
+ *    ary.sum(skip_na: false)
+ *
+ * Calculate the sum of the values in `ary`.
+ * This method utilizes
+ * [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
+ * to compensate the result precision when the `ary` includes Float values.
+ *
+ * Note that This library does not redefine `sum` method introduced in Ruby 2.4.
+ *
+ * @return [Number] A summation value
+ */
+static VALUE
+ary_sum(int argc, VALUE* argv, VALUE ary)
+{
+  VALUE v, opts;
+  int skip_na;
+
+  if (rb_scan_args(argc, argv, "01:", &v, &opts) == 0) {
+    v = LONG2FIX(0);
+  }
+  skip_na = opt_skip_na(opts);
+
+#ifndef HAVE_ENUM_SUM
+  if (!skip_na) {
+    return rb_funcall(orig_ary_sum, rb_intern("call"), argc, &v);
+  }
+#endif
+
+  return ary_calculate_sum(ary, v, skip_na, NULL);
+}
+
 static void
 calculate_and_set_mean(VALUE *mean_ptr, VALUE sum, long const n)
 {
@@ -771,9 +851,10 @@ calculate_and_set_mean(VALUE *mean_ptr, VALUE sum, long const n)
 }
 
 static void
-ary_mean_variance(VALUE ary, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
+ary_mean_variance(VALUE ary, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof, int skip_na)
 {
   long i;
+  long na_count;
   size_t n = 0;
   double m = 0.0, m2 = 0.0, f = 0.0, c = 0.0;
 
@@ -797,8 +878,8 @@ ary_mean_variance(VALUE ary, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
 
   if (variance_ptr == NULL) {
     VALUE init = DBL2NUM(0.0);
-    VALUE const sum = ary_sum(1, &init, ary);
-    long const n = RARRAY_LEN(ary);
+    VALUE const sum = ary_calculate_sum(ary, init, skip_na, &na_count);
+    long const n = RARRAY_LEN(ary) - na_count;
     calculate_and_set_mean(mean_ptr, sum, n);
     return;
   }
@@ -839,26 +920,46 @@ ary_mean_variance(VALUE ary, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
   }
 }
 
-static int
-opt_population_p(VALUE opts)
+struct variance_opts {
+  int population;
+  int skip_na;
+};
+
+static void
+get_variance_opts(VALUE opts, struct variance_opts *out)
 {
-  VALUE population = Qfalse;
+  assert(out != NULL);
+
+  out->population = 0;
+  out->skip_na = 0;
 
   if (!NIL_P(opts)) {
 #ifdef HAVE_RB_GET_KWARGS
-    ID kwargs = id_population;
-    rb_get_kwargs(opts, &kwargs, 0, 1, &population);
+    static ID kwarg_keys[2];
+    VALUE kwarg_vals;
+
+    if (!kwarg_keys[0]) {
+      kwarg_keys[0] = id_population;
+      kwarg_keys[1] = id_skip_na;
+    }
+
+    rb_get_kwargs(opts, &kwarg_keys, 0, 2, kwarg_vals);
+    out->population = (kwarg_vals[0] != Qundef) ? RTEST(kwarg_vals[0]) : out->population;
+    out->skip_na = (kwarg_vals[1] != Qundef) ? RTEST(kwarg_vals[1]) : out->skip_na;
 #else
-    VALUE val = rb_hash_aref(opts, ID2SYM(id_population));
-    population = NIL_P(val) ? population : val;
+    VALUE val;
+
+    val = rb_hash_aref(opts, ID2SYM(id_population));
+    out->population = NIL_P(val) ? out->population : RTEST(val);
+
+    val = rb_hash_aref(opts, ID2SYM(id_skip_na));
+    out->skip_na = NIL_P(val) ? out->skip_na : RTEST(val);
 #endif
   }
-
-  return RTEST(population);
 }
 
 /* call-seq:
- *    ary.mean_variance(population: false)
+ *    ary.mean_variance(population: false, skip_na: false)
  *
  * Calculate a mean and a variance of the values in `ary`.
  * The first element of the result array is the mean, and the second is the variance.
@@ -876,19 +977,21 @@ opt_population_p(VALUE opts)
 static VALUE
 ary_mean_variance_m(int argc, VALUE* argv, VALUE ary)
 {
-  VALUE opts, mean, variance;
+  struct variance_opts options;
+  VALUE opts, mean = Qnil, variance = Qnil;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
-  ary_mean_variance(ary, &mean, &variance, ddof);
+  ary_mean_variance(ary, &mean, &variance, ddof, options.skip_na);
   return rb_assoc_new(mean, variance);
 }
 
 /* call-seq:
- *    ary.mean
+ *    ary.mean(skip_na: false)
  *
  * Calculate a mean of the values in `ary`.
  * This method utilizes
@@ -898,15 +1001,20 @@ ary_mean_variance_m(int argc, VALUE* argv, VALUE ary)
  * @return [Number] A mean value
  */
 static VALUE
-ary_mean(VALUE ary)
+ary_mean(int argc, VALUE *argv, VALUE ary)
 {
-  VALUE mean;
-  ary_mean_variance(ary, &mean, NULL, 1);
+  VALUE mean = Qnil, opts;
+  int skip_na;
+
+  rb_scan_args(argc, argv, ":", &opts);
+  skip_na = opt_skip_na(opts);
+
+  ary_mean_variance(ary, &mean, NULL, 1, skip_na);
   return mean;
 }
 
 /* call-seq:
- *    ary.variance(population: false)
+ *    ary.variance(population: false, skip_na: false)
  *
  * Calculate a variance of the values in `ary`.
  * This method scan values in `ary` only once,
@@ -922,14 +1030,16 @@ ary_mean(VALUE ary)
 static VALUE
 ary_variance(int argc, VALUE* argv, VALUE ary)
 {
+  struct variance_opts options;
   VALUE opts, variance;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
-  ary_mean_variance(ary, NULL, &variance, ddof);
+  ary_mean_variance(ary, NULL, &variance, ddof, options.skip_na);
   return variance;
 }
 
@@ -943,6 +1053,7 @@ struct enum_sum_memo {
   double f, c;
   int block_given;
   int float_value;
+  int skip_na;
 };
 
 static void
@@ -956,8 +1067,12 @@ sum_iter(VALUE e, struct enum_sum_memo *memo)
   double f = memo->f;
   double c = memo->c;
 
-  if (memo->block_given)
+  if (memo->block_given) {
     e = rb_yield(e);
+  }
+  if (memo->skip_na && is_na(e)) {
+    return;
+  }
 
   memo->count += 1;
 
@@ -1090,7 +1205,7 @@ int_range_sum_count(VALUE beg, VALUE end, int excl,
 }
 
 static void
-enum_sum_count(VALUE obj, VALUE init, VALUE *sum_ptr, long *count_ptr)
+enum_sum_count(VALUE obj, VALUE init, int skip_na, VALUE *sum_ptr, long *count_ptr)
 {
   struct enum_sum_memo memo;
   VALUE beg, end;
@@ -1101,6 +1216,7 @@ enum_sum_count(VALUE obj, VALUE init, VALUE *sum_ptr, long *count_ptr)
   memo.block_given = rb_block_given_p();
   memo.n = 0;
   memo.r = Qundef;
+  memo.skip_na = skip_na;
 
   if ((memo.float_value = RB_FLOAT_TYPE_P(memo.v))) {
     memo.f = RFLOAT_VALUE(memo.v);
@@ -1138,9 +1254,8 @@ enum_sum_count(VALUE obj, VALUE init, VALUE *sum_ptr, long *count_ptr)
     *count_ptr = memo.count;
 }
 
-#ifndef HAVE_ENUM_SUM
 /* call-seq:
- *    enum.sum
+ *    enum.sum(skip_na: false)
  *
  * Calculate the sum of the values in `enum`.
  * This method utilizes
@@ -1154,16 +1269,27 @@ enum_sum_count(VALUE obj, VALUE init, VALUE *sum_ptr, long *count_ptr)
 static VALUE
 enum_sum(int argc, VALUE* argv, VALUE obj)
 {
-  VALUE sum, init;
+  VALUE sum, init, opts;
+  int skip_na;
 
-  if (rb_scan_args(argc, argv, "01", &init) == 0)
+  if (rb_scan_args(argc, argv, "01:", &init, &opts) == 0) {
     init = LONG2FIX(0);
+  }
+  skip_na = opt_skip_na(opts);
 
-  enum_sum_count(obj, init, &sum, NULL);
+#ifndef HAVE_ENUM_SUM
+  if (skip_na) {
+    enum_sum_count(obj, init, skip_na, &sum, NULL);
+  }
+  else {
+    rb_funcall(orig_enum_sum, rb_intern("call"), argc, &init);
+  }
+#else
+  enum_sum_count(obj, init, skip_na, &sum, NULL);
+#endif
 
   return sum;
 }
-#endif
 
 struct enum_mean_variance_memo {
   int block_given;
@@ -1253,7 +1379,7 @@ enum_mean_variance(VALUE obj, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
     long n;
     VALUE sum;
     VALUE init = DBL2NUM(0.0);
-    enum_sum_count(obj, init, &sum, &n);
+    enum_sum_count(obj, init, 0, &sum, &n); /* TODO: skip_na */
     if (n > 0)
       calculate_and_set_mean(mean_ptr, sum, n);
     return;
@@ -1303,11 +1429,13 @@ enum_mean_variance(VALUE obj, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
 static VALUE
 enum_mean_variance_m(int argc, VALUE* argv, VALUE obj)
 {
+  struct variance_opts options;
   VALUE opts, mean, variance;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
   enum_mean_variance(obj, &mean, &variance, ddof);
@@ -1349,11 +1477,13 @@ enum_mean(VALUE obj)
 static VALUE
 enum_variance(int argc, VALUE* argv, VALUE obj)
 {
+  struct variance_opts options;
   VALUE opts, variance;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
   enum_mean_variance(obj, NULL, &variance, ddof);
@@ -1392,11 +1522,13 @@ sqrt_value(VALUE x)
 static VALUE
 enum_mean_stdev(int argc, VALUE* argv, VALUE obj)
 {
+  struct variance_opts options;
   VALUE opts, mean, variance;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
   enum_mean_variance(obj, &mean, &variance, ddof);
@@ -1446,14 +1578,16 @@ enum_stdev(int argc, VALUE* argv, VALUE obj)
 static VALUE
 ary_mean_stdev(int argc, VALUE* argv, VALUE ary)
 {
+  struct variance_opts options;
   VALUE opts, mean, variance;
   size_t ddof = 1;
 
   rb_scan_args(argc, argv, "0:", &opts);
-  if (opt_population_p(opts))
+  get_variance_opts(opts, &options);
+  if (options.population)
     ddof = 0;
 
-  ary_mean_variance(ary, &mean, &variance, ddof);
+  ary_mean_variance(ary, &mean, &variance, ddof, options.skip_na);
   VALUE stdev = sqrt_value(variance);
   return rb_assoc_new(mean, stdev);
 }
@@ -1479,21 +1613,6 @@ ary_stdev(int argc, VALUE* argv, VALUE ary)
   return stdev;
 }
 
-static inline int
-is_na(VALUE v)
-{
-  if (NIL_P(v))
-    return 1;
-
-  if (RB_FLOAT_TYPE_P(v) && isnan(RFLOAT_VALUE(v)))
-    return 1;
-
-  if (rb_respond_to(v, id_nan_p) && RTEST(rb_funcall(v, id_nan_p, 0)))
-    return 1;
-
-  return 0;
-}
-
 static int
 ary_percentile_sort_cmp(const void *ap, const void *bp, void *dummy)
 {
@@ -1900,7 +2019,7 @@ any_value_counts(int argc, VALUE *argv, VALUE obj,
   struct value_counts_opts opts;
   struct value_counts_memo memo;
 
-  rb_scan_args(argc, argv, ":", &kwargs);
+  rb_scan_args(argc, argv, "0:", &kwargs);
   value_counts_extract_opts(kwargs, &opts);
 
   memo.result = rb_hash_new();
@@ -2102,50 +2221,67 @@ histogram_edge_bin_index(VALUE edge, VALUE rb_x, int left_p)
 }
 
 static void
-histogram_weights_push_values(VALUE weights, VALUE edge, VALUE values, int left_p)
+histogram_weights_push_values(VALUE bin_weights, VALUE edge, VALUE values, VALUE weight_array, int left_p)
 {
+  const VALUE one = INT2FIX(1);
+  long bi, i, n, n_bins, weighted = 0;
   VALUE x, cur;
-  long i, n, bi;
+
+  assert(RB_TYPE_P(edge, T_ARRAY));
+  assert(RB_TYPE_P(values, T_ARRAY));
 
   n = RARRAY_LEN(values);
+  n_bins = RARRAY_LEN(edge) - 1;
+
+  if (! NIL_P(weight_array)) {
+    assert(RB_TYPE_P(weight_array, T_ARRAY));
+    assert(RARRAY_LEN(weight_array) == n);
+    weighted = 1;
+  }
+
   for (i = 0; i < n; ++i) {
     x = RARRAY_AREF(values, i);
 
-    bi = histogram_edge_bin_index(edge, x, left_p);
-
-    cur = rb_ary_entry(weights, bi);
-    if (NIL_P(cur)) {
-      cur = INT2FIX(1);
+    VALUE w;
+    if (weighted) {
+      w = RARRAY_AREF(weight_array, i);
+      if (RB_TYPE_P(w, T_COMPLEX)) {
+        VALUE imag = RCOMPLEX(w)->imag;
+        if (! RTEST(f_zero_p(imag))) {
+          goto type_error;
+        }
+      }
+      else if (rb_obj_is_kind_of(w, rb_cNumeric)) {
+        if (!RTEST(f_real_p(w))) {
+          goto type_error;
+        }
+      }
+      else {
+        goto type_error;
+      }
     }
     else {
-      cur = rb_funcall(cur, idPLUS, 1, INT2FIX(1));
+      w = one;
     }
 
-    rb_ary_store(weights, bi, cur);
-  }
-}
+    bi = histogram_edge_bin_index(edge, x, left_p);
 
-static int
-opt_closed_left_p(VALUE opts)
-{
-  int left_p = 1;
+    if (0 <= bi && bi < n_bins) {
+      cur = rb_ary_entry(bin_weights, bi);
+      if (NIL_P(cur)) {
+        cur = w;
+      }
+      else {
+        cur = rb_funcall(cur, idPLUS, 1, w);
+      }
 
-  if (!NIL_P(opts)) {
-    VALUE closed;
-#ifdef HAVE_RB_GET_KWARGS
-    ID kwargs = id_closed;
-    rb_get_kwargs(opts, &kwargs, 0, 1, &closed);
-#else
-    closed = rb_hash_lookup2(opts, ID2SYM(id_closed), sym_left);
-#endif
-    left_p = (closed != sym_right);
-    if (left_p && closed != sym_left) {
-      rb_raise(rb_eArgError, "invalid value for :closed keyword "
-               "(%"PRIsVALUE" for :left or :right)", closed);
+      rb_ary_store(bin_weights, bi, cur);
     }
   }
+  return;
 
-  return left_p;
+type_error:
+      rb_raise(rb_eTypeError, "weight array must have only real numbers");
 }
 
 static inline long
@@ -2238,9 +2374,9 @@ ary_histogram_calculate_edge_lo_hi(const double lo, const double hi, const long
 }
 
 static VALUE
-ary_histogram_calculate_edge(VALUE ary, const long nbins, const int left_p)
+ary_histogram_calculate_edge(VALUE ary, VALUE arg0, const int left_p)
 {
-  long n;
+  long n, nbins;
   VALUE minmax;
   VALUE edge = Qnil;
   double lo, hi;
@@ -2248,6 +2384,22 @@ ary_histogram_calculate_edge(VALUE ary, const long nbins, const int left_p)
   Check_Type(ary, T_ARRAY);
   n = RARRAY_LEN(ary);
 
+  if (NIL_P(arg0)) {
+    arg0 = sym_auto;
+  }
+
+  if (RB_TYPE_P(arg0, T_SYMBOL)) {
+    if (arg0 != sym_auto && arg0 != sym_sturges) {
+      rb_raise(rb_eArgError, "Unknown method to calculate bin width: %+"PRIsVALUE, arg0);
+    }
+    else {
+      nbins = sturges(n);
+    }
+  }
+  else {
+    nbins = NUM2LONG(arg0);
+  }
+
   if (n == 0 && nbins < 0) {
     rb_raise(rb_eArgError, "nbins must be >= 0 for an empty array, got %ld", nbins);
   }
@@ -2269,10 +2421,47 @@ ary_histogram_calculate_edge(VALUE ary, const long nbins, const int left_p)
   return edge;
 }
 
+static VALUE
+check_histogram_weight_array(VALUE weight_array, const long ary_len)
+{
+  if (weight_array == Qundef) return Qnil;
+
+  weight_array = rb_check_convert_type(weight_array, T_ARRAY, "Array", "to_ary");
+  if (RARRAY_LEN(weight_array) != ary_len) {
+    rb_raise(rb_eArgError, "weight array must have the same number of items as the receiver array");
+  }
+
+  return weight_array;
+}
+
+static VALUE
+check_histogram_edges(VALUE edges)
+{
+  if (edges == Qundef) return Qnil;
+  return rb_check_convert_type(edges, T_ARRAY, "Array", "to_ary");
+}
+
+static int
+check_histogram_left_p(VALUE closed)
+{
+  int left_p = (closed != sym_right);
+  if (left_p && closed != Qundef && closed != sym_left) {
+    rb_raise(rb_eArgError, "invalid value for :closed keyword "
+        "(%"PRIsVALUE" for :left or :right)", closed);
+  }
+  return left_p;
+}
+
 /* call-seq:
- *    ary.histogram(nbins=:auto, closed: :left)
+ *    ary.histogram(nbins=:auto, weight: nil, closed: :left)
  *
  * @param [Integer] nbins  The approximate number of bins
+ * @params [Array<Numeric>] weights
+ *   An optional weight array, that has the same length as the receiver.
+ *   `weight[i]` means the weight value of the i-th element in the receiver.
+ * @params [Array<Numeric>] edges
+ *   An optional edge array, that specify the bin edges.
+ *   This array must be sorted.
  * @param [:left, :right] closed
  *   If :left (the default), the bin interval are left-closed.
  *   If :right, the bin interval are right-closed.
@@ -2282,30 +2471,49 @@ ary_histogram_calculate_edge(VALUE ary, const long nbins, const int left_p)
 static VALUE
 ary_histogram(int argc, VALUE *argv, VALUE ary)
 {
-  VALUE arg0, opts, edge, weights;
-  int left_p;
-  long nbins, nweights, i;
+  VALUE arg0, kwargs, bin_weights;
+  long n_bin_weights, i;
 
-  rb_scan_args(argc, argv, "01:", &arg0, &opts);
-  if (NIL_P(arg0)) {
-    nbins = sturges(RARRAY_LEN(ary));
-  }
-  else {
-    nbins = NUM2LONG(arg0);
+  VALUE weight_array = Qnil;
+  VALUE edges = Qnil;
+  int left_p = 1;
+
+  rb_scan_args(argc, argv, "01:", &arg0, &kwargs);
+
+  if (!NIL_P(kwargs)) {
+    enum { kw_weights, kw_edges, kw_closed };
+    static ID kwarg_keys[3];
+    VALUE kwarg_vals[3];
+
+    if (!kwarg_keys[0]) {
+      kwarg_keys[kw_weights] = rb_intern("weights");
+      kwarg_keys[kw_edges]  = rb_intern("edges");
+      kwarg_keys[kw_closed] = rb_intern("closed");
+    }
+
+    rb_get_kwargs(kwargs, kwarg_keys, 0, 3, kwarg_vals);
+
+    weight_array = check_histogram_weight_array(kwarg_vals[kw_weights], RARRAY_LEN(ary));
+    edges = check_histogram_edges(kwarg_vals[kw_edges]);
+    left_p = check_histogram_left_p(kwarg_vals[kw_closed]);
   }
-  left_p = opt_closed_left_p(opts);
 
-  edge = ary_histogram_calculate_edge(ary, nbins, left_p);
+  if (NIL_P(edges)) {
+    edges = ary_histogram_calculate_edge(ary, arg0, left_p);
+  }
+  else if (! NIL_P(arg0)) {
+    rb_raise(rb_eArgError, "Unable to use both `nbins` and `edges` together");
+  }
 
-  nweights = RARRAY_LEN(edge) - 1;
-  weights = rb_ary_new_capa(nweights);
-  for (i = 0; i < nweights; ++i) {
-    rb_ary_store(weights, i, INT2FIX(0));
+  n_bin_weights = RARRAY_LEN(edges) - 1;
+  bin_weights = rb_ary_new_capa(n_bin_weights);
+  for (i = 0; i < n_bin_weights; ++i) {
+    rb_ary_store(bin_weights, i, INT2FIX(0));
   }
 
-  histogram_weights_push_values(weights, edge, ary, left_p);
+  histogram_weights_push_values(bin_weights, edges, ary, weight_array, left_p);
 
-  return rb_struct_new(cHistogram, edge, weights,
+  return rb_struct_new(cHistogram, edges, bin_weights,
                        left_p ? sym_left : sym_right,
                        Qfalse);
 }
@@ -2315,10 +2523,16 @@ Init_extension(void)
 {
   VALUE mEnumerableStatistics;
 
-#ifndef HAVE_ENUM_SUM
-  rb_define_method(rb_mEnumerable, "sum", enum_sum, -1);
+#ifdef HAVE_RB_EXT_RACTOR_SAFE
+  rb_ext_ractor_safe(true);
 #endif
 
+  mEnumerableStatistics = rb_const_get_at(rb_cObject, rb_intern("EnumerableStatistics"));
+
+  orig_enum_sum = rb_funcall(rb_mEnumerable, rb_intern("public_instance_method"), 1, rb_str_new_cstr("sum"));
+  orig_ary_sum = rb_funcall(rb_cArray, rb_intern("public_instance_method"), 1, rb_str_new_cstr("sum"));
+
+  rb_define_method(rb_mEnumerable, "sum", enum_sum, -1);
   rb_define_method(rb_mEnumerable, "mean_variance", enum_mean_variance_m, -1);
   rb_define_method(rb_mEnumerable, "mean", enum_mean, 0);
   rb_define_method(rb_mEnumerable, "variance", enum_variance, -1);
@@ -2326,11 +2540,9 @@ Init_extension(void)
   rb_define_method(rb_mEnumerable, "stdev", enum_stdev, -1);
   rb_define_method(rb_mEnumerable, "value_counts", enum_value_counts, -1);
 
-#ifndef HAVE_ARRAY_SUM
   rb_define_method(rb_cArray, "sum", ary_sum, -1);
-#endif
   rb_define_method(rb_cArray, "mean_variance", ary_mean_variance_m, -1);
-  rb_define_method(rb_cArray, "mean", ary_mean, 0);
+  rb_define_method(rb_cArray, "mean", ary_mean, -1);
   rb_define_method(rb_cArray, "variance", ary_variance, -1);
   rb_define_method(rb_cArray, "mean_stdev", ary_mean_stdev, -1);
   rb_define_method(rb_cArray, "stdev", ary_stdev, -1);
@@ -2343,11 +2555,13 @@ Init_extension(void)
   half_in_rational = nurat_s_new_internal(rb_cRational, INT2FIX(1), INT2FIX(2));
   rb_gc_register_mark_object(half_in_rational);
 
-  mEnumerableStatistics = rb_const_get_at(rb_cObject, rb_intern("EnumerableStatistics"));
   cHistogram = rb_const_get_at(mEnumerableStatistics, rb_intern("Histogram"));
 
   rb_define_method(rb_cArray, "histogram", ary_histogram, -1);
 
+  void Init_array_extension(void);
+  Init_array_extension();
+
   idPLUS = '+';
   idMINUS = '-';
   idSTAR = '*';
@@ -2366,7 +2580,9 @@ Init_extension(void)
   id_population = rb_intern("population");
   id_closed = rb_intern("closed");
   id_edge = rb_intern("edge");
+  id_skip_na = rb_intern("skip_na");
 
+  sym_auto = ID2SYM(rb_intern("auto"));
   sym_left = ID2SYM(rb_intern("left"));
   sym_right = ID2SYM(rb_intern("right"));
 }

data/lib/enumerable_statistics/array_ext.rb

@@ -0,0 +1,37 @@
+module EnumerableStatistics
+  module ArrayExtension
+    def find_max
+      n = size
+      return nil if n == 0
+
+      imax, i = 0, 1
+      while i < n
+        imax = i if self[i] > self[imax]
+        i += 1
+      end
+      [self[imax], imax]
+    end
+
+    def argmax
+      find_max[1]
+    end
+
+    def find_min
+      n = size
+      return nil if n == 0
+
+      imin, i = 0, 1
+      while i < n
+        imin = i if self[i] < self[imax]
+        i += 1
+      end
+      [self[imin], imin]
+    end
+
+    def argmin
+      find_min[1]
+    end
+  end
+
+  Array.include ArrayExtension
+end

data/lib/enumerable_statistics/histogram.rb

@@ -1,5 +1,6 @@
 module EnumerableStatistics
-  class Histogram < Struct.new(:edge, :weights, :closed, :isdensity)
+  class Histogram < Struct.new(:edges, :weights, :closed, :isdensity)
+    alias edge edges
     alias density? isdensity
   end
 end

data/lib/enumerable_statistics/version.rb

@@ -1,5 +1,5 @@
 module EnumerableStatistics
-  VERSION = '2.0.1'
+  VERSION = '2.0.8'
 
   module Version
     numbers, TAG = VERSION.split('-', 2)

data/lib/enumerable_statistics.rb

@@ -1,2 +1,3 @@
 require_relative "enumerable_statistics/version"
+require_relative "enumerable_statistics/array_ext"
 require_relative "enumerable_statistics/histogram"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enumerable-statistics
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.8
 platform: ruby
 authors:
 - Kenta Murata
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-11 00:00:00.000000000 Z
+date: 2024-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.17.2
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.17.2
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
@@ -114,12 +128,11 @@ email:
 executables: []
 extensions:
 - ext/enumerable/statistics/extension/extconf.rb
-- ext/-bench-/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
-- ".travis.yml"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
@@ -136,12 +149,13 @@ files:
 - bin/rspec
 - bin/setup
 - enumerable-statistics.gemspec
-- ext/-bench-/extconf.rb
+- ext/enumerable/statistics/extension/array_ext.c
 - ext/enumerable/statistics/extension/extconf.rb
 - ext/enumerable/statistics/extension/statistics.c
 - images/benchmark.png
 - lib/enumerable/statistics.rb
 - lib/enumerable_statistics.rb
+- lib/enumerable_statistics/array_ext.rb
 - lib/enumerable_statistics/histogram.rb
 - lib/enumerable_statistics/version.rb
 - templates/default/layout/html/headers.erb
@@ -275,7 +289,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
 summary: Statistics features for Enumerable

data/.travis.yml

@@ -1,32 +0,0 @@
----
-notification:
-  email:
-  - mrkn@ruby-lang.org
-
-language: ruby
-
-before_install:
-  - yes | gem update --system
-  - gem install bundler
-
-install:
-  - bundle install
-
-script:
-  - bundle exec rake --trace clobber compile
-  - bundle exec rake spec
-
-matrix:
-  include:
-    - name: "2.3"
-      rvm: 2.3
-    - name: "2.4"
-      rvm: 2.4.5
-    - name: "2.5"
-      rvm: 2.5.2
-    - name: "2.6"
-      rvm: 2.6
-    - name: "trunk"
-      rvm: ruby-head
-  allow_failures:
-    - rvm: 2.3

data/ext/-bench-/extconf.rb

@@ -1,3 +0,0 @@
-require 'mkmf'
-
-create_makefile('-bench-')