randomext 0.1

data/ext/binomial.c

@@ -0,0 +1,323 @@
+#include "randomext.h"
+
+typedef struct {
+  int n;
+  double theta;
+  int N;
+  int k;
+  double *p;
+  int *T;
+  int *K;
+  double *V;
+} binomial_t;
+
+static double binomial_distribution(int k, int n, double theta)
+{
+  double ret = 1.0;
+  int i;
+  for (i=1; i <= k; ++i) {
+    ret *= n-k+i;
+    ret /= i;
+    ret *= theta;
+    if (i <= n - k)
+      ret *= 1 - theta;
+  }
+  for (i=0; i<n-2*k; ++i)
+    ret *= 1 - theta;
+
+  return ret;
+}
+
+/* Returns Bin(x+1| n, theta)/Bin(x| n, theta) */
+inline static double forward_ratio(double x, double n, double theta)
+{
+  return ((n+1)/(x+1) - 1)*(theta/(1-theta));
+}
+
+/* Returns Bin(x-1| n, theta)/Bin(x| n, theta) */
+inline static double backward_ratio(double x, double n, double theta)
+{
+  return ((n+1)/(n+1-x)-1)*((1-theta)/theta);
+}
+
+static void check_binomial_params(int n, double theta, const char* method_name)
+{
+  if (n < 1)
+    rb_raise(rb_eArgError, "%s: n must be >= 1", method_name);
+  if (theta <= 0.0 || 1.0 <= theta)
+    rb_raise(rb_eArgError, "%s: n must be in (0, 1)", method_name);
+  
+}
+/*
+ * Draws a random sample from a binomial distribution
+ *
+ * Inverse function method is used.
+ *
+ * @overload binomial(n, theta)
+ * @param [Integer] n the number of trials (n > 0)
+ * @param [Float] theta success probability (0 < theta < 1)
+ * @return [Integer] a random sample in 0..n
+ */
+static VALUE random_binomial_inv(VALUE self, VALUE num, VALUE prob)
+{
+  int n = NUM2INT(num);
+  double theta = NUM2DBL(prob);
+  int mode = floor(theta*(n+1));
+  int xl = mode;
+  int xu = mode+1;
+  double pl = binomial_distribution(xl, n, theta);
+  double pu = pl*forward_ratio(xl, n, theta);
+  double u = rb_random_real(self);
+
+  check_binomial_params(n, theta, "Random#binomial");
+  
+  for (;xl >=0 || xu <= n;) {
+    if (xl >= 0) {
+      if (u <= pl)
+        return INT2NUM(xl);
+      u = u - pl;
+      pl *= backward_ratio(xl, n, theta);
+      --xl;
+    }
+    if (xu <= n) {
+      if (u <= pu)
+        return INT2NUM(xu);
+      u = u - pu;
+      pu *= forward_ratio(xu, n, theta);
+      ++xu;
+    }
+  }
+  
+  return INT2FIX(0);
+}
+
+static void fill_binomial_table(binomial_t *bin)
+{
+  double theta = bin->theta;
+  double n = bin->n;
+  int mode = floor(theta*(n+1));
+  int k;
+
+  bin->p[mode] = binomial_distribution(mode, n, theta);
+  for (k = mode+1; k <= n; ++k) {
+    bin->p[k] = bin->p[k-1]*forward_ratio(k-1, n, theta);
+  }
+  for (k = mode-1; k >= 0; --k) {
+    bin->p[k] = bin->p[k+1]*backward_ratio(k+1, n, theta);
+  }
+}
+
+static void fill_binomial_VK_table(binomial_t *bin, double ntheta[])
+{
+  double c = 1.0/(bin->n + 1);
+  int i, j, n, x;
+  
+  bin->K = ALLOC_N(int, bin->n + 1);
+  bin->V = ALLOC_N(double, bin->n + 1);
+
+  for (i=0; i<=bin->n; ++i) {
+    bin->K[i] = i;
+    bin->V[i] = (i+1)*c;
+  }
+
+  for (n=0; n<bin->n; ++n) {
+    for (x=0, i=j=0; x<=bin->n; ++x) {
+      if (ntheta[x] < ntheta[i])
+        i = x;
+      if (ntheta[x] > ntheta[j])
+        j = x;
+    }
+    bin->K[i] = j;
+    bin->V[i] = i*c + ntheta[i];
+    ntheta[j] = ntheta[j] - (c - ntheta[i]);
+    ntheta[i] = c;
+  }
+}
+
+static void fill_binomial_T_VT_table(binomial_t *bin)
+{
+  int k, i, x;
+  int nt;
+  int *qt = ALLOC_N(int, bin->n + 2);
+  double *theta = ALLOC_N(double, bin->n + 1);
+  double *ntheta = ALLOC_N(double, bin->n + 1);
+  double sum_theta = 0;
+  
+  for (k=7; ;k++) {
+    int b = pow2(k);
+    nt = 0;
+    qt[0] = 0;
+    for (x=0; x<=bin->n; x++) {
+      qt[x+1] = floor(b*bin->p[x]) + qt[x];
+    }
+    if (k > 16 || qt[bin->n + 1] > 0.9*b)
+      break;
+  }
+
+  bin->k = k;
+  bin->N = pow2(k);
+  bin->T = ALLOC_N(int, bin->N);
+  for (x=0; x<=bin->n; ++x) {
+    for (i=qt[x]; i<qt[x+1]; ++i)
+      bin->T[i] = x;
+  }
+  for (i=qt[bin->n + 1]; i<bin->N; ++i)
+    bin->T[i] = -1;
+
+  for (x=0; x<=bin->n; ++x) {
+    theta[x] = pow2(k) * bin->p[x] - (qt[x+1]-qt[x]);
+    sum_theta += theta[x];
+  }
+  
+  for (x=0; x<=bin->n; ++x)
+    ntheta[x] = theta[x]/sum_theta;
+
+  fill_binomial_VK_table(bin, ntheta);
+
+  xfree(qt);
+  xfree(theta);
+  xfree(ntheta);
+}
+
+static void binomial_free(binomial_t *bin)
+{
+  xfree(bin->p);
+  xfree(bin->T);
+  xfree(bin->K);
+  xfree(bin->V);
+  xfree(bin);
+}
+      
+static VALUE binomial_alloc(VALUE klass)
+{
+  binomial_t *bin;
+  VALUE obj = Data_Make_Struct(klass, binomial_t, 0, binomial_free, bin);
+  bin->n = -1; 
+  bin->p = NULL; bin->T = NULL; bin->K = NULL; bin->V = NULL;
+  return obj;
+}
+
+/*
+ * Returns a random sampler from a binomial distribution.
+ *
+ * This sampler uses table plus square histgram method with
+ * Robin Hoot method. This method constructs a table for each
+ * distribution. If you once construct the table, you can
+ * draw a random sample fast for large n (n >= 40), but the
+ * cost of the table construction is expensive. Therefore,
+ * if you need to draw many samples from the same binomial distribution,
+ * you had better to use this class. Otherwise, you should use
+ * Random#binomial.
+ *
+ * @overload initialize(rng, n, theta)
+ * @param [Random] rng a random number generator
+ * @param [Integer] n the number of trials (n > 0)
+ * @param [Float] theta success probability (0 < theta < 1)
+ * @return [Random::Binomial] a random number generator from the specified binomial distribution
+ */
+static VALUE binomial_initialize(VALUE self, VALUE rng, VALUE num, VALUE prob)
+{
+  binomial_t *bin;
+  int n = NUM2INT(num);
+  double theta = NUM2DBL(prob);
+
+  check_binomial_params(n, theta, "Random::Binomial.new");
+  
+  rb_iv_set(self, "rng", rng);
+  Data_Get_Struct(self, binomial_t, bin);
+  bin->n = n;
+  bin->theta = theta;
+  bin->p = ALLOC_N(double, bin->n + 1);
+
+  fill_binomial_table(bin);
+  fill_binomial_T_VT_table(bin);
+  
+  return Qnil;
+}
+
+/*
+ * Draws a sample from the binomimial distribution whose parameters
+ * are specified in Random::Binomial.new.
+ *
+ * @return [Integer] a random sample
+ */
+static VALUE binomial_rand(VALUE self)
+{
+  VALUE rng = rb_iv_get(self, "rng");
+  binomial_t *bin;
+  uint32_t I0 = rb_random_int32(rng);
+  uint32_t ILk;
+  double U;
+  int J;
+
+  Data_Get_Struct(self, binomial_t, bin);
+  
+  ILk = I0 & MASK(bin->k);
+  if (bin->T[ILk] >= 0)
+    return INT2NUM(bin->T[ILk]);
+  
+  U = rb_random_real(rng);
+  J = floor((bin->n + 1)*U);
+  if (U < bin->V[J])
+    return INT2NUM(J);
+  else
+    return INT2NUM(bin->K[J]);
+}
+
+/*
+ * @!attribute [r] n
+ * @return [Integer] the parameter n
+ */
+static VALUE binomial_n(VALUE self)
+{
+  binomial_t *bin;
+  Data_Get_Struct(self, binomial_t, bin);
+
+  return INT2NUM(bin->n);
+}
+
+/*
+ * @!attribute [r] theta
+ * @return [Float] the parameter theta
+ */
+static VALUE binomial_theta(VALUE self)
+{
+  binomial_t *bin;
+  Data_Get_Struct(self, binomial_t, bin);
+
+  return DBL2NUM(bin->theta);
+}
+
+#if 0
+static VALUE binomial_debug_info(VALUE self)
+{
+  binomial_t *bin;
+  int i;
+  
+  Data_Get_Struct(self, binomial_t, bin);
+  
+
+  printf("N=%d\n", bin->N);
+  for (i=0; i<bin->N; ++i) {
+    printf("%d ", bin->T[i]);
+  }
+  puts("");
+  for (i=0; i<=bin->n; ++i) {
+    printf("%f %d\n", bin->V[i], bin->K[i]);
+  }
+  return Qnil;
+}
+#endif
+
+void randomext_binomial_init(VALUE cRandom)
+{
+  VALUE cBinomial = rb_define_class_under(cRandom, "Binomial", rb_cObject);
+  
+  rb_define_method(cRandom, "binomial", random_binomial_inv, 2);
+  rb_define_alloc_func(cBinomial, binomial_alloc);
+  rb_define_method(cBinomial, "initialize", binomial_initialize, 3);
+  rb_define_method(cBinomial, "rand", binomial_rand, 0);
+  rb_define_method(cBinomial, "n", binomial_n, 0);
+  rb_define_method(cBinomial, "theta", binomial_theta, 0);
+  //rb_define_method(cBinomial, "debug_info", binomial_debug_info, 0);
+}

data/ext/extconf.rb

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

data/ext/gamma.c

@@ -0,0 +1,32 @@
+#include "randomext.h"
+
+/*
+ * @private
+ */
+static VALUE random_gamma(VALUE self, VALUE shape)
+{
+  double c, d;
+  
+  if (NUM2DBL(shape) < 1.0)
+    rb_raise(rb_eArgError, "Random#_gamma: shape parameter must be >= 1.0");
+  
+  d = NUM2DBL(shape) - 1.0/3.0;
+  c = 1/sqrt(9*d);
+
+  for (;;) {
+    double z, v, y, w, u;
+    z = randomext_random_standard_normal(self);
+    v = 1 + c*z;
+    if (v <= 0) continue;
+    w = v*v*v; y = d*w;
+    u = random_open_interval(self);
+    if (u > 1 - 0.0331*(z*z*z*z) && z*z/2 + d*log(w) - y + d < log(u))
+      continue;
+    return DBL2NUM(y);
+  }
+}
+
+void randomext_gamma_init(VALUE cRandom)
+{
+  rb_define_private_method(cRandom, "_gamma", random_gamma, 1);
+}

data/ext/hypergeometric.c

@@ -0,0 +1,81 @@
+#include "randomext.h"
+
+/* Returns HGeo(x+1| N, M, n)/HGeo(x| N, M, n) */
+inline static double forward_ratio(int x, int N, int M, int n)
+{
+  return (double)((M-x)*(n-x))/((x+1)*(N-M-n+x+1));
+}
+
+/* Returns HGeo(x-1| N, M, n)/HGeo(x| N, M, n) */
+inline static double backward_ratio(int x, int N, int M, int n)
+{
+  return 1.0/forward_ratio(x-1, N, M, n);
+}
+
+/* Returns HGeo(x| N, M, n) */
+static inline double hypergeometric_distribution(int x, int N, int M, int n)
+{
+  return exp(randomext_logcombination(M, x)
+             + randomext_logcombination(N-M, n-x)
+             - randomext_logcombination(N, n));
+}
+
+/*
+ * Draws a random sample from a hypergeometric distribution.
+ *
+ * Inverse method is used.
+ *
+ * @overload hypergeometric(N, M, n)
+ * @param [Integer] N a population (N >= 0)
+ * @param [Integer] M the number of successes (0 <= M <= N)
+ * @param [Integer] n the number of samples (0 <= n <= N)
+ * @return [Integer] a random sample in [max(0, n-(N-M)), min(n, M)]
+ */
+static VALUE random_hypergoemtric_inv(VALUE self, VALUE vN, VALUE vM, VALUE vn)
+{
+  int N = NUM2INT(vN);
+  int M = NUM2INT(vM);
+  int n = NUM2INT(vn);
+  int ok = (N >= 0) && (M >= 0) && (n >= 0) && (M <= N) && (n <= N);
+  int mode, x_min, x_max, xu, xl;
+  double pl, pu;
+  double u;
+  
+  if (!ok)
+    rb_raise(rb_eArgError,
+             "Random#hypergeometric: paramters must be:"
+             "(N >= 0) && (M >= 0) && (n >= 0) && (M <= N) && (n <= N)");
+
+  mode = (M+1)*(n+1) / (N+2);
+  x_min = MAX2(0, n - (N-M));
+  x_max = MIN2(n, M);
+  xu = mode;
+  pu = hypergeometric_distribution(mode, N, M, n);
+  xl = mode-1;
+  pl = pu * backward_ratio(mode, N, M, n);
+  u = rb_random_real(self);
+
+  for (;x_min <= xl || xu <= x_max;) {
+    if (xu <= x_max) {
+      if (u <= pu)
+        return INT2NUM(xu);
+      u -= pu;
+      pu *= forward_ratio(xu, N, M, n);
+      ++xu;
+    }
+    if (xl >= x_min) {
+      if (u <= pl)
+        return INT2NUM(xl);
+      u -= pl;
+      pl *= backward_ratio(xl, N, M, n);
+      --xl;
+    }
+  }
+  
+  return INT2NUM(x_min);
+}
+
+void randomext_hypergeometric_init(VALUE cRandom)
+{
+  rb_define_method(cRandom, "hypergeometric", random_hypergoemtric_inv, 3);
+}

data/ext/other.c

@@ -0,0 +1,122 @@
+#include "randomext.h"
+
+/* 
+ * Draws a random sample from a von Mises distribution.
+ *
+ * The return value is contained in [-PI, PI].
+ *
+ * @overload vonmises(mu, kappa)
+ * @param [Float] mu direction parameter (-PI <= mu <= PI)
+ * @param [Float] kappa concentration parameter (kappa > 0)
+ * @return [Float] A random sample in [-PI, PI]
+ */
+static VALUE random_vonmises(VALUE self, VALUE vmu, VALUE vkappa)
+{
+  double mu = NUM2DBL(vmu);
+  double kappa = NUM2DBL(vkappa);
+  double s;
+  
+  if (kappa <= 0)
+    rb_raise(rb_eArgError, "Random#vonmises: parameter kappa must be positive");
+  
+  s = (1 + sqrt(1+4*kappa*kappa))/(2*kappa);
+  
+  for (;;) {
+    double u = rb_random_real(self);
+    double z = cos(2*M_PI*u);
+    double W = (1-s*z)/(s-z);
+    double T = kappa*(s-W);
+    double U = rb_random_real(self);
+    double V = rb_random_real(self);
+    double x, y;
+    
+    if (V > T*(2-T) && V > T*exp(1-T))
+      continue;
+
+    if (U < 0.5)
+      y = -acos(W);
+    else
+      y = acos(W);
+    x = y + mu;
+    if (x >= M_PI)
+      return DBL2NUM(x - M_PI);
+    else if (x < -M_PI)
+      return DBL2NUM(x + M_PI);
+    else
+      return DBL2NUM(x);
+  }
+}
+
+/*
+ * Draws a random sample from a Zipf-Mandelbrot distribution.
+ *
+ * In case of q == 0.0, the distribution is called a Zipf distribution.
+ *
+ * @overload zipf_mandelbrot(n, q=0.0, s=1.0)
+ * @param [Integer] n the maximum of return value (n > 0)
+ * @param [Float] q a parameter (q >= 0.0)
+ * @param [Float] s a parameter (s > 0.0)
+ * @return [Integer] a random sample in 1..n
+ */
+static VALUE random_zipf(int argc, VALUE *argv, VALUE self)
+{
+  VALUE vN, vs, vq;
+  int N;
+  double s, q;
+  double sum;
+  int i;
+  double u;
+  
+  rb_scan_args(argc, argv, "12", &vN, &vq, &vs);
+  N = NUM2INT(vN);
+  s = NIL_P(vs) ? 1.0 : NUM2DBL(vs);
+  q = NIL_P(vq) ? 0.0 : NUM2DBL(vq);
+
+  if (N <= 0 || s <= 0 || q < 0)
+    rb_raise(rb_eArgError, "Random#zipf_mandelbrot: parameters must be N >0, s > 0, q >= 0");
+  
+  for (i=1, sum=0; i<=N; ++i)
+    sum += 1.0/pow(i+q, s);
+
+  u = rb_random_real(self);
+  
+  for (i=1; i<=N; ++i) {
+    double p = 1.0/pow(i+q, s)/sum;
+    if (u <= p)
+      return INT2NUM(i);
+    u -= p;
+  }
+  
+  return INT2NUM(N);
+}
+
+/*
+ * Draws a random sample from a zeta distribution.
+ *
+ * @overload zeta(s)
+ * @param [Integer] s a parameter (s > 0.0)
+ * @return [Integer] a random sample in [1, INFINITY)
+ */
+static VALUE random_zeta(VALUE self, VALUE vs)
+{
+  double s = NUM2DBL(vs);
+  double q = s - 1.0;
+  double r = -1.0/q;
+  double t = pow(2.0, q);
+
+  for (;;) {
+    double u = 1.0 - rb_random_real(self);
+    double v = rb_random_real(self);
+    int x = floor(pow(u, r));
+    double w = pow(1.0 + 1.0/x, q);
+    if (v*x*(w-1)/(t-1) <= w/t)
+      return INT2NUM(x);
+  }
+}
+
+void randomext_other_init(VALUE cRandom)
+{
+  rb_define_method(cRandom, "vonmises", random_vonmises, 2);
+  rb_define_method(cRandom, "zipf_mandelbrot", random_zipf, -1);
+  rb_define_method(cRandom, "zeta", random_zeta, 1);
+}

data/ext/poisson.c

@@ -0,0 +1,65 @@
+#include "randomext.h"
+
+static double poisson_distribution(int m, double lambda)
+{
+  return exp(-lambda + m*log(lambda) - randomext_sumlog(1, m));
+}
+
+/* Returns Poi(x+1|lambda)/Poi(x|lambda) */
+static inline double forward_ratio(int x, double lambda)
+{
+  return lambda/(x+1);
+}
+
+/* Returns Poi(x-1|lambda)/Poi(x|lambda) */
+static inline double backward_ratio(int x, double lambda)
+{
+  return x/lambda;
+}
+
+/*
+ * Draws a random sample from a Poisson distribution.
+ *
+ * Inverse function method is used.
+ *
+ * @overload poisson(lambda)
+ * @param [Float] lambda mean
+ * @return [Integer] a random sample in [0, INFINITY)
+ */
+static VALUE random_poisson_inv(VALUE self, VALUE l)
+{
+  double lambda = NUM2DBL(l);
+  int mode, xu, xl;
+  double pu, pl, u;
+  
+  if (lambda <= 0.0)
+    rb_raise(rb_eArgError, "Random#poisson: lambda must be positive");
+
+  mode = floor(lambda);
+  xu = mode;
+  xl = mode - 1;
+  pu = poisson_distribution(mode, lambda);
+  pl = pu * backward_ratio(xu, lambda);
+  u = rb_random_real(self);
+  
+  for (;;) {
+    if (u <= pu)
+      return INT2NUM(xu);
+    u = u - pu;
+    pu *= forward_ratio(xu, lambda);
+    ++xu;
+
+    if (xl >= 0) {
+      if (u <= pl)
+        return INT2NUM(xl);
+      u = u - pl;
+      pl *= backward_ratio(xl, lambda);
+      --xl;
+    }
+  }
+}
+
+void randomext_poisson_init(VALUE cRandom)
+{
+  rb_define_method(cRandom, "poisson", random_poisson_inv, 1);
+}

data/ext/randomext.h

@@ -0,0 +1,27 @@
+#include <ruby.h>
+#include <math.h>
+#include <stdint.h>
+
+double randomext_random_standard_normal(VALUE random);
+double randomext_sumlog(int from, int to);
+double randomext_logcombination(int n, int m);
+
+inline static uint64_t pow2(int r)
+{
+  return (uint64_t)1<<r;
+}
+
+inline static double random_open_interval(VALUE random)
+{
+  for (;;) {
+    double u = rb_random_real(random);
+    if (u != 0.0) return u;
+  }
+}
+
+#define MASK(bits) (~(~0<<(bits)))
+#define BIT(nth) (1<<(nth))
+
+#define MAX2(n, m) (((n) < (m)) ? (m) : (n))
+#define MIN2(n, m) (((n) < (m)) ? (n) : (m))
+

data/ext/randomext_native.c

@@ -0,0 +1,76 @@
+#include "randomext.h"
+
+#define SUMLOG_TABLE_SIZE_INIT 1024
+#define SUMLOG_TABLE_SIZE_MAX (1024*32)
+
+/* sumlog_table[0] = 0 */
+/* sumlog_table[i] = log(1) + log(2) + ... + log(i) */
+static double* sumlog_table = NULL;
+static int sumlog_table_size = -1;
+
+static inline void setup_sumlog_table(int need)
+{
+  int old_sumlog_table_size;
+  int i;
+  
+  if (sumlog_table_size > need || need >= SUMLOG_TABLE_SIZE_MAX)
+    return;
+  
+  if (sumlog_table == NULL) {
+    sumlog_table_size = SUMLOG_TABLE_SIZE_INIT;
+    sumlog_table = ALLOC_N(double, sumlog_table_size);
+    sumlog_table[0] = 0;
+    old_sumlog_table_size = 1;
+  } else {
+    old_sumlog_table_size = sumlog_table_size;
+  }
+  
+  for (;sumlog_table_size < need; sumlog_table_size <<= 1)
+    ;
+
+  REALLOC_N(sumlog_table, double, sumlog_table_size);
+
+  for (i = old_sumlog_table_size; i < sumlog_table_size; ++i) {
+    sumlog_table[i] = sumlog_table[i-1] + log(i);
+  }
+}
+
+double randomext_sumlog(int from, int to)
+{
+  int i;
+  double ret = 0.0;
+
+  setup_sumlog_table(to);
+  if (to < SUMLOG_TABLE_SIZE_MAX)
+    return sumlog_table[to] - sumlog_table[from-1];
+  
+  for (i=from; i<=to; ++i)
+    ret += log(i);
+  return ret;
+}
+
+double randomext_logcombination(int n, int m)
+{
+  return randomext_sumlog(n-m+1, n) - randomext_sumlog(1, m);
+}
+
+extern void randomext_standard_normal_init(VALUE cRandom);
+extern void randomext_standard_exponential_init(VALUE cRandom);
+extern void randomext_gamma_init(VALUE cRandom);
+extern void randomext_binomial_init(VALUE cRandom);
+extern void randomext_poisson_init(VALUE cRandom);
+extern void randomext_hypergeometric_init(VALUE cRandom);
+extern void randomext_other_init(VALUE cRandom);
+
+void Init_randomext_native()
+{
+  VALUE cRandom = rb_const_get(rb_cObject, rb_intern("Random"));
+  
+  randomext_standard_normal_init(cRandom);
+  randomext_standard_exponential_init(cRandom);
+  randomext_gamma_init(cRandom);
+  randomext_binomial_init(cRandom);
+  randomext_poisson_init(cRandom);
+  randomext_hypergeometric_init(cRandom);
+  randomext_other_init(cRandom);
+}

data/ext/standard_exponential.c

@@ -0,0 +1,79 @@
+#include "randomext.h"
+
+#define K 8
+#define n (1<<K)
+#define v 0.00394965982258
+#define r 7.697117470131
+#define m 64
+
+static double* w = NULL;
+static double* f;
+static uint64_t* k;
+
+void init_exponentail_table(void)
+{
+  double xi;
+  int i;
+  
+  w = ALLOC_N(double, n);
+  f = ALLOC_N(double, n);
+  k = ALLOC_N(uint64_t, n);
+
+  w[n-1] = v*exp(r)/pow2(m-K);
+  w[n-2] = r/pow2(m-K);
+  k[n-1] = floor(r/w[n-1]);
+  f[n-1] = exp(-r);
+  xi = r;
+  
+  for (i=n-2; i >= 1; --i) {
+    xi = -log(exp(-xi) + v/xi);
+    w[i-1] = xi/pow2(m-K);
+    k[i] = floor(xi/w[i]);
+    f[i] = exp(-xi);
+  }
+  k[0] = 0;
+  f[0] = 1;
+}
+
+static double standard_exponential(VALUE rng)
+{
+  uint32_t u1; 
+  uint32_t i; 
+  uint64_t u2; 
+
+  if (w == NULL)
+    init_exponentail_table();
+  
+retry:
+  u1 = rb_random_int32(rng);
+  i = MASK(K) & u1;
+  u2 = (uint64_t)rb_random_int32(rng) | (((uint64_t)u1 >> K) << 32);
+  
+  if (u2 < k[i])
+    return (double)u2 * w[i];
+  if (i == n-1) {
+    double u = rb_random_real(rng);
+    return r - log(1-u);
+  } else {
+    double ux = u2*w[i];
+    double u = rb_random_real(rng);
+    if (u*(f[i]-f[i+1]) <= exp(-ux) - f[i+1])
+      return ux;
+    goto retry;
+  }
+}
+
+/*
+ * Draws a random sample from the standard exponential distribution.
+ *
+ * @return [Float] a random sample
+ */
+static VALUE random_standard_exp(VALUE self)
+{
+  return DBL2NUM(standard_exponential(self));
+}
+
+void randomext_standard_exponential_init(VALUE cRandom)
+{
+  rb_define_method(cRandom, "standard_exponential", random_standard_exp, 0);
+}

data/ext/standard_normal.c

@@ -0,0 +1,94 @@
+#include "randomext.h"
+
+#define R 3.442619855899
+#define V 9.91256303526217e-3
+#define K 7
+#define M 64
+#define N (1<<K)
+
+static double* w = NULL;
+static uint64_t* k;
+static double* f;
+
+inline static double sn(double x)
+{
+  return exp(-x*x/2);
+}
+
+static void init_snormal_table(void)
+{
+  int i;
+  double xi;
+  
+  w = ALLOC_N(double, N);
+  k = ALLOC_N(uint64_t, N);
+  f = ALLOC_N(double, N);
+  
+  w[N-1] = V*exp(R*R/2)/pow2(M-K-1);
+  w[N-2] = R/pow2(M-K-1);
+  k[N-1] = floor(R/w[N-1]);
+  f[N-1] = sn(R);
+  xi = R;
+  
+  for (i=N-2; i>=1; --i) {
+    xi = sqrt(-2*log(sn(xi)+V/xi));
+    w[i-1] = xi/pow2(M-K-1);
+    k[i] = floor(xi/w[i]);
+    f[i] = sn(xi);
+  }
+  k[0] = 0;
+  f[0] = 1;
+}
+
+static double sample_from_tail(VALUE random)
+{
+  for (;;) {
+    double x = sqrt(R*R-2*log(1-rb_random_real(random)));
+    if (x*rb_random_real(random) <= R)
+      return x;
+  }
+}
+
+double randomext_random_standard_normal(VALUE random)
+{
+  int i;
+  uint64_t u;
+  int sign;
+  double ux;
+
+  if (w == NULL)
+    init_snormal_table();
+  
+  for (;;) {
+    unsigned int u0 = rb_random_int32(random);
+    i = u0 & MASK(K);
+    sign = (u0 & BIT(K)) ? 1 : -1;
+    u = ((uint64_t)(u0 >> (K+1)) << 32) | rb_random_int32(random);
+
+    if (u < k[i])
+      return sign*(u*w[i]);
+    if (i == N-1)
+      return sign*sample_from_tail(random);
+    ux = u * w[i];
+    if ( rb_random_real(random)*(f[i]-f[i+1]) <= sn(ux)-f[i+1])
+      return sign*ux;
+  }
+
+}
+
+/*
+ * Draws a random sample from the standard normal distribution.
+ *
+ * Ziggurat method is used for random sampling.
+ * 
+ * @return [Float] a random sample 
+ */
+static VALUE random_standard_normal(VALUE self)
+{
+  return DBL2NUM(randomext_random_standard_normal(self));
+}
+
+void randomext_standard_normal_init(VALUE cRandom)
+{
+  rb_define_method(cRandom, "standard_normal", random_standard_normal, 0);
+}

data/lib/randomext.rb

@@ -0,0 +1,373 @@
+require 'randomext_native'
+
+class Random
+  # Draws a random sample from a normal(Gaussian) distribution.
+  #
+  # @param [Float] mean mean
+  # @param [Float] sd standard deviarion
+  # @return [Float] a random sample
+  def normal(mean=0.0, sd=1.0)
+    mean + standard_normal()*sd
+  end
+
+  # Draws a random sample from a log normal distribution.
+  #
+  # The probabilistic mass function of lognormal distribution is defined:
+  #
+  #     1/sqrt(2*PI*sigma**2)*exp(-(log(x)-mu)**2/(2*sigma**2))
+  #
+  # @param [Float] mu the mean in a normal distribution
+  # @param [Float] sigma the standard deviarion in a normal distribution
+  # @return [Float] a random sample in (0, INFINITY)
+  def lognormal(mu=0.0, sigma=1.0)
+    Math.exp(normal(mu, sigma))
+  end
+
+  # Draws a random sample from a Cauthy distribution.
+  #
+  # @param [Float] loc location parameter
+  # @param [Float] scale scale parameter
+  # @return [Float] a random sample
+  def cauthy(loc, scale)
+    loc + scale*standard_cauthy()
+  end
+
+  # Draws a random sample from the standard Cauthy distribution.
+  #
+  # Computed using Polar method from the standard normal distribution.
+  # @return [Float] a random sample
+  def standard_cauthy
+    y1 = standard_normal()
+    begin; y2 = standard_normal(); end until y2 != 0.0
+    return y1/y2
+  end
+
+  # Draws a random sample from a Levy distribution.
+  #
+  # @param [Float] loc location parameter
+  # @param [Float] scale scale parameter
+  # @return [Float] a random sample
+  def levy(loc=0.0, scale=1.0)
+    begin z = standard_normal.abs; end until z > 0
+    loc + scale/z**2
+  end
+
+  # Draws a random sample from a exponential distribution.
+  #
+  # Inverse function method is used.
+  # @param [Float] scale scale parameter (scale > 0)
+  # @return [Float] a random sample
+  def exponential(scale=1.0)
+    if scale < 0.0
+      raise ArgumentError, "Random#exponential: scale parameter must be positive"
+    end
+    scale * standard_exponential
+  end
+
+  # Draws a random sample from a Laplace distribution
+  #
+  # @param [Float] loc location parameter
+  # @param [Float] scale scale parameter
+  # @return [Float] a random sample
+  def laplace(loc=0.0, scale=1.0)
+    sign = rand(2) == 1 ? 1 : -1
+    loc + sign*scale*standard_exponential
+  end
+
+  # Draws a random sample from a Rayleigh distribution
+  #
+  # @param [Float] sigma scale parameter
+  # @return [Float] a random sample
+  def rayleigh(sigma=1.0)
+    sigma*Math.sqrt(2*standard_exponential)
+  end
+
+  # Draws a random sample from a Weibull distribution
+  #
+  # @param [Float] g shape parameter (g > 0.0)
+  # @param [Float] mu scale parameter 
+  # @return [Float] a random sample
+  def weibull(g, mu=1.0)
+    if g <= 0
+      raise ArgumentError, "Random#weibull: shape parameter must be positive"
+    end
+    mu * standard_exponential**(1.0/g)
+  end
+
+  # Draws a random sample from a Gumbel distribution
+  #
+  # @param [Float] loc location parameter
+  # @param [Float] scale scale parameter
+  # @return [Float] a random sample
+  def gumbel(loc=0.0, scale=1.0)
+    loc - scale * Math.log(standard_exponential)
+  end
+  
+  # Draws a random sample from a gamma distribution
+  #
+  # @param [Float] shape shape parameter (shape > 0.0)
+  # @param [Float] scale scale parameter (scale > 0.0)
+  # @return [Float] a random sample
+  def gamma(shape, scale=1.0)
+    if scale <= 0.0
+      raise ArgumentError, "Random#gamma: scale parameter must be positive"
+    end
+    
+    case
+    when shape <= 0.0
+      raise ArgumentError, "Random#gamma: shape parameter must be positive"
+    when shape > 1.0
+      scale * _gamma(shape)
+    when shape == 1.0
+      exponential(scale)
+    when shape < 1.0
+      scale*_gamma(shape+1)*rand_open_interval**(1.0/shape)
+    end
+  end
+
+  # Draws a random sample from a beta distribution.
+  #
+  # @param [Float] alpha a shape parameter (alpha > 0.0)
+  # @param [Float] beta another shape parameter (beta > 0.0)
+  # @return [Float] a random sample
+  def beta(alpha, beta)
+    y1 = gamma(alpha); y2 = gamma(beta)
+    y1/(y1+y2)
+  end
+
+  # Draws a random sample from a Dirichlet distribution.
+  #
+  # @param [Array<Float>] as shape parameters
+  # @return [Array<Float>] a random sample in the (K-1)-dimensional simplex (K == as.size)
+  def dirichlet(*as)
+    if as.any?{|a| a <= 0.0}
+      raise ArgumentError, "Random#dirichlet: parameters must be positive"
+    end
+
+    ys = as.map{|a| gamma(a) }
+    sum = ys.inject(0.0, &:+)
+    ys.map{|y| y/sum }
+  end
+  
+  # Draws a random sample from a power function distribution
+  #
+  # @param [Float] shape shape parameter (shape > 0.0)
+  # @param [Float] a lower boundary parameter
+  # @param [Float] b upper boundary parameter (a < b)
+  # @return [Float] a random sample
+  def power(shape, a, b)
+    if shape <= 0 || a >= b
+      raise ArgumentError, "Random#power: shape must be positive, and b should be greater than a"
+    end
+    
+    a + (b-a)*(rand_open_interval**(1/shape))
+  end
+  # Draw a random sample from a chi_square distribution.
+  #
+  # @param [Integer] r degree of freedom (r >= 1)
+  # @return [Float] a random sample
+  def chi_square(r)
+    if r == 1
+      standard_normal ** 2
+    elsif r > 1
+      gamma(r*0.5, 2)
+    else
+      raise ArgumentError, "Random#chi_square:r (degree of freedom) must be >= 1"
+    end
+  end
+
+  # Draws a random sample from a F distribution.
+  #
+  # @param [Integer] r1 degree of freedom (r1 >= 1)
+  # @param [Integer] r2 degree of freedom (r2 >= 1)
+  # @return [Float] a random sample
+  def F(r1, r2)
+    f = r2 / r1.to_f
+    f*chi_square(r1)/chi_square(r2)
+  end
+
+  # Draws a random sample from a t distribution.
+  #  
+  # @param [Integer] r degree of freedom (r >= 1)
+  # @return [Float] a random sample
+  def t(r)
+    if r ==1
+      standard_cauthy
+    elsif r == 2
+      standard_normal/Math.sqrt(exponential(1))
+    elsif r > 2
+      rdiv2 = r/2.0
+      Math.sqrt(rdiv2)*standard_normal/Math.sqrt(_gamma(rdiv2))
+    else
+      raise ArgumentError, "Random#t: r (degree of freedom) must be >= 1"
+    end
+  end
+
+  # Draws a random sample from a wald distribution.
+  #
+  # A wald distribution is also called an inverse Gaussian distribution.
+  #
+  # @param [Float] mean mean
+  # @param [Float] shape shape parameter (shape > 0.0)
+  # @return [Float] a random sample in (0, INFINITY)
+  def wald(mean, shape)
+    if shape <= 0.0
+      raise ArgumentError, "Random#wald: shape parameter must be positive"
+    end
+    p = mean**2
+    q = p/(2*shape)
+    z = standard_normal
+    return mean if z == 0.0
+    v = mean + q*z**2
+    x1 = v + Math.sqrt(v**2-p)
+    return x1 if rand*(x1 + mean) <= mean
+    return p/x1
+  end
+  
+  # Draws a random sample from a Pareto distribution.
+  #
+  # The probabilistic mass function for the distribution is defined as:
+  #
+  #     p(x) = a*b**a/x**(a+1)
+  #
+  # @param [Float] a shape parameter (a > 0.0)
+  # @param [Float] b scale parameter (b > 0.0)
+  # @return [Float] a random sample in [b, INFINITY)
+  def pareto(a, b=1.0)
+    if a <= 0 || b <= 0
+      raise ArgumentError, "Random#pareto: parameters a and b must be positive"
+    end
+    b * (1.0 - rand)**(-1/a)
+  end
+  
+  # Draws a random sample from a logistic distribution.
+  #
+  # @param [Float] mu the location parameter
+  # @param [Float] theta the scale parameter
+  # @return [Float] a random sample
+  def logistic(mu, theta)
+    u = rand_open_interval
+    mu + theta*log(u/(1-u))
+  end
+
+  # Draws a random sample from a Non-Central Chi-Square distribution.
+  #
+  # @param [Integer] r a parameter (r > 0)
+  # @param [Float] lambda another parameter (lambda > 0)
+  # @return [Float] a random sample in (0, INFINITY)
+  def non_central_chi_square(r, lambda)
+    if lambda < 0.0
+      raise ArgumentError, "Random#non_central_chi_square: lambda must be positive"
+    end
+    if !r.integer? || r <= 0
+      raise ArgumentError, "Random#non_central_chi_square: r must be positive integer"
+    end
+    j = poisson(lambda/2)
+    chi_square(r + 2*j)
+  end
+
+  # Draws a random sample from a Non-Central t distribution
+  #
+  # @param [Integer] r a parameter (r > 0)
+  # @param [Float] lambda another parameter (lambda > 0)
+  # @return [Float] a random sample
+  def non_central_t(r, lambda)
+    if lambda == 0.0
+      raise ArgumentError, "Random#non_central_t: lambda must not be 0"
+    end
+
+    if r == 1
+      z = standard_normal + lambda
+      w = standard_normal.abs
+      z/w
+    elsif r == 2
+      z = standard_normal + lambda
+      w = standard_exponential
+      z/Math.sqrt(w)
+    elsif r > 2
+      d = Math.sqrt(r/2.0)
+      z = standard_normal + lambda
+      w = _gamma(r/2.0)
+      d*z/Math.sqrt(w)
+    else
+      raise ArgumentError, "Random#non_central_t: r must be positive"
+    end
+  end
+  
+  # Draw a random sample from a Bernoulli distribution.
+  #
+  # @param [Float] p the probability returning 1
+  # @return [Integer] a random sample, 0 or 1
+  def bernoulli(p)
+    (rand < p) ? 1 : 0
+  end
+
+  # Draws a random sample from a geometric distribution.
+  #
+  # @param [Float] theta the probability of sucess (0 < theta < 1)
+  # @return [Integer] a random sample in [1, INFINITY)
+  def geometric(theta)
+    if theta <= 0.0 || theta >= 1.0
+      raise ArgumentError, "Random#geometric: theta should be in (0, 1)"
+    end
+    
+    d= -1/(Math.log(1-theta))
+    (d * standard_exponential).floor + 1
+  end
+
+  # Draws a random sample from a Planck distribution.
+  #
+  # @param [Float] a shape parameter
+  # @param [Float] b scale parameter
+  # @return [Float] a random sample in (0, INFINITY)
+  def planck(a, b)
+    if a <= 0 || b <= 0
+      raise ArgumentError, "Random#planck: parameters must be positive"
+    end
+    
+    y = _gamma(a+1)
+    j = zeta(a+1)
+    b*y/j
+  end
+  
+  # Draws a random sample from a negative binomial distribution.
+  #
+  # @param [Float] r s parameter (0 < r)
+  # @param [Float] theta a parameter (0 < theta < 1)
+  # @return [Integer] a random sample in [0, INFINITY)
+  def negative_binomial(r, theta)
+    if r <= 0.0
+      raise ArgumentError, "Random#negative_binomial: r must be positive"
+    end
+    if theta <= 0.0 && theta >= 1.0
+      raise ArgumentError, "Random#negative_binomial: theta must be in (0, 1)"
+    end
+    poisson(gamma(r, 1/theta - 1))
+  end
+
+  # Draws a random sample from a log series distribution.
+  #
+  # @param [Float] theta a parameter (0 < theta < 1)
+  # @return [Integer] a random sample in [0, INFINITY)
+  def logseries(theta)
+    if theta <= 0 || 1 <= theta
+      raise ArgumentError, "Random#logseries: theta must be in (0, 1)"
+    end
+    q = 1 - theta
+    v = rand_open_interval
+    if v >= theta
+      1
+    else
+      u = rand_open_interval
+      (log(v)/log(1-q**u)).ceil
+    end
+  end
+  
+  # Draw a sample from the uniform distribution on (0, 1)
+  #
+  # @return [Float] a random sample in (0, 1)
+  def rand_open_interval
+    begin; x = rand; end until x != 0.0
+    x
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: randomext
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Ippei Obayashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-14 00:00:00.000000000 Z
+dependencies: []
+description: ! "This library extends class Random in the Ruby standard library.\nThe
+  Random class in the Ruby standard library supports only \nrandom sampling from discrete/continuous
+  uniform distribution.\n\nThis library provides random sampling methods from \nmany
+  kinds of probability distributions such as normal, gamma,\nbeta, chi_square, t,
+  F, binomial, Poisson, and many other\ndistributions.\n"
+email: ohai@kmc.gr.jp
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/randomext.rb
+- ext/extconf.rb
+- ext/standard_exponential.c
+- ext/randomext.h
+- ext/other.c
+- ext/hypergeometric.c
+- ext/randomext_native.c
+- ext/poisson.c
+- ext/binomial.c
+- ext/gamma.c
+- ext/standard_normal.c
+homepage: http://www.kmc.gr.jp/~ohai/randomext/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: This library extend Random class of Ruby standard library
+test_files: []