cheap-stats 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0e5a30b7e09b21f08359019f9a4a33bb8bc8b4e1e103bea1eed739f12de818f0
+  data.tar.gz: dc3146cd65e34779373ffe61b5f32c90ac1cfb89218e5fefd81804bf6d40ac59
+SHA512:
+  metadata.gz: 5860b61e54bc57a8ade4724d4f5e5ac62811079b75869177e774c0eb281341fa0a2c7ee7f41f59fbb409355b4a2e5757ccf14a7179d6912d0919d240928759fe
+  data.tar.gz: a9b091cfcb393b1236dd5eca02eaf2d5742c51ce0ea94da38827171c6752c0a6140856c50679b97d363eceabffbdd2876ffb5795aa99c0e365ffe81ad7f85ffd

data/.gitignore

@@ -0,0 +1,50 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in cheap-stats.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Hiroshi Kuwagata
+
+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

@@ -0,0 +1,35 @@
+# cheap-stats
+A cheap statistics library for Ruby
+
+## Installation
+
+```ruby
+gem 'cheap-stats'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cheap-stats
+
+## Examplw
+
+```ruby
+require 'chaep_stats'
+
+SAMPLES = [7.0, 4.0, 1.0, 5.0, 3.0, 10.0, 6.0, 2.0, 8.0, 9.0]
+
+stats = CheapStats.new(SMAPLES)
+
+p stats.mean
+p stats.std
+p stats.skewness
+
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/cheap-stats.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cheap_stats/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cheap-stats"
+  spec.version       = CheapStats::VERSION
+  spec.authors       = ["Hiroshi Kuwagata"]
+  spec.email         = ["kgt9221@gmail.com"]
+
+  spec.summary       = %q{A cheaper statistics library.}
+  spec.description   = %q{A cheaper statistics library.}
+  spec.homepage      = "https://github.com/kwgt/cheap-stats"
+  spec.license       = "MIT"
+
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f|
+      f.match(%r{^(test|spec|features)/})
+    }
+  end
+
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.extensions    = ["ext/cheap_stats/extconf.rb"]
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.4.0"
+
+  spec.add_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+end

data/ext/cheap_stats/cheap_stats.c

@@ -0,0 +1,605 @@
+/*
+ * Small statics library
+ *
+ *  Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "cheap_stats.h"
+
+#define DEFAULT_ERROR         __LINE__
+#define MIN_SAMPLES           10
+
+#define ALLOC(t)              ((t*)malloc(sizeof(t)))
+#define NALLOC(t,n)           ((t*)malloc(sizeof(t) * (n)))
+#define FREE(var)             do {free(var);var = NULL;} while (0)
+#define SHRINK(n)             ((n * 10) / 13)
+#define SWAP(a,b)             do {double t; t = b; b = a; a = t;} while(0)
+
+static void
+combsort11(double* a, size_t n)
+{
+  int h;
+  int f;
+  int i;
+
+  /*
+   * sort by ascending order
+   */
+
+  h = n;
+
+  while (h > 1 || f) {
+    f = 0;
+    h = SHRINK(h);
+
+    if (h == 9 || h == 10) h = 11;
+
+    for (i = 0; i < ((int)n - h); i++) {
+      if (a[i] > a[i + h]) {
+        SWAP(a[i], a[i + h]);
+        f = !0;
+      }
+    }
+  }
+}
+
+static int
+binsearch(double* a, size_t n, double v)
+{
+  int l;
+  int r;
+  int ret;
+
+  l = 0;
+  r = n - 1;
+
+  while (1) {
+    ret = (l + r) / 2;
+
+    if (r <= l) break;
+
+    if (a[ret] < v) {
+      l = ret + 1;
+      continue;
+    } 
+    
+    if (a[ret] > v) {
+      r = ret - 1;
+      continue;
+    }
+
+    break;
+  }
+
+  return ret;
+}
+
+static double
+calc_sum(double* a, size_t n)
+{
+  int i;
+  double s;
+
+  s = 0;
+
+  for (i = 0; i < (int)n; i++) {
+    s += a[i];
+  }
+
+  return s;
+}
+
+static double
+calc_variance(double* a, size_t n, double mean)
+{
+  int i;
+
+  double d;
+  double s;
+
+  s = 0;
+
+  for (i = 0; i < (int)n; i++) {
+    d  = a[i] - mean; 
+    s += (d * d);
+  }
+
+  return s / n;
+}
+
+static double
+calc_cdf(double* a, size_t n, double v)
+{
+  int idx;
+
+  if (v > a[n - 1]) {
+    idx = n;
+  } else {
+    idx = binsearch(a, n, v);
+  }
+
+  return (double)idx / n;
+}
+
+static double
+calc_moment(double* a, size_t n, double k)
+{
+  double s;
+  int i;
+
+  for (i = 0; i < (int)n; i++) {
+    s += pow(a[i], k);
+  }
+
+  return s / n;
+}
+
+static double
+calc_central_moment(double* a, size_t n, double k, double mean)
+{
+  double s;
+  int i;
+
+  for (i = 0; i < (int)n; i++) {
+    s += pow(a[i] - mean, k);
+  }
+
+  return s / n;
+}
+
+static double
+calc_std_moment(double* a, size_t n, double k, double mean, double std)
+{
+  return calc_central_moment(a, n, k, mean) / pow(std, k);
+}
+
+static double
+calc_normal_pdf(double* a, size_t n,
+                double mean, double std, double total, double v)
+{
+  double t;
+
+  t = (v - mean) / std;
+
+  // 2.50662827463 == sqrt(2.0 * M_PI)
+  return (exp(-0.5 * (t * t)) / (std * 2.50662827463)) / total;
+}
+
+static double
+kernel_gaussian(double x)
+{
+  // 2.50662827463 == sqrt(2.0 * M_PI)
+  return exp(-(x * x) / 2.0) / 2.50662827463;
+}
+
+static double
+calc_kde(double* a, size_t n, double sig, double v)
+{
+  double h;
+  double s;
+  int i;
+
+  h = (0.9 * sig) / pow(n, 1.0 / 5.0);
+  s = 0.0;
+
+  for (i = 0; i < (int)n; i++) {
+    s += kernel_gaussian((v - a[i]) / h);
+  }
+
+  return (s / (n * h));
+}
+
+int
+cheap_stats_new(double* src, size_t n, cheap_stats_t** dst)
+{
+	int ret;
+  double* a0;
+  double* a1;
+  cheap_stats_t* ptr;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+  ptr = NULL;
+  a0  = NULL;
+  a1  = NULL;
+
+  /*
+   * argument check
+   */
+  do {
+    if (src == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (n < MIN_SAMPLES) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * alloc memory
+   */
+  if (!ret) do {
+    a0 = NALLOC(double, n);
+    if (a0 == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    a1 = NALLOC(double, n);
+    if (a1 == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    ptr = ALLOC(cheap_stats_t);
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * put return parameter
+   */
+  if (!ret) {
+    memcpy(a0, src, sizeof(double) * n);
+    memcpy(a1, src, sizeof(double) * n);
+    combsort11(a1, n);
+
+    ptr->a0       = a0;
+    ptr->a1       = a1;
+    ptr->n        = n;
+    ptr->total    = calc_sum(a0, n);
+    ptr->mean     = ptr->total / n;
+    ptr->min      = ptr->a1[0];
+    ptr->max      = ptr->a1[n - 1];
+    ptr->q1       = ptr->a1[n / 4];
+    ptr->q3       = ptr->a1[(3 * n) / 4];
+    ptr->median   = ptr->a1[n / 2];
+    ptr->variance = calc_variance(a0, n, ptr->mean);
+    ptr->std      = sqrt(ptr->variance);
+
+    *dst = ptr;
+  }
+
+  /*
+   * post process
+   */
+  if (ret) {
+    if (ptr) free(ptr);
+    if (a0) free(a0);
+    if (a1) free(a1);
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_destroy(cheap_stats_t* ptr)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  if (ptr == NULL) {
+    ret = DEFAULT_ERROR;
+  }
+
+  /*
+   * release memory
+   */
+  if (!ret) {
+    if (ptr->a0) free(ptr->a0);
+    if (ptr->a1) free(ptr->a1);
+    free(ptr);
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_cdf(cheap_stats_t* ptr, double v, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc CDF
+   */
+  if (!ret) {
+    *dst = calc_cdf(ptr->a1, ptr->n, v); 
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_normal_pdf(cheap_stats_t* ptr, double v, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc CDF
+   */
+  if (!ret) {
+    *dst = calc_normal_pdf(ptr->a1, ptr->n, ptr->mean, ptr->std, ptr->total, v);
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_estimated_pdf(cheap_stats_t* ptr, double v, double* dst)
+{
+  int ret;
+  double sig;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc CDF
+   */
+  if (!ret) {
+    sig  = ptr->q3 - ptr->q1;
+    if (sig > ptr->std) sig = ptr->std;
+
+    *dst = calc_kde(ptr->a1, ptr->n, sig, v); 
+  }
+
+  return ret;
+}
+
+
+int
+cheap_stats_moment(cheap_stats_t* ptr, double k, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc raw moment
+   */
+  if (!ret) {
+    *dst = calc_moment(ptr->a1, ptr->n, k); 
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_central_moment(cheap_stats_t* ptr, double k, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc raw moment
+   */
+  if (!ret) {
+    *dst = calc_central_moment(ptr->a1, ptr->n, k, ptr->mean); 
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_std_moment(cheap_stats_t* ptr, double k, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc raw moment
+   */
+  if (!ret) {
+    *dst = calc_std_moment(ptr->a1, ptr->n, k, ptr->mean, ptr->std); 
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_skewness(cheap_stats_t* ptr, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc raw moment
+   */
+  if (!ret) {
+    *dst = calc_std_moment(ptr->a1, ptr->n, 3.0, ptr->mean, ptr->std); 
+  }
+
+  return ret;
+}
+
+int
+cheap_stats_pearson_skewness(cheap_stats_t* ptr, double* dst)
+{
+  int ret;
+
+  /*
+   * initialize
+   */
+  ret = 0;
+
+  /*
+   * argument check
+   */
+  do {
+    if (ptr == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+
+    if (dst == NULL) {
+      ret = DEFAULT_ERROR;
+      break;
+    }
+  } while (0);
+
+  /*
+   * calc raw moment
+   */
+  if (!ret) {
+    *dst = (3.0 * (ptr->mean - ptr->median)) / (ptr->std + 1e-15);
+  }
+
+  return ret;
+}
+

data/ext/cheap_stats/cheap_stats.h

@@ -0,0 +1,37 @@
+/*
+ * Small statics library
+ *
+ *  Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+#ifndef __SMALL_STATS_H__
+#define __SMALL_STATS_H__
+
+#include <stdlib.h>
+
+typedef struct {
+  double* a0;
+  double* a1; // sorted
+  size_t n;
+
+  double total;
+  double mean;
+  double min;
+  double max;
+  double q1;
+  double q3;
+  double median;
+  double variance;
+  double std;
+} cheap_stats_t;
+
+int cheap_stats_new(double* samples, size_t size, cheap_stats_t** obj);
+int cheap_stats_destroy(cheap_stats_t* obj);
+int cheap_stats_cdf(cheap_stats_t* obj, double v, double* dst);
+int cheap_stats_moment(cheap_stats_t* obj, double k, double* dst);
+int cheap_stats_central_moment(cheap_stats_t* obj, double k, double* dst);
+int cheap_stats_std_moment(cheap_stats_t* obj, double k, double* dst);
+int cheap_stats_skewness(cheap_stats_t* obj, double* dst);
+int cheap_stats_pearson_skewness(cheap_stats_t* obj, double* dst);
+
+#endif /* !defined(__SMALL_STATS_H__) */

data/ext/cheap_stats/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_library( "m")
+create_makefile( "cheap_stats/cheap_stats")

data/ext/cheap_stats/rb_cheap_stats.c

@@ -0,0 +1,513 @@
+/*
+ * cheap statistics library for ruby
+ *
+ *  Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include "ruby.h"
+
+#include "cheap_stats.h"
+
+#define N(x)                      (sizeof(x)/sizeof(*x))
+
+#define RUNTIME_ERROR(msg, ...)   rb_raise(rb_eRuntimeError, (msg), __VA_ARGS__)
+#define ARGUMENT_ERROR(msg, ...)  rb_raise(rb_eArgError, (msg), __VA_ARGS__)
+#define TYPE_ERROR(msg, ...)      rb_raise(rb_eTypeError, (msg), __VA_ARGS__)
+#define NOMEMORY_ERROR(msg, ...)  rb_raise(rb_eNoMemError, (msg), __VA_ARGS__)
+
+#define API_SIMPLIFIED            1
+#define API_CLASSIC               2
+
+#define EQ_STR(val,str)           (rb_to_id(val) == rb_intern(str))
+#define EQ_INT(val,n)             (FIX2INT(val) == n)
+#define IS_NUMERIC(t) \
+      ((t) == T_FLOAT || (t) ==  T_FIXNUM || (t) == T_BIGNUM)
+
+typedef struct {
+  cheap_stats_t* stats;
+} rb_cheap_stats_t;
+
+VALUE klass;
+
+static size_t
+rb_cheap_stats_size(const void* _ptr)
+{
+  rb_cheap_stats_t* ptr;
+
+  ptr = (rb_cheap_stats_t*)_ptr;
+
+  return sizeof(*ptr) + ((sizeof(double) * ptr->stats->n) * 2);
+}
+
+static void
+rb_cheap_stats_free(void* _ptr)
+{
+  rb_cheap_stats_t* ptr;
+
+  ptr = (rb_cheap_stats_t*)_ptr;
+
+  if (ptr->stats != NULL) {
+    cheap_stats_destroy(ptr->stats);
+    ptr->stats = NULL;
+  }
+
+  xfree(ptr);
+}
+
+static const struct rb_data_type_struct rb_cheap_stats_data_type = {
+  "A Cheap satatics library",
+  {
+    NULL,
+    rb_cheap_stats_free,
+    rb_cheap_stats_size,
+    {NULL, NULL}
+  },
+  NULL,
+  NULL,
+};
+
+static VALUE
+rb_cheap_stats_alloc(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  ptr = ALLOC(rb_cheap_stats_t);
+  memset(ptr, 0, sizeof(*ptr));
+
+  return TypedData_Wrap_Struct(klass, &rb_cheap_stats_data_type, ptr);
+}
+
+/**
+ * initialize object
+ *
+ * @params [Array<Numeric>] samples   sample vaules.
+ */
+static VALUE
+rb_cheap_stats_initialize(VALUE self, VALUE samples)
+{
+  rb_cheap_stats_t* ptr;
+  VALUE exp;
+  const char* msg;
+  int err;
+  double *a;
+  int i;
+  int n;
+  VALUE v;
+  int t;
+  char str[64];
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  Check_Type(samples, T_ARRAY);
+
+  do {
+    exp = Qnil;
+    a   = NULL;
+
+    /*
+     * allocate work buffer
+     */
+    n   = RARRAY_LEN(samples);
+    a   = malloc(sizeof(double) * n);
+
+    if (a == NULL) {
+      exp = rb_eNoMemError;
+      msg = "Memory allocation failed";
+      break;
+    }
+
+    /*
+     * copy source value
+     */
+    for (i = 0; i < n; i++) {
+      v = RARRAY_AREF(samples, i);
+      t = TYPE(v);
+
+      if (!IS_NUMERIC(t)) break;
+
+      a[i] = NUM2DBL(v);
+    }
+
+    if (i != n) {
+      exp = rb_eTypeError;
+      msg = "the value that not numeric was included";
+    }
+
+    /*
+     * create statistic context
+     */
+    err = cheap_stats_new(a, n, &ptr->stats);
+    if (err) {
+      sprintf(str, "cheap_stats_new() failed [err=%d]", err); 
+
+      exp = rb_eRuntimeError;
+      msg = str;
+      break;
+    }
+  } while (0);
+
+  /*
+   * post porcess 
+   */
+  if (a != NULL) free(a);
+
+  if (exp != Qnil) {
+    if (ptr->stats != NULL) {
+      cheap_stats_destroy(ptr->stats);
+      ptr->stats = NULL;
+    }
+
+    rb_raise(exp, msg);
+  }
+
+  return self;
+}
+
+/**
+ * get total value of samples
+ *
+ * @return [Float] total value
+ */
+static VALUE
+rb_cheap_stats_total(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->total);
+}
+
+/**
+ * get mean of samples
+ *
+ * @return [Float] mean
+ */
+static VALUE
+rb_cheap_stats_mean(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->mean);
+}
+
+/**
+ * get min value of samples
+ *
+ * @return [Float] min value
+ */
+static VALUE
+rb_cheap_stats_min(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->min);
+}
+
+/**
+ * get max value of samples
+ *
+ * @return [Float] max value
+ */
+static VALUE
+rb_cheap_stats_max(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->max);
+}
+
+/**
+ * get 1/4 quartile value of samples
+ *
+ * @return [Float] 1/4 quartile value
+ */
+static VALUE
+rb_cheap_stats_q1(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->q1);
+}
+
+/**
+ * get 3/4 quartile value of samples
+ *
+ * @return [Float] 3/4 quartile value
+ */
+static VALUE
+rb_cheap_stats_q3(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->q3);
+}
+
+/**
+ * get median of samples
+ *
+ * @return [Float] median
+ */
+static VALUE
+rb_cheap_stats_median(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->median);
+}
+
+/**
+ * get standard division of samples
+ *
+ * @return [Float] standard division
+ */
+static VALUE
+rb_cheap_stats_std(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->std);
+}
+
+/**
+ * get variance of samples
+ *
+ * @return [Float] variance
+ */
+static VALUE
+rb_cheap_stats_variance(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  return DBL2NUM(ptr->stats->variance);
+}
+
+/**
+ * calc CDF
+ *
+ * @param [Numeric] x   taregt value
+ *
+ * @return [Float] CDF value that coresspoinding to target.
+ */
+static VALUE
+rb_cheap_stats_cdf(VALUE self, VALUE x)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_cdf(ptr->stats, rb_num2dbl(x), &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_cdf() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+/**
+ * calc moment
+ *
+ * @param [Numeric] k   order number
+ *
+ * @return [Float] moment value
+ */
+static VALUE
+rb_cheap_stats_moment(VALUE self, VALUE k)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_moment(ptr->stats, rb_num2dbl(k), &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_moment() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+/**
+ * calc central moment
+ *
+ * @param [Numeric] k   order number
+ *
+ * @return [Float] moment value
+ */
+static VALUE
+rb_cheap_stats_central_moment(VALUE self, VALUE k)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_central_moment(ptr->stats, rb_num2dbl(k), &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_central_moment() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+/**
+ * calc std (standard division) moment
+ *
+ * @param [Numeric] k   order number
+ *
+ * @return [Float] moment value
+ */
+static VALUE
+rb_cheap_stats_std_moment(VALUE self, VALUE k)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_std_moment(ptr->stats, rb_num2dbl(k), &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_std_moment() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+/**
+ * calc skewness value
+ *
+ * @return [Float] skewness value
+ */
+static VALUE
+rb_cheap_stats_skewness(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_skewness(ptr->stats,  &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_skewness() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+/**
+ * calc pearson median skewness value
+ *
+ * @return [Float] skewness value
+ */
+static VALUE
+rb_cheap_stats_pearson_skewness(VALUE self)
+{
+  rb_cheap_stats_t* ptr;
+  int err;
+  double ret;
+
+  /*
+   * strip context data
+   */
+  TypedData_Get_Struct(self, rb_cheap_stats_t, &rb_cheap_stats_data_type, ptr);
+
+  /*
+   * check argument
+   */
+  err = cheap_stats_pearson_skewness(ptr->stats,  &ret);
+  if (err) {
+    RUNTIME_ERROR("cheap_stats_pearson_skewness() failed [err=%d]", err);
+  }
+
+  return DBL2NUM(ret);
+}
+
+void
+Init_cheap_stats()
+{
+  klass = rb_define_class("CheapStats", rb_cObject);
+
+  rb_define_alloc_func(klass, rb_cheap_stats_alloc);
+
+  rb_define_method(klass, "initialize", rb_cheap_stats_initialize, 1);
+  rb_define_method(klass, "total", rb_cheap_stats_total, 0);
+  rb_define_method(klass, "min", rb_cheap_stats_min, 0);
+  rb_define_method(klass, "max", rb_cheap_stats_max, 0);
+  rb_define_method(klass, "q1", rb_cheap_stats_q1, 0);
+  rb_define_method(klass, "q3", rb_cheap_stats_q3, 0);
+  rb_define_method(klass, "mean", rb_cheap_stats_mean, 0);
+  rb_define_method(klass, "median", rb_cheap_stats_median, 0);
+  rb_define_method(klass, "variance", rb_cheap_stats_variance, 0);
+  rb_define_method(klass, "std", rb_cheap_stats_std, 0);
+  rb_define_method(klass, "cdf", rb_cheap_stats_cdf, 1);
+  rb_define_method(klass, "moment", rb_cheap_stats_moment, 1);
+  rb_define_method(klass, "central_moment", rb_cheap_stats_central_moment, 1);
+  rb_define_method(klass, "std_moment", rb_cheap_stats_std_moment, 1);
+  rb_define_method(klass, "skewness", rb_cheap_stats_skewness, 0);
+  rb_define_method(klass, "pearson_skewness",rb_cheap_stats_pearson_skewness,0);
+
+  rb_alias(klass, rb_intern("average"), rb_intern("mean"));
+  rb_alias(klass, rb_intern("sigma"), rb_intern("std"));
+}

data/lib/cheap_stats.rb

@@ -0,0 +1,11 @@
+#
+# Cheap statistics for rUby
+#
+#   Copyright (C) 2019 Hiroshi Kuwagata <kgt9221@gmail.com>
+#
+
+require "cheap_stats/version"
+require "cheap_stats/cheap_stats"
+
+class CheapStats
+end

data/lib/cheap_stats/version.rb

@@ -0,0 +1,3 @@
+class CheapStats
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: cheap-stats
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Hiroshi Kuwagata
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  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'
+description: A cheaper statistics library.
+email:
+- kgt9221@gmail.com
+executables: []
+extensions:
+- ext/cheap_stats/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cheap-stats.gemspec
+- ext/cheap_stats/cheap_stats.c
+- ext/cheap_stats/cheap_stats.h
+- ext/cheap_stats/extconf.rb
+- ext/cheap_stats/rb_cheap_stats.c
+- lib/cheap_stats.rb
+- lib/cheap_stats/version.rb
+homepage: https://github.com/kwgt/cheap-stats
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kwgt/cheap-stats
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: A cheaper statistics library.
+test_files: []