enumerable-statistics 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9bbba060f2298fae081d18782b237d693663558c
-  data.tar.gz: f4b5aa2e3bdaed71938a0bb4fb699f9d04daf3e5
+  metadata.gz: 01d8583f76df44d84e20ab090a5589e44e33dacf
+  data.tar.gz: c070a1c7b007646ee0769b9e4924c0af0914341d
 SHA512:
-  metadata.gz: 6b2cc2848db0d8103e09bf770d565be0fcfe360f6dbb45b18ebbbca48027d0f96ae6488a90f3f0ddf3111a82200e14e3b07509f3f7e6cd5ce2fa115350f34224
-  data.tar.gz: 2fdc7b8b992a2194aabd6aa82af286d93d03772f385ed1927f2c412eaf2667dd9c9472a65b438c9a1a9660012a014bd879ec16e5dc934ac76d9a543a936539cd
+  metadata.gz: 7b3027aea941fa441b21c53ff8570b712cd576b42d97d9b7e3c421c92ad9c79552860a4f1c3bfd86da5c7f654d5396ab23415a0f861a4290ac1971ced29372e4
+  data.tar.gz: d082b4b5c2dd4c91b40400ccbbcd68859e6811bc14add0416133c8a70d67c97b4af10ae4f53fef4fc73efcc139d7f3d224baa5e7b983c4428880bc671039a935

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# 1.0.1
+
+- Add `mean_variance` method in Array class and Enumerable module
+- Add optimized implementation of `mean_variance` method for a Hash
+- Add the following methods, implemented by using `mean_variance`, in Array class and Enumerable module
+    - `mean`
+    - `variance`
+    - `stddev`
+    - `mean_stddev`
+- Add `sum` method in Array class and Enumerable module when Ruby < 2.4, that is almost same as introduced in Ruby 2.4
+- Add optimized implementation of `sum` method for a Range with integer ends and a Hash, that is almost same as introduced in Ruby 2.4
+
+# 1.0.0
+
+- This version was yanked due to documentation issue

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Kenta Murata
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,8 +1,8 @@
 # Enumerable::Statistics
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/enumerable/statistics`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Build Status](https://travis-ci.org/mrkn/enumerable-statistics.svg?branch=master)](https://travis-ci.org/mrkn/enumerable-statistics)
 
-TODO: Delete this and the text above, and describe your gem
+Enumerable::Statistics provides some methods to calculate statistical summary in arrays and enumerables.
 
 ## Installation
 
@@ -22,7 +22,63 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+You should load this library by the following line in your script at first.
+
+```ruby
+require 'enumerable/statistics'
+```
+
+The following methods are supplied by this library:
+
+- `Array#mean`, `Enumerable#mean`
+  - Calculates a mean of values in an array or an enumerable
+- `Array#variance`, `Enumerable#variance`
+  - Calculates a variance of values in an array or an enumerable
+- `Array#stdev`, `Enumerable#stdev`
+  - Calculates a standard deviation of values in an array or an enumerable
+- `Array#mean_variance`, `Enumerable#mean_variance`
+  - Calculates a mean and a variance simultaneously
+- `Array#mean_stdev`, `Enumerable#mean_stdev`
+  - Calculates a mean and a standard deviation simultaneously
+
+Moreover, for Ruby < 2.4, `Array#sum` and `Enumerable#sum` are provided.
+
+All methods scan a collection once to calculate statistics and preserve precision as possible.
+
+## Performance
+
+```
+$ bundle exec rake bench
+# sum
+Warming up --------------------------------------
+              inject     1.545k i/100ms
+               while     2.342k i/100ms
+                 sum    11.009k i/100ms
+Calculating -------------------------------------
+              inject     15.016k (± 9.6%) i/s -     75.705k in   5.098723s
+               while     22.238k (±16.2%) i/s -    107.732k in   5.068156s
+                 sum    112.992k (± 6.9%) i/s -    572.468k in   5.091868s
+# mean
+Warming up --------------------------------------
+              inject     1.578k i/100ms
+               while     2.057k i/100ms
+                mean     9.855k i/100ms
+Calculating -------------------------------------
+              inject     15.347k (± 8.6%) i/s -     77.322k in   5.076009s
+               while     21.669k (±14.5%) i/s -    106.964k in   5.074312s
+                mean    108.861k (± 8.9%) i/s -    542.025k in   5.021786s
+# variance
+Warming up --------------------------------------
+              inject   586.000  i/100ms
+               while   826.000  i/100ms
+            variance     8.475k i/100ms
+Calculating -------------------------------------
+              inject      6.187k (± 6.7%) i/s -     31.058k in   5.043418s
+               while      8.597k (± 7.4%) i/s -     42.952k in   5.024587s
+            variance     84.702k (± 8.5%) i/s -    423.750k in   5.039936s
+```
+
+![](./images/benchmark.png)
 
 ## Development
 
@@ -32,5 +88,5 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/enumerable-statistics.
+Bug reports and pull requests are welcome on GitHub at https://github.com/mrkn/enumerable-statistics.
 

data/Rakefile

@@ -7,3 +7,14 @@ task :default => :spec
 Rake::ExtensionTask.new('enumerable/statistics/extension')
 
 RSpec::Core::RakeTask.new(:spec)
+
+task :bench do
+  puts "# sum\n"
+  system('ruby bench/sum.rb')
+
+  puts "# mean\n"
+  system('ruby bench/mean.rb')
+
+  puts "# variance\n"
+  system('ruby bench/variance.rb')
+end

data/bench/mean.rb

@@ -0,0 +1,27 @@
+require 'enumerable/statistics'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.config(times: 5, warmup: 2)
+
+  n = 1_000
+  ary = Array.new(n) { rand }
+
+  x.report('inject') do
+    mean = ary.inject(:+) / n.to_f
+  end
+
+  x.report('while') do
+    i = 0
+    mean = 0
+    while i < n
+      mean += ary[i]
+      i += 1
+    end
+    mean /= n.to_f
+  end
+
+  x.report('mean') do
+    mean = ary.mean
+  end
+end

data/bench/sum.rb

@@ -0,0 +1,26 @@
+require 'enumerable/statistics'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.config(times: 5, warmup: 2)
+
+  n = 1_000
+  ary = Array.new(n) { rand }
+
+  x.report('inject') do
+    sum = ary.inject(:+)
+  end
+
+  x.report('while') do
+    i = 0
+    sum = 0
+    while i < n
+      sum += ary[i]
+      i += 1
+    end
+  end
+
+  x.report('sum') do
+    sum = ary.sum
+  end
+end

data/bench/variance.rb

@@ -0,0 +1,30 @@
+require 'enumerable/statistics'
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.config(times: 5, warmup: 2)
+
+  n = 1_000
+  ary = Array.new(n) { rand }
+  mean = ary.inject(:+) / n.to_f
+
+  x.report('inject') do
+    var = ary.inject(0.0) { |sum, x|
+      sum += (x - mean) ** 2
+    } / (n - 1).to_f
+  end
+
+  x.report('while') do
+    i = 0
+    var = 0
+    while i < n
+      var += (ary[i] - mean) ** 2
+      i += 1
+    end
+    mean /= (n - 1).to_f
+  end
+
+  x.report('variance') do
+    var = ary.variance
+  end
+end

data/enumerable-statistics.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake-compiler", "~> 0.9.8"
   spec.add_development_dependency "rspec", "~> 3.4"
   spec.add_development_dependency "fuubar"
+  spec.add_development_dependency "benchmark-ips"
 end

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

@@ -5,15 +5,28 @@
 #if RUBY_API_VERSION_CODE >= 20400
 /* for 2.4.0 or higher */
 # define HAVE_ARRAY_SUM
+# define HAVE_ENUM_SUM
 # undef HAVE_RB_FIX_PLUS
 # undef HAVE_RB_RATIONAL_PLUS
 #elif RUBY_API_VERSION_CODE >= 20200
 /* for 2.3.0 and 2.2.0 */
 # undef HAVE_ARRAY_SUM
+# undef HAVE_ENUM_SUM
 # undef HAVE_RB_FIX_PLUS
 # undef HAVE_RB_RATIONAL_PLUS
 #endif
 
+#ifndef RB_INTEGER_TYPE_P
+# define RB_INTEGER_TYPE_P(obj) enum_stat_integer_type_p(obj)
+static inline int
+enum_stat_integer_type_p(VALUE obj)
+{
+    return (FIXNUM_P(obj) ||
+	    (!SPECIAL_CONST_P(obj) &&
+	     BUILTIN_TYPE(obj) == RUBY_T_BIGNUM));
+}
+#endif
+
 #ifndef HAVE_TYPE_STRUCT_RRATIONAL
 struct RRational {
     struct RBasic basic;
@@ -67,8 +80,14 @@ struct RComplex {
 # define MUL_OVERFLOW_LONG_P(a, b) MUL_OVERFLOW_SIGNED_INTEGER_P(a, b, LONG_MIN, LONG_MAX)
 #endif
 
-static ID idPow, idPLUS, idMINUS, idSTAR, id_eqeq_p, id_idiv, id_negate, id_to_f, id_cmp;
-static ID id_each, id_real_p;
+#define SET_MEAN(v) do { if (mean_ptr) *mean_ptr = (v); } while (0)
+#define SET_VARIANCE(v) do { if (variance_ptr) *variance_ptr = (v); } while (0)
+
+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;
+static ID id_each, id_real_p, id_sum, id_population;
 
 inline static VALUE
 f_add(VALUE x, VALUE y)
@@ -99,7 +118,6 @@ f_real_p(VALUE x)
     return rb_funcall(x, id_real_p, 0);
 }
 
-#ifndef HAVE_RB_FIX_PLUS
 static VALUE
 complex_new(VALUE klass, VALUE real, VALUE imag)
 {
@@ -156,6 +174,7 @@ complex_add(VALUE self, VALUE other)
   return rb_num_coerce_bin(self, other, idPLUS);
 }
 
+#ifndef HAVE_RB_FIX_PLUS
 static VALUE
 rb_fix_plus(VALUE x, VALUE y)
 {
@@ -185,6 +204,170 @@ rb_fix_plus(VALUE x, VALUE y)
 }
 #endif
 
+#ifndef HAVE_RB_INT_PLUS
+static VALUE
+rb_int_plus(VALUE x, VALUE y)
+{
+  if (FIXNUM_P(x)) {
+    return rb_fix_plus(x, y);
+  }
+  else if (RB_TYPE_P(x, T_BIGNUM)) {
+    return rb_big_plus(x, y);
+  }
+  return rb_num_coerce_bin(x, y, '+');
+}
+#endif
+
+#ifndef HAVE_RB_FIX_MINUS
+static VALUE
+rb_fix_minus(VALUE x, VALUE y)
+{
+  if (FIXNUM_P(y)) {
+    long a, b, c;
+    VALUE r;
+
+    a = FIX2LONG(x);
+    b = FIX2LONG(y);
+    c = a - b;
+    r = LONG2NUM(c);
+
+    return r;
+  }
+  else if (RB_TYPE_P(y, T_BIGNUM)) {
+    x = rb_int2big(FIX2LONG(x));
+    return rb_big_minus(x, y);
+  }
+  else if (RB_TYPE_P(y, T_FLOAT)) {
+    return DBL2NUM((double)FIX2LONG(x) - RFLOAT_VALUE(y));
+  }
+  else {
+    return rb_num_coerce_bin(x, y, '-');
+  }
+}
+#endif
+
+#ifndef HAVE_RB_INT_MINUS
+VALUE
+rb_int_minus(VALUE x, VALUE y)
+{
+  if (FIXNUM_P(x)) {
+    return rb_fix_minus(x, y);
+  }
+  else if (RB_TYPE_P(x, T_BIGNUM)) {
+    return rb_big_minus(x, y);
+  }
+  return rb_num_coerce_bin(x, y, '-');
+}
+#endif
+
+#ifndef HAVE_RB_INTEGER_FLOAT_CMP
+static VALUE
+rb_integer_float_cmp(VALUE x, VALUE y)
+{
+  double yd = RFLOAT_VALUE(y);
+  double yi, yf;
+  VALUE rel;
+
+  if (isnan(yd))
+    return Qnil;
+  if (isinf(yd)) {
+    if (yd > 0.0) return INT2FIX(-1);
+    else return INT2FIX(1);
+  }
+  yf = modf(yd, &yi);
+  if (FIXNUM_P(x)) {
+#if SIZEOF_LONG * CHAR_BIT < DBL_MANT_DIG /* assume FLT_RADIX == 2 */
+    double xd = (double)FIX2LONG(x);
+    if (xd < yd)
+      return INT2FIX(-1);
+    if (xd > yd)
+      return INT2FIX(1);
+    return INT2FIX(0);
+#else
+    long xn, yn;
+    if (yi < FIXNUM_MIN)
+      return INT2FIX(1);
+    if (FIXNUM_MAX+1 <= yi)
+      return INT2FIX(-1);
+    xn = FIX2LONG(x);
+    yn = (long)yi;
+    if (xn < yn)
+      return INT2FIX(-1);
+    if (xn > yn)
+      return INT2FIX(1);
+    if (yf < 0.0)
+      return INT2FIX(1);
+    if (0.0 < yf)
+      return INT2FIX(-1);
+    return INT2FIX(0);
+#endif
+  }
+  y = rb_dbl2big(yi);
+  rel = rb_big_cmp(x, y);
+  if (yf == 0.0 || rel != INT2FIX(0))
+    return rel;
+  if (yf < 0.0)
+    return INT2FIX(1);
+  return INT2FIX(-1);
+}
+#endif
+
+static VALUE
+fix_ge(VALUE x, VALUE y)
+{
+  if (FIXNUM_P(y)) {
+    if (FIX2LONG(x) >= FIX2LONG(y)) return Qtrue;
+    return Qfalse;
+  }
+  else if (RB_TYPE_P(y, T_BIGNUM)) {
+    return rb_big_cmp(y, x) != INT2FIX(+1) ? Qtrue : Qfalse;
+  }
+  else if (RB_TYPE_P(y, T_FLOAT)) {
+    VALUE rel = rb_integer_float_cmp(x, y);
+    return rel == INT2FIX(1) || rel == INT2FIX(0) ? Qtrue : Qfalse;
+  }
+  else {
+    return rb_num_coerce_relop(x, y, idGE);
+  }
+}
+
+#ifndef HAVE_RB_BIG_GE
+static VALUE
+rb_big_ge(VALUE x, VALUE y)
+{
+  VALUE rel;
+  int n;
+
+  if (RB_INTEGER_TYPE_P(y)) {
+    rel = rb_big_cmp(x, y);
+  }
+  else if (RB_FLOAT_TYPE_P(y)) {
+    rel = rb_integer_float_cmp(x, y);
+  }
+  else {
+    return rb_num_coerce_relop(x, y, idGE);
+  }
+
+  if (NIL_P(rel)) return Qfalse;
+  n = FIX2INT(rel);
+  return n >= 0 ? Qtrue : Qfalse;
+}
+#endif
+
+#ifndef HAVE_RB_INT_GE
+static VALUE
+rb_int_ge(VALUE x, VALUE y)
+{
+  if (FIXNUM_P(x)) {
+    return fix_ge(x, y);
+  }
+  else if (RB_TYPE_P(x, T_BIGNUM)) {
+    return rb_big_ge(x, y);
+  }
+  return Qnil;
+}
+#endif
+
 #ifndef HAVE_RB_RATIONAL_PLUS
 # define ZERO INT2FIX(0)
 # define ONE  INT2FIX(1)
@@ -459,7 +642,18 @@ rb_rational_plus(VALUE self, VALUE other)
 }
 #endif
 
-#ifndef HAVE_ARRAY_SUM
+/* 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)
 {
@@ -558,7 +752,196 @@ not_exact:
 
   return v;
 }
+
+static void
+calculate_and_set_mean(VALUE *mean_ptr, VALUE sum, long const n)
+{
+  if (RB_TYPE_P(sum, T_COMPLEX)) {
+    VALUE real_mean, imag_mean;
+    VALUE const real = RCOMPLEX(sum)->real;
+    VALUE const imag = RCOMPLEX(sum)->imag;
+
+    if (RB_FLOAT_TYPE_P(real))
+      real_mean = DBL2NUM(RFLOAT_VALUE(real) / n);
+    else
+      real_mean = rb_funcall(real, idDIV, 1, DBL2NUM(n));
+
+    if (RB_FLOAT_TYPE_P(imag))
+      imag_mean = DBL2NUM(RFLOAT_VALUE(imag) / n);
+    else
+      imag_mean = rb_funcall(imag, idDIV, 1, DBL2NUM(n));
+
+    SET_MEAN(complex_new(CLASS_OF(sum), real_mean, imag_mean));
+  }
+  else if (RB_FLOAT_TYPE_P(sum)) {
+    SET_MEAN(DBL2NUM(RFLOAT_VALUE(sum) / n));
+  }
+  else
+    SET_MEAN(rb_funcall(sum, idDIV, 1, DBL2NUM(n)));
+}
+
+static void
+ary_mean_variance(VALUE ary, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
+{
+  long i;
+  size_t n = 0;
+  double m = 0.0, m2 = 0.0, f = 0.0, c = 0.0;
+
+  SET_MEAN(DBL2NUM(0));
+  SET_VARIANCE(DBL2NUM(NAN));
+
+  if (RARRAY_LEN(ary) == 0)
+    return;
+  else if (RARRAY_LEN(ary) == 1) {
+    VALUE e = RARRAY_AREF(ary, 0);
+    if (rb_block_given_p())
+      e = rb_yield(e);
+    if (RB_TYPE_P(e, T_COMPLEX))
+      SET_MEAN(e);
+    else {
+      e = rb_Float(e);
+      SET_MEAN(e);
+    }
+    return;
+  }
+
+  if (variance_ptr == NULL) {
+    VALUE init = DBL2NUM(0.0);
+    VALUE const sum = ary_sum(1, &init, ary);
+    long const n = RARRAY_LEN(ary);
+    calculate_and_set_mean(mean_ptr, sum, n);
+    return;
+  }
+
+  for (i = 0; i < RARRAY_LEN(ary); ++i) {
+    double x, delta, y, t;
+    VALUE e;
+
+    n += 1;
+
+    e = RARRAY_AREF(ary, i);
+    if (rb_block_given_p())
+      e = rb_yield(e);
+
+    if (RB_FLOAT_TYPE_P(e))
+      x = RFLOAT_VALUE(e);
+    else if (FIXNUM_P(e))
+      x = FIX2LONG(e);
+    else if (RB_TYPE_P(e, T_BIGNUM))
+      x = rb_big2dbl(e);
+    else
+      x = rb_num2dbl(e);
+
+    y = x - c;
+    t = f + y;
+    c = (t - f) - y;
+    f = t;
+
+    delta = x - m;
+    m += delta / n;
+    m2 += delta * (x - m);
+  }
+
+  SET_MEAN(DBL2NUM(f / n));
+  if (n >= 2) {
+    assert(n > ddof);
+    SET_VARIANCE(DBL2NUM(m2 / (n - ddof)));
+  }
+}
+
+static int
+opt_population_p(VALUE opts)
+{
+  ID kwargs = id_population;
+  VALUE population = Qfalse;
+
+  if (!NIL_P(opts)) {
+#ifdef HAVE_RB_GET_KWARGS
+    rb_get_kwargs(opts, &kwargs, 0, 1, &population);
+#else
+    VALUE val = rb_hash_aref(opts, ID2SYM(id_population));
+    population = NIL_P(val) ? population : val;
 #endif
+  }
+
+  return RTEST(population);
+}
+
+/* call-seq:
+ *    eary.mean_variance(population: 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.
+ *
+ * When the `population:` keyword parameter is `true`,
+ * the variance is calculated as a population variance (divided by $n$).
+ * The default `population:` keyword parameter is `false`;
+ * this means the variance is a sample variance (divided by $n-1$).
+ *
+ * This method scan values in `ary` only once,
+ * and does not cache the values on memory.
+ *
+ * @return (mean, variance) Two element array consists of mean and variance values
+ */
+static VALUE
+ary_mean_variance_m(int argc, VALUE* argv, VALUE ary)
+{
+  VALUE opts, mean, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  ary_mean_variance(ary, &mean, &variance, ddof);
+  return rb_assoc_new(mean, variance);
+}
+
+/* call-seq:
+ *    ary.mean
+ *
+ * Calculate a mean 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 `enum` includes Float values.
+ *
+ * @return [Number] A mean value
+ */
+static VALUE
+ary_mean(VALUE ary)
+{
+  VALUE mean;
+  ary_mean_variance(ary, &mean, NULL, 1);
+  return mean;
+}
+
+/* call-seq:
+ *    ary.variance(population: false)
+ *
+ * Calculate a variance of the values in `ary`.
+ * This method scan values in `ary` only once,
+ * and does not cache the values on memory.
+ *
+ * When the `population:` keyword parameter is `true`,
+ * the variance is calculated as a population variance (divided by $n$).
+ * The default `population:` keyword parameter is `false`;
+ * this means the variance is a sample variance (divided by $n-1$).
+ *
+ * @return [Number] A variance value
+ */
+static VALUE
+ary_variance(int argc, VALUE* argv, VALUE ary)
+{
+  VALUE opts, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  ary_mean_variance(ary, NULL, &variance, ddof);
+  return variance;
+}
 
 #define ENUM_WANT_SVALUE() do { \
   e = rb_enum_values_pack(argc, argv); \
@@ -566,27 +949,28 @@ not_exact:
 
 struct enum_sum_memo {
   VALUE v, r;
-  long n;
+  long n, count;
   double f, c;
   int block_given;
   int float_value;
 };
 
-static VALUE
-enum_sum_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(e, args))
+static void
+sum_iter(VALUE e, struct enum_sum_memo *memo)
 {
-  struct enum_sum_memo *memo = (struct enum_sum_memo *)args;
+  int const unused = (assert(memo != NULL), 0);
+
   long n = memo->n;
   VALUE v = memo->v;
   VALUE r = memo->r;
   double f = memo->f;
   double c = memo->c;
 
-  ENUM_WANT_SVALUE();
-
   if (memo->block_given)
     e = rb_yield(e);
 
+  memo->count += 1;
+
   if (memo->float_value)
     goto float_value;
 
@@ -659,20 +1043,72 @@ enum_sum_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(e, args))
   memo->r = r;
   memo->f = f;
   memo->c = c;
+  (void)unused;
+}
 
+static VALUE
+enum_sum_i(RB_BLOCK_CALL_FUNC_ARGLIST(e, args))
+{
+  ENUM_WANT_SVALUE();
+  sum_iter(e, (struct enum_sum_memo *) args);
   return Qnil;
 }
 
-static VALUE
-enum_stat_sum(int argc, VALUE* argv, VALUE obj)
+static int
+hash_sum_i(VALUE key, VALUE value, VALUE arg)
 {
-  struct enum_sum_memo memo;
+  sum_iter(rb_assoc_new(key, value), (struct enum_sum_memo *) arg);
+  return ST_CONTINUE;
+}
+
+static void
+hash_sum(VALUE hash, struct enum_sum_memo *memo)
+{
+  assert(RB_TYPE_P(hash, T_HASH));
+  assert(memo != NULL);
 
-  if (rb_scan_args(argc, argv, "01", &memo.v) == 0)
-    memo.v = LONG2FIX(0);
+  rb_hash_foreach(hash, hash_sum_i, (VALUE)memo);
+}
 
-  memo.block_given = rb_block_given_p();
+static void
+int_range_sum_count(VALUE beg, VALUE end, int excl,
+                    VALUE init, VALUE *sum_ptr, long *count_ptr)
+{
+  if (excl) {
+    if (FIXNUM_P(end))
+      end = LONG2FIX(FIX2LONG(end) - 1);
+    else
+      end = rb_big_minus(end, LONG2FIX(1));
+  }
+
+  if (rb_int_ge(end, beg)) {
+    VALUE a;
+    a = rb_int_plus(rb_int_minus(end, beg), LONG2FIX(1));
+    a = f_mul(a, rb_int_plus(end, beg));
+    a = f_idiv(a, LONG2FIX(2));
+    if (sum_ptr)
+      *sum_ptr = rb_int_plus(init, a);
+    if (count_ptr)
+      *count_ptr = a;
+    return;
+  }
 
+  if (sum_ptr)
+    *sum_ptr = init;
+  if (count_ptr)
+    *count_ptr = 0;
+}
+
+static void
+enum_sum_count(VALUE obj, VALUE init, VALUE *sum_ptr, long *count_ptr)
+{
+  struct enum_sum_memo memo;
+  VALUE beg, end;
+  int excl;
+
+  memo.count = 0;
+  memo.v = init;
+  memo.block_given = rb_block_given_p();
   memo.n = 0;
   memo.r = Qundef;
 
@@ -681,80 +1117,407 @@ enum_stat_sum(int argc, VALUE* argv, VALUE obj)
     memo.c = 0.0;
   }
 
-  rb_block_call(obj, id_each, 0, 0, enum_sum_iter_i, (VALUE)&memo);
+  if (RTEST(rb_range_values(obj, &beg, &end, &excl))) {
+    if (!rb_block_given_p() && !memo.float_value &&
+        RB_INTEGER_TYPE_P(beg) && RB_INTEGER_TYPE_P(end)) {
+      int_range_sum_count(beg, end, excl, memo.v, sum_ptr, count_ptr);
+      return;
+    }
+  }
+
+  if (RB_TYPE_P(obj, T_HASH) &&
+      rb_method_basic_definition_p(CLASS_OF(obj), id_each))
+    hash_sum(obj, &memo);
+  else
+    rb_block_call(obj, id_each, 0, 0, enum_sum_i, (VALUE)&memo);
 
   if (memo.float_value) {
-    return DBL2NUM(memo.f);
+    if (sum_ptr)
+      *sum_ptr = DBL2NUM(memo.f);
   }
   else {
     if (memo.n != 0)
       memo.v = rb_fix_plus(LONG2FIX(memo.n), memo.v);
     if (memo.r != Qundef)
       memo.v = rb_rational_plus(memo.r, memo.v);
-    return memo.v;
+    if (sum_ptr)
+      *sum_ptr = memo.v;
   }
+
+  if (count_ptr)
+    *count_ptr = memo.count;
 }
 
+/* call-seq:
+ *    enum.sum
+ *
+ * Calculate the sum of the values in `enum`.
+ * This method utilizes
+ * [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
+ * to compensate the result precision when the `enum` includes Float values.
+ *
+ * Note that This library does not redefine `sum` method introduced in Ruby 2.4.
+ *
+ * @return [Number] A summation value
+ */
 static VALUE
-enum_stat_mean_variance(VALUE obj)
+enum_sum(int argc, VALUE* argv, VALUE obj)
 {
-  return rb_assoc_new(INT2FIX(0), INT2FIX(0));
+  VALUE sum, init;
+
+  if (rb_scan_args(argc, argv, "01", &init) == 0)
+    init = LONG2FIX(0);
+
+  enum_sum_count(obj, init, &sum, NULL);
+
+  return sum;
+}
+
+struct enum_mean_variance_memo {
+  int block_given;
+  long n;
+  double m, m2, f, c;
+};
+
+static void
+mean_variance_iter(VALUE e, struct enum_mean_variance_memo *memo)
+{
+  int const unused = (assert(memo != NULL), 0);
+
+  double x, delta, y, t;
+
+  long n = memo->n;
+  double m = memo->m;
+  double m2 = memo->m2;
+  double f = memo->f;
+  double c = memo->c;
+
+  if (memo->block_given)
+    e = rb_yield(e);
+
+  n += 1;
+
+  if (RB_FLOAT_TYPE_P(e))
+    x = RFLOAT_VALUE(e);
+  else if (FIXNUM_P(e))
+    x = FIX2LONG(e);
+  else if (RB_TYPE_P(e, T_BIGNUM))
+    x = rb_big2dbl(e);
+  else {
+    x = rb_num2dbl(e);
+  }
+
+  y = x - c;
+  t = f + y;
+  c = (t - f) - y;
+  f = t;
+
+  delta = x - m;
+  m += delta / n;
+  m2 += delta * (x - m);
+
+  memo->n = n;
+  memo->m = m;
+  memo->m2 = m2;
+  memo->f = f;
+  memo->c = c;
+  (void)unused;
 }
 
 static VALUE
-enum_stat_mean(VALUE obj)
+enum_mean_variance_iter_i(RB_BLOCK_CALL_FUNC_ARGLIST(e, args))
+{
+  struct enum_mean_variance_memo *memo = (struct enum_mean_variance_memo *)args;
+  ENUM_WANT_SVALUE();
+  mean_variance_iter(e, (struct enum_sum_memo *) args);
+  return Qnil;
+}
+
+static int
+hash_mean_variance_i(VALUE key, VALUE value, VALUE arg)
 {
-  VALUE ary = enum_stat_mean_variance(obj);
-  return RARRAY_AREF(ary, 0);
+  mean_variance_iter(rb_assoc_new(key, value), (struct enum_mean_variance_memo *) arg);
+  return ST_CONTINUE;
+}
+
+static void
+hash_mean_variance(VALUE hash, struct enum_mean_variance_memo *memo)
+{
+  assert(RB_TYPE_P(hash, T_HASH));
+  assert(memo != NULL);
+
+  rb_hash_foreach(hash, hash_mean_variance_i, (VALUE)memo);
+}
+
+static void
+enum_mean_variance(VALUE obj, VALUE *mean_ptr, VALUE *variance_ptr, size_t ddof)
+{
+  struct enum_mean_variance_memo memo;
+
+  SET_MEAN(DBL2NUM(0));
+  SET_VARIANCE(DBL2NUM(NAN));
+
+  if (variance_ptr == NULL) {
+    long n;
+    VALUE sum;
+    VALUE init = DBL2NUM(0.0);
+    enum_sum_count(obj, init, &sum, &n);
+    if (n > 0)
+      calculate_and_set_mean(mean_ptr, sum, n);
+    return;
+  }
+
+  memo.block_given = rb_block_given_p();
+  memo.n = 0;
+  memo.m = 0.0;
+  memo.m2 = 0.0;
+  memo.f = 0.0;
+  memo.c = 0.0;
+
+  if (RB_TYPE_P(obj, T_HASH) &&
+      rb_method_basic_definition_p(CLASS_OF(obj), id_each))
+    hash_mean_variance(obj, &memo);
+  else
+    rb_block_call(obj, id_each, 0, 0, enum_mean_variance_iter_i, (VALUE)&memo);
+
+  if (memo.n == 0)
+    return;
+  else if (memo.n == 1)
+    SET_MEAN(DBL2NUM(memo.f));
+  else {
+    SET_MEAN(DBL2NUM(memo.f / memo.n));
+
+    assert(memo.n > ddof);
+    SET_VARIANCE(DBL2NUM(memo.m2 / (double)(memo.n - ddof)));
+  }
 }
 
+/* call-seq:
+ *    enum.mean_variance(population: false)
+ *
+ * Calculate a mean and a variance of the values in `enum`.
+ * The first element of the result array is the mean, and the second is the variance.
+ *
+ * When the `population:` keyword parameter is `true`,
+ * the variance is calculated as a population variance (divided by $n$).
+ * The default `population:` keyword parameter is `false`;
+ * this means the variance is a sample variance (divided by $n-1$).
+ *
+ * This method scan values in `enum` only once,
+ * and does not cache the values on memory.
+ *
+ * @return (mean, variance) Two element array consists of mean and variance values
+ */
 static VALUE
-enum_stat_variance(VALUE obj)
+enum_mean_variance_m(int argc, VALUE* argv, VALUE obj)
 {
-  VALUE ary = enum_stat_mean_variance(obj);
-  return RARRAY_AREF(ary, 1);
+  VALUE opts, mean, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  enum_mean_variance(obj, &mean, &variance, ddof);
+  return rb_assoc_new(mean, variance);
 }
 
+/* call-seq:
+ *    enum.mean
+ *
+ * Calculate a mean of the values in `enum`.
+ * This method utilizes
+ * [Kahan summation algorithm](https://en.wikipedia.org/wiki/Kahan_summation_algorithm)
+ * to compensate the result precision when the `enum` includes Float values.
+ *
+ * @return [Number] A mean value
+ */
 static VALUE
-enum_stat_mean_stddev(VALUE obj)
+enum_mean(VALUE obj)
 {
-  VALUE ary = enum_stat_mean_variance(obj);
-  VALUE var = RARRAY_AREF(ary, 1);
-  VALUE stddev = rb_funcall(var, idPow, 1, DBL2NUM(0.5));
-  RARRAY_ASET(ary, 1, stddev);
-  return ary;
+  VALUE mean;
+  enum_mean_variance(obj, &mean, NULL, 1);
+  return mean;
 }
 
+/* call-seq:
+ *    enum.variance(population: false)
+ *
+ * Calculate a variance of the values in `enum`.
+ * This method scan values in `enum` only once,
+ * and does not cache the values on memory.
+ *
+ * When the `population:` keyword parameter is `true`,
+ * the variance is calculated as a population variance (divided by $n$).
+ * The default `population:` keyword parameter is `false`;
+ * this means the variance is a sample variance (divided by $n-1$).
+ *
+ * @return [Number] A variance value
+ */
 static VALUE
-enum_stat_stddev(VALUE obj)
+enum_variance(int argc, VALUE* argv, VALUE obj)
 {
-  VALUE ary = enum_stat_mean_stddev(obj);
-  return RARRAY_AREF(ary, 1);
+  VALUE opts, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  enum_mean_variance(obj, NULL, &variance, ddof);
+  return variance;
+}
+
+static VALUE
+sqrt_value(VALUE x)
+{
+  if (RB_INTEGER_TYPE_P(x) || RB_FLOAT_TYPE_P(x) || RB_TYPE_P(x, T_RATIONAL)) {
+    double f = NUM2DBL(x);
+    return DBL2NUM(sqrt(f));
+  }
+
+  return rb_funcall(x, idPow, 1, half_in_rational);
+}
+
+/* call-seq:
+ *    enum.mean_stdev(population: false)
+ *
+ * Calculate a mean and a standard deviation of the values in `enum`.
+ * The first element of the result array is the mean,
+ * and the second is the standard deviation.
+ *
+ * This method is equivalent to:
+ *
+ * ```ruby
+ * def mean_stdev(population: false)
+ *   m, v = mean_variance(population: population)
+ *   [m, Math.sqrt(v)]
+ * end
+ * ```
+ *
+ * @return (mean, stdev)
+ */
+static VALUE
+enum_mean_stdev(int argc, VALUE* argv, VALUE obj)
+{
+  VALUE opts, mean, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  enum_mean_variance(obj, &mean, &variance, ddof);
+  VALUE stdev = sqrt_value(variance);
+  return rb_assoc_new(mean, stdev);
+}
+
+/* call-seq:
+ *    enum.stdev(population: false)
+ *
+ * Calculate a standard deviation of the values in `enum`.
+ *
+ * This method is equivalent to:
+ *
+ * ```ruby
+ * Math.sqrt(enum.variance(population: population))
+ * ```
+ *
+ * @return [Number] A standard deviation value
+ */
+static VALUE
+enum_stdev(int argc, VALUE* argv, VALUE obj)
+{
+  VALUE variance = enum_variance(argc, argv, obj);
+  VALUE stdev = sqrt_value(variance);
+  return stdev;
+}
+
+/* call-seq:
+ *    ary.mean_stdev(population: false)
+ *
+ * Calculate a mean and a standard deviation of the values in `ary`.
+ * The first element of the result array is the mean,
+ * and the second is the standard deviation.
+ *
+ * This method is equivalent to:
+ *
+ * ```ruby
+ * def mean_stdev(population: false)
+ *   m, v = mean_variance(population: population)
+ *   [m, Math.sqrt(v)]
+ * end
+ * ```
+ *
+ * @return (mean, stdev)
+ */
+static VALUE
+ary_mean_stdev(int argc, VALUE* argv, VALUE ary)
+{
+  VALUE opts, mean, variance;
+  size_t ddof = 1;
+
+  rb_scan_args(argc, argv, "0:", &opts);
+  if (opt_population_p(opts))
+    ddof = 0;
+
+  ary_mean_variance(ary, &mean, &variance, ddof);
+  VALUE stdev = sqrt_value(variance);
+  return rb_assoc_new(mean, stdev);
+}
+
+/* call-seq:
+ *    ary.stdev(population: false)
+ *
+ * Calculate a standard deviation of the values in `ary`.
+ *
+ * This method is equivalent to:
+ *
+ * ```ruby
+ * Math.sqrt(ary.variance(population: population))
+ * ```
+ *
+ * @return [Number] A standard deviation value
+ */
+static VALUE
+ary_stdev(int argc, VALUE* argv, VALUE ary)
+{
+  VALUE variance = ary_variance(argc, argv, ary);
+  VALUE stdev = sqrt_value(variance);
+  return stdev;
 }
 
 void
 Init_extension(void)
 {
-  rb_define_method(rb_mEnumerable, "sum", enum_stat_sum, -1);
-
-#if 0
-  rb_define_method(rb_mEnumerable, "mean_variance", enum_stat_mean_variance, 0);
-  rb_define_method(rb_mEnumerable, "mean", enum_stat_mean, 0);
-  rb_define_alias(rb_mEnumerable, "average", "mean");
-  rb_define_method(rb_mEnumerable, "variance", enum_stat_variance, 0);
-  rb_define_alias(rb_mEnumerable, "var", "variance");
-  rb_define_method(rb_mEnumerable, "mean_stddev", enum_stat_mean_stddev, 0);
-  rb_define_method(rb_mEnumerable, "stddev", enum_stat_stddev, 0);
+#ifndef HAVE_ENUM_SUM
+  rb_define_method(rb_mEnumerable, "sum", enum_sum, -1);
 #endif
 
+  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);
+  rb_define_method(rb_mEnumerable, "mean_stdev", enum_mean_stdev, -1);
+  rb_define_method(rb_mEnumerable, "stdev", enum_stdev, -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, "variance", ary_variance, -1);
+  rb_define_method(rb_cArray, "mean_stdev", ary_mean_stdev, -1);
+  rb_define_method(rb_cArray, "stdev", ary_stdev, -1);
+
+  half_in_rational = nurat_s_new_internal(rb_cRational, INT2FIX(1), INT2FIX(2));
+  rb_gc_register_mark_object(half_in_rational);
 
   idPLUS = '+';
   idMINUS = '-';
   idSTAR = '*';
+  idDIV = '/';
   idPow = rb_intern("**");
+  idGE = rb_intern(">=");
   id_eqeq_p = rb_intern("==");
   id_idiv = rb_intern("div");
   id_negate = rb_intern("-@");
@@ -762,4 +1525,6 @@ Init_extension(void)
   id_cmp = rb_intern("<=>");
   id_each = rb_intern("each");
   id_real_p = rb_intern("real?");
+  id_sum = rb_intern("sum");
+  id_population = rb_intern("population");
 }