pcg_random 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c4224a9b36896755ece6fca2b0845557df14c600
-  data.tar.gz: 0eee51e96175a204bcea1bb18009bc5b5132d347
+  metadata.gz: 80bdb7b230ebe145ca36718ca2b5ce75927611d3
+  data.tar.gz: f54e765d9d10ce35f10ad63f1cbaa0e8f120fc80
 SHA512:
-  metadata.gz: bb55e8170e1e2cd965ea38f1c00e11656e440f6813d8ed3137e4c9857e5a62a0e095b07103d7934e8b35566077c6138f810c908512182ac624bd7e723bc8a64a
-  data.tar.gz: 312dfe2f1cd5f6241c965f31fadc994f33cc44e5cc707d45e3cd5716131f681c8e7486013fd142193b2d5fea457dee5470da222a9650a201aa4e1557341cb5bb
+  metadata.gz: daf8fdc612fdfb584896480a5ccb5f416cad2b235bbd8f46155c568dcee6b35c911a13eb7fc1af6a7ae5be2b3bd448cbe9f99506b06a17fa05403f5baa4ebc02
+  data.tar.gz: 84057b096b179ffe467e470ba42ac35f84c626edf6c006f108aa9643f0e7b1e525d807a29683774be6e887844205499c7dab06aed3140c5e9f56477ebccbbff9

data/.gitignore

@@ -8,13 +8,12 @@
 /pkg/
 /spec/reports/
 /tmp/
-
+/vendor/
 # Compiled binaries
 *.bundle
 *.so
 *.o
 *.a
-*.gem
 
 # logs
 *.log

data/ext/pcg_random/extconf.rb

@@ -2,7 +2,7 @@ require "mkmf"
 
 RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
 
-$CFLAGS = "-Wall -pedantic -ansi -std=c99"
+$CFLAGS = " -Wall -pedantic -ansi -std=c99"
 
 LIBDIR      = RbConfig::CONFIG['libdir']
 INCLUDEDIR  = RbConfig::CONFIG['includedir']
@@ -21,8 +21,12 @@ LIB_DIRS = [
   '/usr/lib',
 ]
 
-abort 'libpcgrandom is missing' unless find_header('pcg_variants.h')
-abort 'entropy.h missing' unless find_header('entropy.h')
-
+# Typically, it installs libpcg_random.a to /usr/local/lib and
+# pcg_variants.h in /usr/local/include/pcg_variants.h
 dir_config('pcg_random', HEADER_DIRS, LIB_DIRS)
+
+abort 'libpcg_random is missing' unless have_library('pcg_random', 'pcg32_random')
+abort 'entropy.h missing' unless have_header('entropy.h')
+abort 'pcg_variants.h missing' unless have_header('pcg_variants.h')
+
 create_makefile("pcg_random/pcg_random")

data/ext/pcg_random/pcg_random.c

@@ -7,7 +7,7 @@
 #include "pcg_random.h"
 #include "pcg_seed.h"
 
-VALUE rb_mPCGRandom;
+VALUE rb_cPCGRandom;
 
 void
 Init_pcg_random(void)
@@ -16,9 +16,9 @@ Init_pcg_random(void)
     pcg_init_rb_constants();
     
     /* Define encapsulating module */
-    rb_mPCGRandom = rb_define_class("PCGRandom", rb_cObject);
+    rb_cPCGRandom = rb_define_class("PCGRandom", rb_cObject);
     
     /* Define methods under PCGRandom */
-    rb_define_singleton_method(rb_cPCGRandom, "new_seed", pcg_func_new_seed, 0);
+    rb_define_singleton_method(rb_cPCGRandom, "new_seed", pcg_func_new_seed, -1);
     rb_define_singleton_method(rb_cPCGRandom, "raw_seed", pcg_func_raw_seed, 1);
 }

data/ext/pcg_random/pcg_seed.c

@@ -6,29 +6,53 @@
 #include "rb_constants.h"
 #include "pcg_seed.h"
 
-/* Functions local to this source file */
-static VALUE pcg_new_seed_bytestr(void);
+static VALUE pcg_new_seed_bytestr(unsigned long seed_size);
 static VALUE pcg_raw_seed_bytestr(size_t size);
-static VALUE pcg_rb_unpack_str_ui64(VALUE str);
+static VALUE pcg_rb_unpack_str_uint(VALUE str);
 
 /*
- * Returns a 128-bit big-integer that stores the seed value used to seed the 
+ * Returns a n-bit integer that stores the seed value used to seed the 
  * initial state and sequence for the PCG generator.
+ * If no parameters are supplied it default to a 128-bit seed size
+ * 
+ * @param size Number of bytes (EVEN!) that the generated seed must contain.
+ *  Defaults to 16 Bytes = 128 bits
+ *
+ * @raise ArgumentError if size is not even
  */ 
 VALUE
-pcg_func_new_seed(void)
+pcg_func_new_seed(int argc, VALUE *argv, VALUE self)
 {
-    return pcg_new_seed_bytestr();
+    VALUE seed_size;
+    unsigned long n;
+    
+    if(argc == 0)
+    {
+        return pcg_new_seed_bytestr(2 * sizeof(uint64_t));
+    }
+    
+    rb_scan_args(argc, argv, "01", &seed_size);
+    n = NUM2ULONG(seed_size);
+    
+    // Only accept even seed sizes since this later needs to be split into
+    // two parts!
+    if(n % 2 == 1)
+    {
+        rb_raise(rb_eArgError, "Seed size must be even! Found %lu", n);
+    }
+    return pcg_new_seed_bytestr(n * sizeof(char));
 }
 
 /*
- * Generates a random seed represented as a sequence of bytes 
+ * Generates a random seed string represented as a sequence of bytes 
+ *
+ * @param size Size of the bytestring to generate
  */
 VALUE
 pcg_func_raw_seed(VALUE self, VALUE byte_size)
 {
     unsigned long n = NUM2ULONG(byte_size);
-    if( n == 0 )
+    if(n == 0)
     {
         return rb_str_new2("\0");
     }
@@ -42,24 +66,38 @@ pcg_func_raw_seed(VALUE self, VALUE byte_size)
 bool 
 pcg_func_entropy_getbytes(void *dest, size_t size)
 {
-    /* Get random bytes from /dev/random or a fallback source */
-    if( !entropy_getbytes(dest, size) )
-    {
-        fallback_entropy_getbytes(dest, size);
-        return true;
-    }
-    return false;
+    // Get random bytes from /dev/random or a fallback source
+    return entropy_getbytes(dest, size);
 }
 
 /*
- * Internal - Unpacks a string `str` wuth str.unpack('Q*')
- * Unpacks and returns the 0th entry (since it's always a 1 element array)
+ * Internal - Unpacks a string `str` wuth String#unpack
  */
 static VALUE
-pcg_rb_unpack_str_ui64(VALUE str)
+pcg_rb_unpack_str_uint(VALUE str)
 {
-    VALUE ary = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("Q*\0"));
-    return rb_ary_entry(ary, 0);
+    VALUE ary, result, current, base;
+    unsigned long len;
+    
+    // This would be an array of 8 bit fixnums, effectively representing it in
+    // base-256
+    ary = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("C*\0"));
+    len = RARRAY_LEN(ary);
+    
+    base = INT2FIX(256);
+    result = pcg_rb_zero;
+    
+    // First entry in array corresponds to highest significance
+    for(int i = 0; i < len; ++i)
+    {
+        current = rb_ary_entry(ary, i);
+        // Maybe optimize the below code based on on TYPE(result) later ?
+        // Currently this doesnt utilize the C-API a effectively
+        result = rb_funcall(result, pcg_rb_plus, 1, current);
+        result = rb_funcall(result, pcg_rb_mul, 1 , base);
+    }
+    
+    return result;
 }
 
 /*
@@ -70,25 +108,27 @@ static VALUE
 pcg_raw_seed_bytestr(size_t size)
 {
     char *bytestr = (char *) malloc(size + 1);
+    VALUE result;
+    
     memset(bytestr, 0, size + 1);
     pcg_func_entropy_getbytes((void *)bytestr, size);
     
-    return rb_str_new2(bytestr);
+    result = rb_str_new2(bytestr);
+    free(bytestr);
+    
+    return result;
 }
 
 /*
  * Internal - Two random integers are sourced from /dev/random or a fallback
- * technique. 
+ * source 
  * Seed generated by manipulating a 16byte string & unpacking it to Q*
- * 
- * @see pcg_new_seed_bigmul() for alternative techniques
  */
 static VALUE
-pcg_new_seed_bytestr(void)
+pcg_new_seed_bytestr(unsigned long seed_size)
 {
     VALUE seed_bytes_str;
-    
-    seed_bytes_str = pcg_raw_seed_bytestr(2 * sizeof(uint64_t));
-    return pcg_rb_unpack_str_ui64(seed_bytes_str);
+    seed_bytes_str = pcg_raw_seed_bytestr(seed_size);
+    return pcg_rb_unpack_str_uint(seed_bytes_str);
 }
 

data/ext/pcg_random/pcg_seed.h

@@ -4,7 +4,7 @@
 #include <ruby.h>
 #include <stdbool.h>
 
-VALUE pcg_func_new_seed(void);
+VALUE pcg_func_new_seed(int argc, VALUE *argv, VALUE self);
 bool pcg_func_entropy_getbytes(void* dest, size_t size);
 VALUE pcg_func_raw_seed(VALUE self, VALUE byte_size);
 

data/ext/pcg_random/rb_constants.c

@@ -2,12 +2,25 @@
 #include "rb_constants.h"
 
 VALUE pcg_rb_zero,
-      pcg_rb_one;
+      pcg_rb_one,
+      pcg_rb_big_zero,
+      pcg_rb_big_one;
+
+
+ID  pcg_rb_plus,
+    pcg_rb_mul;
 
 void
 pcg_init_rb_constants(void)
 {
-    /* Commonly used ruby objects */
-    pcg_rb_zero = INT2FIX(0u);
-    pcg_rb_one  = INT2FIX(1u);
+    // Commonly used ruby objects
+    pcg_rb_zero = INT2FIX(0);
+    pcg_rb_one  = INT2FIX(1);
+    
+    pcg_rb_big_zero = rb_uint2big(0);
+    pcg_rb_big_one  = rb_uint2big(1);
+    
+    // Commonly called functions
+    pcg_rb_plus = rb_intern("+");
+    pcg_rb_mul  = rb_intern("*");
 }

data/ext/pcg_random/rb_constants.h

@@ -4,7 +4,12 @@
 #include <ruby.h>
 
 extern VALUE pcg_rb_zero,
-             pcg_rb_one;
+             pcg_rb_one,
+             pcg_rb_big_zero,
+             pcg_rb_big_one;
+             
+extern ID pcg_rb_plus, 
+          pcg_rb_mul;
 
 void pcg_init_rb_constants(void);
 

data/lib/pcg_random/version.rb

@@ -1,3 +1,3 @@
 class PCGRandom
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/pcg_random.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rake-compiler', '~> 0'
+  spec.add_development_dependency 'rake-compiler'
   spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'pry', '~> 0'
+  spec.add_development_dependency 'pry'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pcg_random
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Vaibhav Yenamandra
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-16 00:00:00.000000000 Z
+date: 2016-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -42,14 +42,14 @@ dependencies:
   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'
 - !ruby/object:Gem::Dependency
@@ -70,14 +70,14 @@ dependencies:
   name: pry
   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: PCG is a family of simple fast space-efficient statistically good algorithms