pcg_random 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e26f09fa3ea5290710f41975fcf1a22e4265e794
-  data.tar.gz: 792f5b3ffddb3c984d58aa93c8146443e7837682
+  metadata.gz: e613759fc11837de964926f2067b38d770100cd6
+  data.tar.gz: c72b3c2996301edeeb5084c5d785342219c99b59
 SHA512:
-  metadata.gz: 8bf992989aa751a8cd99dc153f78469dc3da4c16b6e2ec3e8dc8a8589aaa1407d0f78b42b9b1a33123ef6b0b83b3b700853afbac5bb23ccc9151e799cd8d7b92
-  data.tar.gz: 8addc87f54888e50b8bdeb08f6959da746054f5d8014c498842121596b6b0c64c314d1b5cd841fd650a97924cc6a69778cd2f36633428b1a352fd0f801ac73b4
+  metadata.gz: 9dd5e22f22437be3e1cf6fa105f984d12cda521462e284a14d373d1f7c3b45b029a07e84a099f2fdbc833e54fe0748dd69f05f972119fa015a6f7c8da5e1754c
+  data.tar.gz: ac91b8a84e7cdb204905fe05453d63fd7aa23900b3416a5dd60606938156e4a84e05dd9dcee033d18b34ce341096c713865dbff672227545dbefc687991b01e0

data/README.md

@@ -1,41 +1,113 @@
-# PcgRandom
+# PCGRandom
+[![Gem Version](https://badge.fury.io/rb/pcg_random.svg)](https://badge.fury.io/rb/pcg_random)
 
-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/pcg_random`. To experiment with that code, run `bin/console` for an interactive prompt.
+```
+ _____ _____ _____ _____           _           
+|  _  |     |   __| __  |___ ___ _| |___ _____ 
+|   __|   --|  |  |    -| .'|   | . | . |     |
+|__|  |_____|_____|__|__|__,|_|_|___|___|_|_|_|
+
+```
 
-TODO: Delete this and the text above, and describe your gem
+Ruby wrappers for the PCGRandom family of random number generators.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+### Prerequisites
 
-```ruby
-gem 'pcg_random'
-```
+* A C-compiler (any modern C compiler is supported on *nix, Windows isn't supported yet)
+* Modified C source code for pcg_random [available here](https://github.com/vaibhav-y/pcg-c/archive/master.zip) for building libpcg_random. 
+* Follow the build instructions [given here](https://github.com/vaibhav-y/pcg-c#building) to build `libpcg_random`
 
-And then execute:
+### Installing the gem:
 
-    $ bundle
+* Rubygems:
 
-Or install it yourself as:
+``` bash
+gem install pcg_random
+```
+
+You can also configure the path to `libpcg_random` by specifying it's path explicitly:
 
-    $ gem install pcg_random
+``` bash
+# specify the custome include path
+gem install pcg_random --with-pcg_random-include=directory/containing/pcg_variants.h
 
-## Usage
+# or, specify the custom path to the libpcg_random binary
+gem install pcg_random --with-pcg_random-lib=directory/containing/libpcg_random.a
 
-TODO: Write usage instructions here
+# Or, specify both the lib/ and include/ together to be under path/to/some/directory
+gem install pcg_random --with-pcg_random-dir=path/to/some/directory
+```
 
 ## Development
+`TODO: Create a CONTRIBTING.md`
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Install pcg_random *from source* using the above steps. Using the above links are important because the library must be compiled with additional flags to be used for gem-development. There are also some issues in the original repository that are addressed in my fork.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+## Using the extension
+
+Either jump into your REPL of choice:
+
+``` ruby
+~$ irb
+2.3.0 :001 > require 'pcg_random'
+ => true
+```
+
+Or go ahead and try the API, it's built to be as close to `Kernel::Random` as possible!
+
+``` ruby
+2.3.0 :002 > seed = PCGRanom.new_seed
+ => 315431527813695542666700950080169144774
+2.3.0 :003 > rng = PCGRanom.new 1234
+ => #<PCGRandom:0x00000001bf3eb0 @seed=1234>
+```
 
-## Contributing
+For detailed instructions, keep checking this repo, I'm working on getting a wiki up.
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/pcg_random.
 
+## Benchmarks
 
-## License
+### PCGRandom.new_seed
+```
+Benchmark of Random.new_seed vs PCGRandom.new_seed
+==================================================
+
+Benchmark created around: 2016-03-30 14:54:16 +0000
+
+Running for: 100000 iterations
+
+Rehearsal ------------------------------------------------------
+Random.new_seed      0.090000   1.240000   1.330000 (  1.323970)
+PCGRandom.new_seed   0.100000   1.150000   1.250000 (  1.254944)
+--------------------------------------------- total: 2.580000sec
+
+                         user     system      total        real
+Random.new_seed      0.110000   1.200000   1.310000 (  1.321571)
+PCGRandom.new_seed   0.100000   1.130000   1.230000 (  1.222634)
+```
+### PCGRandom.raw_seed(16)
+```
+Benchmark of Random.raw_seed(16) vs PCGRandom.raw_seed(16)
+==================================================
+
+Benchmark created around: 2016-03-30 14:41:26 +0000
+
+Running for: 100000 iterations
+
+Rehearsal ----------------------------------------------------------
+Random.raw_seed(16)      0.080000   1.440000   1.520000 (  1.515513)
+PCGRandom.raw_seed(16)   0.110000   1.320000   1.430000 (  1.444519)
+------------------------------------------------- total: 2.950000sec
+
+                             user     system      total        real
+Random.raw_seed(16)      0.080000   1.470000   1.550000 (  1.563351)
+PCGRandom.raw_seed(16)   0.090000   1.340000   1.430000 (  1.441253)
+```
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+## Roadmap
 
+* Achieve full parity with `Kernel::Random`
+* Get a wiki explaining how to go about using this gem
+* Showcase benchmarks in some other place

data/Rakefile

@@ -1,16 +1,14 @@
 require 'bundler/gem_tasks'
+require 'bundler'
 require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec)
-
 require "rake/extensiontask"
 
-task :build => :compile
+RSpec::Core::RakeTask.new(:spec)
 
 Rake::ExtensionTask.new("pcg_random") do |ext|
   ext.lib_dir = "lib/pcg_random"
 end
 
+task :build => :compile
 task :cc => [:clean, :compile]
-
 task :default => [:clobber, :compile, :spec]

data/benchmarks/new_seed.md

@@ -2,16 +2,16 @@
 Benchmark of Random.new_seed vs PCGRandom.new_seed
 ==================================================
 
-Benchmark created around: 2016-03-25 18:27:27 +0000
+Benchmark created around: 2016-03-30 14:54:16 +0000
 
 Running for: 100000 iterations
 
 Rehearsal ------------------------------------------------------
-Random.new_seed      0.120000   1.060000   1.180000 (  1.173928)
-PCGRandom.new_seed   0.070000   1.020000   1.090000 (  1.096108)
---------------------------------------------- total: 2.270000sec
+Random.new_seed      0.090000   1.240000   1.330000 (  1.323970)
+PCGRandom.new_seed   0.100000   1.150000   1.250000 (  1.254944)
+--------------------------------------------- total: 2.580000sec
 
                          user     system      total        real
-Random.new_seed      0.100000   1.090000   1.190000 (  1.188864)
-PCGRandom.new_seed   0.110000   1.090000   1.200000 (  1.197528)
+Random.new_seed      0.110000   1.200000   1.310000 (  1.321571)
+PCGRandom.new_seed   0.100000   1.130000   1.230000 (  1.222634)
 ```

data/benchmarks/raw_seed.md

@@ -2,16 +2,16 @@
 Benchmark of Random.raw_seed(16) vs PCGRandom.raw_seed(16)
 ==================================================
 
-Benchmark created around: 2016-03-25 18:27:35 +0000
+Benchmark created around: 2016-03-30 14:41:26 +0000
 
 Running for: 100000 iterations
 
 Rehearsal ----------------------------------------------------------
-Random.raw_seed(16)      0.040000   0.980000   1.020000 (  1.031410)
-PCGRandom.raw_seed(16)   0.050000   0.970000   1.020000 (  1.021024)
-------------------------------------------------- total: 2.040000sec
+Random.raw_seed(16)      0.080000   1.440000   1.520000 (  1.515513)
+PCGRandom.raw_seed(16)   0.110000   1.320000   1.430000 (  1.444519)
+------------------------------------------------- total: 2.950000sec
 
                              user     system      total        real
-Random.raw_seed(16)      0.090000   0.990000   1.080000 (  1.076778)
-PCGRandom.raw_seed(16)   0.060000   1.000000   1.060000 (  1.067268)
+Random.raw_seed(16)      0.080000   1.470000   1.550000 (  1.563351)
+PCGRandom.raw_seed(16)   0.090000   1.340000   1.430000 (  1.441253)
 ```

data/ext/pcg_random/pcg_random.c

@@ -1,172 +1,20 @@
 #include <ruby.h>
+#include <ruby/util.h>
 #include <stdbool.h>
 #include <stdint.h>
+#include <limits.h>
 #include <math.h>
 #include <pcg_variants.h>
 
 #include "pcg_random.h"
 #include "pcg_seed.h"
+#include "pcg_rng.h"
 
 VALUE rb_cPCGRandom;
 
-static void pcg_random_mark(void *ptr);
-static void pcg_random_free(void *rand_data);
-static size_t pcg_random_memsize(const void *ptr);
-static pcg_rb_rand_t *pcg_get_rand_type(VALUE obj);
-static VALUE pcg_random_alloc(VALUE klass);
-static VALUE pcg_func_init(int argc, VALUE *argv, VALUE self);
-static VALUE pcg_func_get_state(VALUE self);
-static VALUE pcg_func_get_seq(VALUE self);
-
-/*
- * Structure wrapping our rng's data type's GC related functions
- */
-static const rb_data_type_t pcg_rand_data_t = {
-     "pcg_random",
-    {
-        pcg_random_mark,
-        pcg_random_free,
-        pcg_random_memsize,
-    },
-};
-
-/*
- * Internal - Mark the internal seed value for garbage collection since a VALUE
- * inside a C struct is not marked by the GC automatically, and isn't freed
- * correctly either.
- */
-static void
-pcg_random_mark(void *ptr)
-{
-     rb_gc_mark(((pcg_rb_rand_t *) ptr)->seed.val);
-}
-
-/*
- * Internal - Free internal C-types in the `pcg_rb_rand_t` struct
- */
-static void
-pcg_random_free(void *rand_data)
-{
-    xfree(((pcg_rb_rand_t *) rand_data)->rng);
-    xfree((pcg_rb_rand_t *)(rand_data));
-}
-
-/*
- * Internal - Get the size of a valid pcg_rb_rand_t pointer
- *
- * @return the size of `pcg_rb_rand_t` struct if it is initialized correctly.
- *  0 if given a NULL pointer
- */
-static size_t
-pcg_random_memsize(const void *ptr)
-{
-    return ptr ? sizeof(pcg_rb_rand_t) : 0;
-}
-
-/*
- * Internal - Helper function to get a pointer to a pcg_rb_rand_t struct given
- * an instance of the `PCGRandom` class
- *
- * Returns an object wrapping a C struct, with default initializations
- */
-static pcg_rb_rand_t *
-pcg_get_rand_type(VALUE obj)
-{
-    pcg_rb_rand_t *ptr;
-    TypedData_Get_Struct(obj, pcg_rb_rand_t, &pcg_rand_data_t, ptr);
-    return ptr;
-}
-
-/*
- * Memory allocation function that is called by new before `initialize` is
- * The chain is similar to: `new -> allocate -> initialize`
- *
- * Returns an object wrapping a C struct, with default initializations
- */
-static VALUE
-pcg_random_alloc(VALUE klass)
-{
-    pcg_rb_rand_t *rand_data;
-    VALUE obj;
-    /*
-     * ISO C forbids braced-groups within expressions
-     * See: http://stackoverflow.com/questions/1238016/
-     */
-    obj = __extension__ TypedData_Make_Struct(klass, pcg_rb_rand_t, &pcg_rand_data_t, rand_data);
-
-    rand_data->seed.val     = INT2FIX(0);
-    rand_data->seed.state   = 0;
-    rand_data->seed.seq     = 0;
-    rand_data->rng          = ALLOC(pcg32_random_t);
-
-    return obj;
-}
-
-/*
- * Internal - Initialize the requested instance using a pre-allocated ruby
- * object (TypedStruct). Sets the instance variables and relevant accessor
- * methods where applicable.
- */
-static VALUE
-pcg_func_init(int argc, VALUE *argv, VALUE self)
-{
-    VALUE seed;
-    uint64_t cseeds[2];
-    pcg_rb_rand_t* rand_data = pcg_get_rand_type(self);
-
-    if(argc == 0)
-    {
-        seed = DEFAULT_SEED_VALUE;
-    }
-    else
-    {
-        rb_scan_args(argc, argv, "01", &seed);
-    }
-
-    rb_integer_pack(seed, (void *) cseeds, 2, sizeof(uint64_t), 0,
-        INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
-
-    rand_data->seed.val     = seed;
-    rand_data->seed.state   = cseeds[0];
-    rand_data->seed.seq     = cseeds[1];
-    pcg32_srandom_r(rand_data->rng, cseeds[0], cseeds[1]);
-
-    /* Add & set private instance variables */
-    rb_iv_set(self, "@seed", seed);
-    rb_iv_set(self, "state", LONG2NUM(rand_data->seed.state));
-    rb_iv_set(self, "sequence", LONG2NUM(rand_data->seed.seq));
-    return self;
-}
-
-/*
- * Internal - Private method to access internal rng state parameter
- * (Most significant word of seed)
- */
-static VALUE
-pcg_func_get_state(VALUE self)
-{
-    VALUE state;
-    state = rb_iv_get(self, "state");
-    return state;
-}
-
-/*
- * Internal - Private method to access internal rng state parameter
- * (Most significant word of seed)
- */
-static VALUE
-pcg_func_get_seq(VALUE self)
-{
-    VALUE seq;
-    seq = rb_iv_get(self, "sequence");
-    return seq;
-}
-
 void
 Init_pcg_random(void)
 {
-    /* Initializations */
-
     /* Constants / Classes */
     rb_cPCGRandom = rb_define_class("PCGRandom", rb_cObject);
 
@@ -176,18 +24,14 @@ Init_pcg_random(void)
     rb_define_singleton_method(rb_cPCGRandom, "new_seed", pcg_func_new_seed, 0);
     rb_define_singleton_method(rb_cPCGRandom, "raw_seed", pcg_func_raw_seed, 1);
 
-    /* Public instance methods */
+    /* Instance methods */
     rb_define_alloc_func(rb_cPCGRandom, pcg_random_alloc);
-    rb_define_attr(rb_cPCGRandom, "seed", 1, 0);
-    // rb_define_method(rb_cPCGRandom, "rand", pcg_func_rand, -1);
-    // rb_define_method(rb_cPCGRandom, "bytes", pcg_func_rand_bytes, 1);
-    // rb_define_method(rb_cPCGRandom, "initialize_copy", pcg_func_rand_copy, 1);
-    // rb_define_method(rb_cPCGRandom, "==", pcg_func_equal, 1);
-
-    /* Private instance methods */
     rb_define_method(rb_cPCGRandom, "initialize", pcg_func_init, -1);
-    // rb_define_private_method(rb_cPCGRandom, "marshal_dump", pcg_func_dump, 0);
-    // rb_define_private_method(rb_cPCGRandom, "marshal_load", pcg_func_load, 1);
-    rb_define_private_method(rb_cPCGRandom, "state", pcg_func_get_state, 0);
-    rb_define_private_method(rb_cPCGRandom, "sequence", pcg_func_get_seq, 0);
+    
+    rb_define_attr(rb_cPCGRandom, "seed", 1, 0);
+    
+    rb_define_method(rb_cPCGRandom, "rand", pcg_func_rand, -1);
+    rb_define_method(rb_cPCGRandom, "bytes", pcg_func_rand_bytes, 1);
+    
+    rb_define_method(rb_cPCGRandom, "==", pcg_func_eql, 1);
 }

data/ext/pcg_random/pcg_random.h

@@ -2,21 +2,7 @@
 #define PCG_RANDOM_H 1
 
 #include <ruby.h>
-#include <stdint.h>
 
 extern VALUE rb_cPCGRandom;
 
-struct pcg_rb_seed
-{
-    VALUE val;
-    uint64_t state;
-    uint64_t seq;
-};
-
-typedef struct
-{
-    struct pcg_rb_seed seed;
-    pcg32_random_t *rng;
-} pcg_rb_rand_t;
-
 #endif /* PCG_RANDOM_H */

data/ext/pcg_random/pcg_rng.c

@@ -0,0 +1,248 @@
+#include <ruby.h>
+#include <ruby/util.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <limits.h>
+#include <math.h>
+#include <pcg_variants.h>
+
+#include "pcg_random.h"
+#include "pcg_seed.h"
+#include "pcg_rng.h"
+
+VALUE rb_cPCGRandom;
+
+static void pcg_random_mark(void *ptr);
+static void pcg_random_free(void *rand_data);
+
+static size_t pcg_random_memsize(const void *ptr);
+
+static VALUE pcg_rb_float64_rand(pcg32_random_t *rng);
+
+/*
+ * Structure wrapping our rng's data type's GC related functions
+ */
+static const rb_data_type_t pcg_rand_data_t = {
+     "pcg_random",
+    {
+        pcg_random_mark,
+        pcg_random_free,
+        pcg_random_memsize,
+    },
+};
+
+/*
+ * Internal - Mark the internal seed value for garbage collection since a VALUE
+ * inside a C struct is not marked by the GC automatically, and isn't freed
+ * correctly either.
+ */
+static void
+pcg_random_mark(void *ptr)
+{
+     rb_gc_mark(((pcg_rb_rand_t *) ptr)->seed.val);
+}
+
+/*
+ * Internal - Free internal C-types in the `pcg_rb_rand_t` struct
+ */
+static void
+pcg_random_free(void *rand_data)
+{
+    xfree(((pcg_rb_rand_t *) rand_data)->rng);
+    xfree(rand_data);
+}
+
+/*
+ * Internal - Get the size of a valid pcg_rb_rand_t pointer
+ *
+ * @return the size of `pcg_rb_rand_t` struct if it is initialized correctly.
+ *  0 if given a NULL pointer
+ */
+static size_t
+pcg_random_memsize(const void *ptr)
+{
+    return ptr ? sizeof(pcg_rb_rand_t) : 0;
+}
+
+/*
+ * Internal - Helper function to get a pointer to a pcg_rb_rand_t struct given
+ * an instance of the `PCGRandom` class
+ *
+ * Returns an object wrapping a C struct, with default initializations
+ */
+pcg_rb_rand_t *
+pcg_get_rand_type(VALUE obj)
+{
+    pcg_rb_rand_t *ptr;
+    TypedData_Get_Struct(obj, pcg_rb_rand_t, &pcg_rand_data_t, ptr);
+    return ptr;
+}
+
+/*
+ * Memory allocation function that is called by `new` before `initialize` is
+ * The chain is similar to: `new -> allocate -> initialize`
+ *
+ * Returns an object wrapping a C struct, with default initializations
+ */
+VALUE
+pcg_random_alloc(VALUE klass)
+{
+    pcg_rb_rand_t *rand_data;
+    VALUE obj;
+    /*
+     * ISO C forbids braced-groups within expressions
+     * See: http://stackoverflow.com/questions/1238016/
+     */
+    obj = __extension__ TypedData_Make_Struct(klass, pcg_rb_rand_t, &pcg_rand_data_t, rand_data);
+
+    rand_data->seed.val     = INT2FIX(0);
+    rand_data->seed.state   = 0;
+    rand_data->seed.seq     = 0;
+    rand_data->rng          = ALLOC(pcg32_random_t);
+
+    return obj;
+}
+
+/*
+ * Initialize the requested instance using a pre-allocated ruby
+ * object (TypedStruct). Sets the instance variables and relevant accessor
+ * methods where applicable.
+ *
+ * @param seed [Fixnum, Bignum] The seed to use use for initilization
+ * 
+ * @raise TypeError unless parameters are Fixnum / Bignum
+ */
+VALUE
+pcg_func_init(int argc, VALUE *argv, VALUE self)
+{
+    VALUE seed;
+    uint64_t cseeds[2];
+    pcg_rb_rand_t* rand_data = pcg_get_rand_type(self);
+
+    if(argc == 0)
+    {
+        seed = DEFAULT_SEED_VALUE;
+    }
+    else
+    {
+        rb_scan_args(argc, argv, "01", &seed);
+    }
+
+    if( !(RB_TYPE_P(seed, T_FIXNUM) || RB_TYPE_P(seed, T_BIGNUM)) )
+    {
+        rb_raise(rb_eTypeError,"Expected Fixnum or Bignum, found %s", 
+            rb_obj_classname(seed));
+    }
+
+    rb_integer_pack(seed, (void *) cseeds, 2, sizeof(uint64_t), 0,
+        INTEGER_PACK_MSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);
+
+    rand_data->seed.val     = seed;
+    rand_data->seed.state   = cseeds[0];
+    rand_data->seed.seq     = cseeds[1];
+    pcg32_srandom_r(rand_data->rng, cseeds[0], cseeds[1]);
+
+    /* Add & set private instance variables */
+    rb_iv_set(self, "@seed", seed);
+    rb_iv_set(self, "state", LONG2NUM(rand_data->seed.state));
+    rb_iv_set(self, "sequence", LONG2NUM(rand_data->seed.seq));
+    return self;
+}
+
+/*
+ * Get a random string of the given length
+ * 
+ * @param max The upperbound on numbers to generate
+ */
+VALUE
+pcg_func_rand_bytes(VALUE self, VALUE size)
+{
+    VALUE result;
+    pcg_rb_rand_t *rdata = pcg_get_rand_type(self);
+    size_t len = NUM2ULONG(size);
+    char *str = ALLOC_N(char, len);
+    
+    for(int i = 0; i < len; ++i)
+    {
+        str[i] = (char) pcg32_boundedrand_r(rdata->rng, CHAR_MAX);
+    }
+    result = rb_str_new(str, len);
+    xfree(str);
+    return result;
+}
+
+/*
+ * Return a random number between 0 and 1
+ *
+ * @param max Upper bound for the rng or the range of values that are acceptable
+ */
+VALUE
+pcg_func_rand(int argc, VALUE *argv, VALUE self)
+{
+    VALUE max, result;
+    long ubound;
+    double num, lim;
+    pcg_rb_rand_t *rdata = pcg_get_rand_type(self);
+    
+    if(argc == 0)
+    {
+        return pcg_rb_float64_rand(rdata->rng);
+    }
+    
+    rb_scan_args(argc, argv, "01", &max);
+    
+    switch(TYPE(max))
+    {
+        case T_FIXNUM:
+            ubound = FIX2LONG(max);
+            return LONG2FIX(pcg32_boundedrand_r(rdata->rng, ubound));
+        case T_FLOAT:
+            num = ldexp((double) pcg32_boundedrand_r(rdata->rng, UINT32_MAX), -32);
+            lim = NUM2DBL(max);
+            return DBL2NUM(num * lim);
+        case T_BIGNUM:
+            num = ldexp((double) pcg32_boundedrand_r(rdata->rng, UINT32_MAX), -32);
+            result = rb_big_mul(max, DBL2NUM(num));
+            return rb_funcall(result, rb_intern("floor"), 0);
+            break;
+        case T_NIL:
+            rb_raise(rb_eArgError, "Invalid argument - nil");
+            break;
+        default:
+            rb_raise(rb_eTypeError, "Argument of type %s not supported (yet)",
+                rb_obj_classname(max));
+    }
+    return Qnil;
+}
+
+/*
+ * Return a random number in [0, 1) with double precision rounded to the closest
+ * multiple for 1/(2**64)
+ */
+static VALUE 
+pcg_rb_float64_rand(pcg32_random_t *rng)
+{
+    double d = ldexp((double) pcg32_boundedrand_r(rng, UINT32_MAX), -32);
+    return DBL2NUM(d);
+}
+
+/*
+ * Compares two instances of the class, returns true if they had the same
+ * initial state
+ *  
+ * @param other [Object] Object to compare this instance to
+ * 
+ * @return
+ */
+VALUE 
+pcg_func_eql(VALUE self, VALUE other)
+{
+    VALUE s, o;
+    if( !strcmp(rb_obj_classname(self), rb_obj_classname(other)) )
+    {
+        s = rb_iv_get(self, "@seed");
+        o = rb_iv_get(other, "@seed");
+        return rb_funcall(s, rb_intern("=="), 1, o);
+    }
+    return Qfalse;
+}

data/ext/pcg_random/pcg_rng.h

@@ -0,0 +1,29 @@
+#ifndef PCG_RNG_H
+#define PCG_RNG_H 1
+
+#include <ruby.h>
+#include <stdint.h>
+
+struct pcg_rb_seed
+{
+    VALUE val;
+    uint64_t state;
+    uint64_t seq;
+};
+
+typedef struct
+{
+    struct pcg_rb_seed seed;
+    pcg32_random_t *rng;
+} pcg_rb_rand_t;
+
+
+pcg_rb_rand_t *pcg_get_rand_type(VALUE obj);
+
+VALUE pcg_random_alloc(VALUE klass);
+VALUE pcg_func_init(int argc, VALUE *argv, VALUE self);
+VALUE pcg_func_rand(int argc, VALUE *argv, VALUE self);
+VALUE pcg_func_rand_bytes(VALUE self, VALUE size);
+VALUE pcg_func_eql(VALUE self, VALUE other);
+
+#endif /* PCG_RNG_H */

data/lib/pcg_random/version.rb

@@ -1,3 +1,3 @@
 class PCGRandom
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcg_random
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Vaibhav Yenamandra
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-30 00:00:00.000000000 Z
+date: 2016-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,8 @@ files:
 - ext/pcg_random/extconf.rb
 - ext/pcg_random/pcg_random.c
 - ext/pcg_random/pcg_random.h
+- ext/pcg_random/pcg_rng.c
+- ext/pcg_random/pcg_rng.h
 - ext/pcg_random/pcg_seed.c
 - ext/pcg_random/pcg_seed.h
 - ext/pcg_random/pcg_spinlock.h