randomext 0.1 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5b23ad8095b3b5d4a95d99892b179002f3f639a7
+  data.tar.gz: b28e03eb8da6adb9325c0907110c323ba58b94c9
+SHA512:
+  metadata.gz: 5a3e55f905a6a9d9161a4991a88b6d1775fe10677373bb69cfacccfd4b1cf1b92def5e247a8212e03e6ade47364f5b4f4fa91e78eab94faafb55b0accbaa2fd2
+  data.tar.gz: ea89f943c1b2d18d1794fe913b5ef1e4216509b7904a7ac142518b1a4d1497c78d54264e82f1904de83d161f0c069b7b260d7fc1b7a8e3dbe33fcb785bc502eb

data/ext/binomial.c

@@ -1,5 +1,20 @@
 #include "randomext.h"
 
+/*
+ * Document-class: Random::Binomial
+ *
+ * A random sampler from the binoial 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}.
+ *
+ */
 typedef struct {
   int n;
   double theta;
@@ -54,8 +69,8 @@ static void check_binomial_params(int n, double theta, const char* method_name)
  * 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)
+ *   @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)
@@ -137,7 +152,6 @@ static void fill_binomial_VK_table(binomial_t *bin, double ntheta[])
 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);
@@ -145,7 +159,6 @@ static void fill_binomial_T_VT_table(binomial_t *bin)
   
   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];
@@ -200,19 +213,10 @@ static VALUE binomial_alloc(VALUE klass)
 /*
  * 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)
+ *   @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)
@@ -265,7 +269,8 @@ static VALUE binomial_rand(VALUE self)
 }
 
 /*
- * @!attribute [r] n
+ * Returns the parameter n, the number of trials.
+ *
  * @return [Integer] the parameter n
  */
 static VALUE binomial_n(VALUE self)
@@ -277,7 +282,8 @@ static VALUE binomial_n(VALUE self)
 }
 
 /*
- * @!attribute [r] theta
+ * Returns the parameter theta, the success probability.
+ *
  * @return [Float] the parameter theta
  */
 static VALUE binomial_theta(VALUE self)
@@ -288,27 +294,6 @@ static VALUE binomial_theta(VALUE self)
   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);
@@ -319,5 +304,4 @@ void randomext_binomial_init(VALUE cRandom)
   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/hypergeometric.c

@@ -26,9 +26,9 @@ static inline double hypergeometric_distribution(int x, int N, int M, int n)
  * 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)
+ *   @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)

data/ext/other.c

@@ -6,9 +6,9 @@
  * 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]
+ *   @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)
 {
@@ -53,10 +53,10 @@ static VALUE random_vonmises(VALUE self, VALUE vmu, VALUE vkappa)
  * 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
+ *   @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)
 {
@@ -94,7 +94,7 @@ static VALUE random_zipf(int argc, VALUE *argv, VALUE self)
  * Draws a random sample from a zeta distribution.
  *
  * @overload zeta(s)
- * @param [Integer] s a parameter (s > 0.0)
+ *   @param [Integer] s a parameter (s > 0.0)
  * @return [Integer] a random sample in [1, INFINITY)
  */
 static VALUE random_zeta(VALUE self, VALUE vs)

data/ext/poisson.c

@@ -23,7 +23,7 @@ static inline double backward_ratio(int x, double lambda)
  * Inverse function method is used.
  *
  * @overload poisson(lambda)
- * @param [Float] lambda mean
+ *   @param [Float] lambda mean
  * @return [Integer] a random sample in [0, INFINITY)
  */
 static VALUE random_poisson_inv(VALUE self, VALUE l)

data/ext/standard_normal.c

@@ -6,40 +6,13 @@
 #define M 64
 #define N (1<<K)
 
-static double* w = NULL;
-static uint64_t* k;
-static double* f;
+#include "standard_normal_table.h"
 
 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 (;;) {
@@ -56,9 +29,6 @@ double randomext_random_standard_normal(VALUE random)
   int sign;
   double ux;
 
-  if (w == NULL)
-    init_snormal_table();
-  
   for (;;) {
     unsigned int u0 = rb_random_int32(random);
     i = u0 & MASK(K);

data/ext/standard_normal_table.h

@@ -0,0 +1,392 @@
+static double w[N] = {
+  3.779211177528728e-18,
+  5.035852722282574e-18,
+  5.919542444491104e-18,
+  6.625780997425304e-18,
+  7.225554026797095e-18,
+  7.753411501834412e-18,
+  8.22901389351605e-18,
+  8.66471612981438e-18,
+  9.068837885372816e-18,
+  9.447275165901862e-18,
+  9.804374136660416e-18,
+  1.0143440402100701e-17,
+  1.046705311944029e-17,
+  1.0777267798949829e-17,
+  1.1075752268719609e-17,
+  1.1363880762787455e-17,
+  1.164280081091786e-17,
+  1.1913481912009988e-17,
+  1.2176751677985312e-17,
+  1.2433323156881527e-17,
+  1.2683815817413517e-17,
+  1.2928771894948216e-17,
+  1.3168669287123936e-17,
+  1.3403931845028942e-17,
+  1.3634937672194328e-17,
+  1.386202588123086e-17,
+  1.408550214314811e-17,
+  1.4305643282033703e-17,
+  1.452270110785588e-17,
+  1.4736905636009493e-17,
+  1.494846780931835e-17,
+  1.5157581813408613e-17,
+  1.5364427057490915e-17,
+  1.5569169878084408e-17,
+  1.57719650119731e-17,
+  1.5972956875899105e-17,
+  1.6172280683578905e-17,
+  1.6370063425141637e-17,
+  1.6566424729707162e-17,
+  1.6761477628301348e-17,
+  1.6955329231460542e-17,
+  1.7148081333564528e-17,
+  1.7339830954047733e-17,
+  1.7530670824087173e-17,
+  1.772068982608615e-17,
+  1.7909973392213292e-17,
+  1.8098603867375507e-17,
+  1.8286660841268705e-17,
+  1.8474221453535323e-17,
+  1.8661360675541846e-17,
+  1.8848151571856147e-17,
+  1.9034665544139553e-17,
+  1.922097255986149e-17,
+  1.94071413679859e-17,
+  1.959323970356166e-17,
+  1.9779334482967482e-17,
+  1.996549199141056e-17,
+  2.015177806415392e-17,
+  2.0338258262846282e-17,
+  2.052499804824809e-17,
+  2.071206295058628e-17,
+  2.0899518738726243e-17,
+  2.108743158932197e-17,
+  2.127586825709298e-17,
+  2.146489624737944e-17,
+  2.1654583992144607e-17,
+  2.1845001030626488e-17,
+  2.203621819588908e-17,
+  2.2228307808588562e-17,
+  2.2421343879352476e-17,
+  2.2615402321272053e-17,
+  2.2810561174131224e-17,
+  2.3006900842143298e-17,
+  2.3204504347140732e-17,
+  2.3403457599368684e-17,
+  2.360384968827396e-17,
+  2.3805773195962715e-17,
+  2.4009324536330014e-17,
+  2.421460432324996e-17,
+  2.4421717771666483e-17,
+  2.4630775135954096e-17,
+  2.4841892190539375e-17,
+  2.5055190758505437e-17,
+  2.527079929476491e-17,
+  2.548885353140859e-17,
+  2.5709497194049845e-17,
+  2.5932882799429966e-17,
+  2.6159172546277296e-17,
+  2.6388539313487046e-17,
+  2.6621167782188563e-17,
+  2.6857255701293365e-17,
+  2.7097015319798532e-17,
+  2.7340675013619677e-17,
+  2.7588481140256304e-17,
+  2.7840700161422706e-17,
+  2.809762108226512e-17,
+  2.835955826639796e-17,
+  2.8626854699347176e-17,
+  2.889988578991277e-17,
+  2.917906382056743e-17,
+  2.946484318580545e-17,
+  2.9757726593421176e-17,
+  3.0058272450907446e-17,
+  3.0367103721563165e-17,
+  3.068491861822208e-17,
+  3.101250361502133e-17,
+  3.1350749411368486e-17,
+  3.170067069509885e-17,
+  3.206343085064238e-17,
+  3.2440373184106596e-17,
+  3.283306085507585e-17,
+  3.324332861780275e-17,
+  3.3673350851217557e-17,
+  3.412573248168003e-17,
+  3.460363276607498e-17,
+  3.511093738513032e-17,
+  3.565250353172647e-17,
+  3.623451883582939e-17,
+  3.686504450680305e-17,
+  3.75548699516312e-17,
+  3.831892265142546e-17,
+  3.9178734569779584e-17,
+  4.0167091972264215e-17,
+  4.1337714538177976e-17,
+  4.2788395857263743e-17,
+  4.472928950257001e-17,
+  4.777594786313511e-17,
+  5.1529423044407315e-17,
+};
+
+static uint64_t k[N] = {
+  0,
+  54076415620536904,
+  61300587756530160,
+  64377012539529264,
+  66076294707096096,
+  67151864522975000,
+  67892968177924664,
+  68434202989192568,
+  68846593712197952,
+  69171123658870632,
+  69433082538507880,
+  69648914306148520,
+  69829769879067288,
+  69983476194917440,
+  70115687770302160,
+  70230590878559368,
+  70331350677449488,
+  70420404420292040,
+  70499659178058240,
+  70570628466878520,
+  70634528715794040,
+  70692348697106704,
+  70744900361805480,
+  70792856639540568,
+  70836779941489144,
+  70877143927839008,
+  70914350325727000,
+  70948742062233352,
+  70980613620876648,
+  71010219282873288,
+  71037779740400504,
+  71063487444945400,
+  71087510964150584,
+  71109998555058080,
+  71131081113284408,
+  71150874621589976,
+  71169482194156344,
+  71186995792270104,
+  71203497671331240,
+  71219061606927376,
+  71233753938254240,
+  71247634459757496,
+  71260757186039240,
+  71273171010449816,
+  71284920274100840,
+  71296045259079904,
+  71306582617266824,
+  71316565744221304,
+  71326025106040584,
+  71334988525801840,
+  71343481435146536,
+  71351527095693856,
+  71359146794246632,
+  71366360015153064,
+  71373184592683680,
+  71379636845862160,
+  71385731697832616,
+  71391482781545128,
+  71396902533285504,
+  71402002275357128,
+  71406792289034624,
+  71411281878747928,
+  71415479428314056,
+  71419392449911592,
+  71423027626383784,
+  71426390847360208,
+  71429487239599328,
+  71432321191875536,
+  71434896374660288,
+  71437215754778184,
+  71439281605151936,
+  71441095509685592,
+  71442658363269824,
+  71443970366826712,
+  71445031017241888,
+  71445839091957312,
+  71446392627917936,
+  71446688894475496,
+  71446724359753304,
+  71446494649861640,
+  71445994500222504,
+  71445217698110208,
+  71444157015336032,
+  71442804129794104,
+  71441149534335072,
+  71439182431133664,
+  71436890609354568,
+  71434260303482624,
+  71431276029149600,
+  71427920392635256,
+  71424173869414824,
+  71420014546126464,
+  71415417819088288,
+  71410356040935128,
+  71404798104978112,
+  71398708954393280,
+  71392049000153288,
+  71384773427507192,
+  71376831365482520,
+  71368164886913096,
+  71358707797302752,
+  71348384158599168,
+  71337106477510176,
+  71324773465667520,
+  71311267248289504,
+  71296449855397552,
+  71280158769685808,
+  71262201219561744,
+  71242346781854352,
+  71220317675959912,
+  71195775857061400,
+  71168305596529440,
+  71137389581305912,
+  71102375511978928,
+  71062428446027928,
+  71016461188283864,
+  70963029851113296,
+  70900172224299768,
+  70825148412611304,
+  70734006393383296,
+  70620815666934008,
+  70476226522053056,
+  70284534227628608,
+  70017030195232984,
+  69614581079045472,
+  68930870409638744,
+  67462502132127024,
+  66808818195620008,
+};
+
+static double f[N] = {
+  1.0,
+  0.9635996931270862,
+  0.9362826816850596,
+  0.9130436479717402,
+  0.8922816507840261,
+  0.8732430489100695,
+  0.8555006078694506,
+  0.8387836052959896,
+  0.822907211381409,
+  0.8077382946829605,
+  0.7931770117713051,
+  0.7791460859296877,
+  0.7655841738977045,
+  0.7524415591746114,
+  0.7396772436726473,
+  0.7272569183441848,
+  0.7151515074104986,
+  0.7033360990161581,
+  0.6917891434366751,
+  0.6804918409973341,
+  0.6694276673488904,
+  0.658582000050088,
+  0.6479418211102225,
+  0.6374954773350423,
+  0.6272324852499273,
+  0.6171433708188809,
+  0.6072195366251203,
+  0.5974531509445167,
+  0.5878370544347066,
+  0.5783646811197631,
+  0.5690299910679509,
+  0.5598274127040869,
+  0.5507517931146045,
+  0.5417983550254255,
+  0.5329626593838361,
+  0.5242405726729841,
+  0.5156282382440018,
+  0.507122051075569,
+  0.4987186354709795,
+  0.4904148252838441,
+  0.4822076463294852,
+  0.47409430069301695,
+  0.4660721526894561,
+  0.45813871626787206,
+  0.4502916436820392,
+  0.44252871527546844,
+  0.4348478302499909,
+  0.4272469983049961,
+  0.4197243320495744,
+  0.412278040102661,
+  0.40490642080722294,
+  0.3976078564938733,
+  0.3903808082373146,
+  0.3832238110559012,
+  0.3761354695105626,
+  0.3691144536644722,
+  0.3621594953693176,
+  0.3552693848479171,
+  0.3484429675463266,
+  0.3416791412315504,
+  0.3349768533135892,
+  0.3283350983728503,
+  0.3217529158759849,
+  0.3152293880650109,
+  0.3087636380061811,
+  0.30235482778648354,
+  0.296002156846933,
+  0.28970486044295984,
+  0.283462208223233,
+  0.2772735029191881,
+  0.2711380791383846,
+  0.2650553022555892,
+  0.25902456739620483,
+  0.25304529850732577,
+  0.2471169475123214,
+  0.24123899354543982,
+  0.23541094226347908,
+  0.22963232523211613,
+  0.22390269938500842,
+  0.2182216465543054,
+  0.2125887730717303,
+  0.20700370943992652,
+  0.20146611007431367,
+  0.19597565311627774,
+  0.19053204031913715,
+  0.1851349970089922,
+  0.17978427212329545,
+  0.1744796383307895,
+  0.169220892237365,
+  0.16400785468342038,
+  0.1588403711394793,
+  0.15371831220818166,
+  0.14864157424234226,
+  0.14361008009062776,
+  0.1386237799845946,
+  0.13368265258343937,
+  0.1287867061959432,
+  0.12393598020286782,
+  0.11913054670765083,
+  0.11437051244886601,
+  0.10965602101484027,
+  0.10498725540942132,
+  0.10036444102865587,
+  0.09578784912173144,
+  0.09125780082683026,
+  0.08677467189478018,
+  0.08233889824223566,
+  0.0779509825139734,
+  0.0736115018841134,
+  0.06932111739357791,
+  0.06508058521306807,
+  0.060890770348040406,
+  0.05675266348104985,
+  0.05266740190305101,
+  0.048636295859867805,
+  0.044660862200491425,
+  0.040742868074444175,
+  0.0368843887866562,
+  0.03308788614622575,
+  0.02935631744000685,
+  0.02569329193593427,
+  0.022103304615927098,
+  0.018592102737011288,
+  0.015167298010546568,
+  0.011839478657884862,
+  0.008624484412859885,
+  0.005548995220771345,
+  0.002669629083880923,
+};

metadata

@@ -1,17 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: randomext
 version: !ruby/object:Gem::Version
-  version: '0.1'
-  prerelease: 
+  version: 0.1.1
 platform: ruby
 authors:
 - Ippei Obayashi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-14 00:00:00.000000000 Z
+date: 2015-12-17 00:00:00.000000000 Z
 dependencies: []
-description: ! "This library extends class Random in the Ruby standard library.\nThe
+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,
@@ -22,39 +21,41 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
-- lib/randomext.rb
+- ext/binomial.c
 - ext/extconf.rb
-- ext/standard_exponential.c
-- ext/randomext.h
-- ext/other.c
+- ext/gamma.c
 - ext/hypergeometric.c
-- ext/randomext_native.c
+- ext/other.c
 - ext/poisson.c
-- ext/binomial.c
-- ext/gamma.c
+- ext/randomext.h
+- ext/randomext_native.c
+- ext/standard_exponential.c
 - ext/standard_normal.c
+- ext/standard_normal_table.h
+- lib/randomext.rb
 homepage: http://www.kmc.gr.jp/~ohai/randomext/
-licenses: []
+licenses:
+- BSD-2-Clause
+metadata: {}
 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
+rubygems_version: 2.4.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: This library extend Random class of Ruby standard library
 test_files: []
+has_rdoc: false