pcg_random 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4224a9b36896755ece6fca2b0845557df14c600
+  data.tar.gz: 0eee51e96175a204bcea1bb18009bc5b5132d347
+SHA512:
+  metadata.gz: bb55e8170e1e2cd965ea38f1c00e11656e440f6813d8ed3137e4c9857e5a62a0e095b07103d7934e8b35566077c6138f810c908512182ac624bd7e723bc8a64a
+  data.tar.gz: 312dfe2f1cd5f6241c965f31fadc994f33cc44e5cc707d45e3cd5716131f681c8e7486013fd142193b2d5fea457dee5470da222a9650a201aa4e1557341cb5bb

data/.gitignore

@@ -0,0 +1,27 @@
+# Defaults
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# Compiled binaries
+*.bundle
+*.so
+*.o
+*.a
+*.gem
+
+# logs
+*.log
+
+# Github commit messages
+.gitmsg
+
+# Benchmark code till I find an alternative way that doesn't piss off
+# rake-compiler
+/bench/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Vaibhav Yenamandra
+
+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,41 @@
+# PcgRandom
+
+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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pcg_random'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pcg_random
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+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.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/pcg_random.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

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

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pcg_random"
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/pcg_random/entropy.c

@@ -0,0 +1,123 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+ 
+/* This code provides a mechanism for getting external randomness for 
+ * seeding purposes.  Usually, it's just a wrapper around reading
+ * /dev/random.
+ *
+ * Alas, because not every system provides /dev/random, we need a fallback.
+ * We also need to try to test whether or not to use the fallback.
+ */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <time.h>
+
+#include "pcg_variants.h"
+#include "pcg_spinlock.h"
+
+#include "entropy.h"
+
+#ifndef IS_UNIX
+#if !defined(_WIN32) && (defined(__unix__)  || defined(__unix) \
+                         || (defined(__APPLE__) && defined(__MACH__)))
+    #define IS_UNIX 1
+#else
+    #define IS_UNIX 0
+#endif
+#endif
+
+// If HAVE_DEV_RANDOM is set, we use that value, otherwise we guess
+#ifndef HAVE_DEV_RANDOM
+#define HAVE_DEV_RANDOM         IS_UNIX
+#endif
+
+#if HAVE_DEV_RANDOM
+    #include <fcntl.h>
+    #include <unistd.h>
+#endif
+
+#if HAVE_DEV_RANDOM 
+/* entropy_getbytes(dest, size):
+ *     Use /dev/random to get some external entropy for seeding purposes.
+ *
+ * Note:
+ *     If reading /dev/random fails (which ought to never happen), it returns
+ *     false, otherwise it returns true.  If it fails, you could instead call
+ *     fallback_entropy_getbytes which always succeeds.
+ */
+
+bool entropy_getbytes(void* dest, size_t size)
+{
+    int fd = open("/dev/random", O_RDONLY);
+    if (fd < 0)
+        return false;
+    int sz = read(fd, dest, size);
+    if (sz < size)
+        return false;
+    return close(fd) == 0;
+}
+#else
+bool entropy_getbytes(void* dest, size_t size)
+{
+    fallback_entropy_getbytes(dest, size);
+    return true;
+}
+#endif
+
+/* fallback_entropy_getbytes(dest, size):
+ *     Works like the /dev/random version above, but avoids using /dev/random.
+ *     Instead, it uses a private RNG (so that repeated calls will return
+ *     different seeds).  Makes no attempt at cryptographic security.
+ */
+
+void fallback_entropy_getbytes(void* dest, size_t size)
+{
+    // Most modern OSs use address-space randomization, meaning that we can
+    // use the address of stack variables and system library code as
+    // initializers.  It's not as good as using /dev/random, but probably
+    // better than using the current time alone.
+
+    static PCG_SPINLOCK_DECLARE(mutex);
+    PCG_SPINLOCK_LOCK(mutex);
+
+    static int intitialized = 0;
+    static pcg32_random_t entropy_rng;
+    
+    if (!intitialized) {
+        int dummyvar;
+        pcg32_srandom_r(&entropy_rng,
+                        time(NULL) ^ (intptr_t)&fallback_entropy_getbytes, 
+                        (intptr_t)&dummyvar);
+        intitialized = 1;
+    }
+    
+    char* dest_cp = (char*) dest;
+    for (size_t i = 0; i < size; ++i) {
+        dest_cp[i] = (char) pcg32_random_r(&entropy_rng);
+    }
+
+    PCG_SPINLOCK_UNLOCK(mutex);
+}

data/ext/pcg_random/entropy.h

@@ -0,0 +1,40 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+
+#ifndef ENTROPY_H_INCLUDED
+#define ENTROPY_H_INCLUDED 1
+
+#include <stdbool.h>
+
+#if __cplusplus
+extern "C" {
+#endif
+
+extern bool entropy_getbytes(void* dest, size_t size);
+extern void fallback_entropy_getbytes(void* dest, size_t size);
+
+#if __cplusplus
+}
+#endif
+
+#endif // ENTROPY_H_INCLUDED

data/ext/pcg_random/extconf.rb

@@ -0,0 +1,28 @@
+require "mkmf"
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+$CFLAGS = "-Wall -pedantic -ansi -std=c99"
+
+LIBDIR      = RbConfig::CONFIG['libdir']
+INCLUDEDIR  = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  '/opt/local/include',
+  '/usr/local/include',
+  INCLUDEDIR,
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  '/opt/local/lib',
+  '/usr/local/lib',
+  LIBDIR,
+  '/usr/lib',
+]
+
+abort 'libpcgrandom is missing' unless find_header('pcg_variants.h')
+abort 'entropy.h missing' unless find_header('entropy.h')
+
+dir_config('pcg_random', HEADER_DIRS, LIB_DIRS)
+create_makefile("pcg_random/pcg_random")

data/ext/pcg_random/pcg_random.c

@@ -0,0 +1,24 @@
+#include <ruby.h>
+#include <pcg_variants.h>
+#include <inttypes.h>
+#include <string.h>
+
+#include "rb_constants.h"
+#include "pcg_random.h"
+#include "pcg_seed.h"
+
+VALUE rb_mPCGRandom;
+
+void
+Init_pcg_random(void)
+{
+    /* Initialize constants used by C-code*/
+    pcg_init_rb_constants();
+    
+    /* Define encapsulating module */
+    rb_mPCGRandom = 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, "raw_seed", pcg_func_raw_seed, 1);
+}

data/ext/pcg_random/pcg_random.h

@@ -0,0 +1,9 @@
+#ifndef PCG_RANDOM_H
+#define PCG_RANDOM_H 1
+
+#include <ruby.h>
+#include <inttypes.h>
+
+extern VALUE rb_cPCGRandom;
+
+#endif /* PCG_RANDOM_H */

data/ext/pcg_random/pcg_seed.c

@@ -0,0 +1,94 @@
+#include <ruby.h>
+#include <pcg_variants.h>
+#include <stdbool.h>
+
+#include "entropy.h"
+#include "rb_constants.h"
+#include "pcg_seed.h"
+
+/* Functions local to this source file */
+static VALUE pcg_new_seed_bytestr(void);
+static VALUE pcg_raw_seed_bytestr(size_t size);
+static VALUE pcg_rb_unpack_str_ui64(VALUE str);
+
+/*
+ * Returns a 128-bit big-integer that stores the seed value used to seed the 
+ * initial state and sequence for the PCG generator.
+ */ 
+VALUE
+pcg_func_new_seed(void)
+{
+    return pcg_new_seed_bytestr();
+}
+
+/*
+ * Generates a random seed represented as a sequence of bytes 
+ */
+VALUE
+pcg_func_raw_seed(VALUE self, VALUE byte_size)
+{
+    unsigned long n = NUM2ULONG(byte_size);
+    if( n == 0 )
+    {
+        return rb_str_new2("\0");
+    }
+    return pcg_raw_seed_bytestr(n);
+}
+
+/*
+ * Generates a sequence of random bytes using device entropy
+ * or a fallback mechanism based on pcg32_random_r
+ */
+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;
+}
+
+/*
+ * Internal - Unpacks a string `str` wuth str.unpack('Q*')
+ * Unpacks and returns the 0th entry (since it's always a 1 element array)
+ */
+static VALUE
+pcg_rb_unpack_str_ui64(VALUE str)
+{
+    VALUE ary = rb_funcall(str, rb_intern("unpack"), 1, rb_str_new2("Q*\0"));
+    return rb_ary_entry(ary, 0);
+}
+
+/*
+ * Internal - gets `size` number of random bytes from a platform source
+ * and returns those as a ruby string
+ */
+static VALUE
+pcg_raw_seed_bytestr(size_t size)
+{
+    char *bytestr = (char *) malloc(size + 1);
+    memset(bytestr, 0, size + 1);
+    pcg_func_entropy_getbytes((void *)bytestr, size);
+    
+    return rb_str_new2(bytestr);
+}
+
+/*
+ * Internal - Two random integers are sourced from /dev/random or a fallback
+ * technique. 
+ * 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)
+{
+    VALUE seed_bytes_str;
+    
+    seed_bytes_str = pcg_raw_seed_bytestr(2 * sizeof(uint64_t));
+    return pcg_rb_unpack_str_ui64(seed_bytes_str);
+}
+

data/ext/pcg_random/pcg_seed.h

@@ -0,0 +1,11 @@
+#ifndef PCG_SEED_H
+#define PCG_SEED_H 1
+
+#include <ruby.h>
+#include <stdbool.h>
+
+VALUE pcg_func_new_seed(void);
+bool pcg_func_entropy_getbytes(void* dest, size_t size);
+VALUE pcg_func_raw_seed(VALUE self, VALUE byte_size);
+
+#endif /* PCG_SEED_H */

data/ext/pcg_random/pcg_spinlock.h

@@ -0,0 +1,57 @@
+/*
+ * PCG Random Number Generation for C.
+ *
+ * Copyright 2014 Melissa O'Neill <oneill@pcg-random.org>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * including its license and other licensing options, visit
+ *
+ *     http://www.pcg-random.org
+ */
+ 
+/* This code provides a minimal spinlock implementation.  It's only used
+ * in supporting fallback_entropy_getbytes.
+ */
+
+#ifndef PCG_SPINLOCK_H_INCLUDED
+#define PCG_SPINLOCK_H_INCLUDED 1
+
+#ifndef __has_include
+    #define INCLUDE_OKAY(x) 1
+#else
+    #define INCLUDE_OKAY(x) __has_include(x)
+#endif
+
+#if __STDC_VERSION__ >= 201112L && !__STDC_NO_ATOMICS__ \
+        && INCLUDE_OKAY(<stdatomic.h>)
+    #include <stdatomic.h>
+    #define PCG_SPINLOCK_DECLARE(mutex) atomic_flag mutex = ATOMIC_FLAG_INIT
+    #define PCG_SPINLOCK_LOCK(mutex)    do {} \
+                                        while (atomic_flag_test_and_set(&mutex))
+    #define PCG_SPINLOCK_UNLOCK(mutex)  atomic_flag_clear(&mutex)
+#elif __GNUC__
+    #define PCG_SPINLOCK_DECLARE(mutex) volatile int mutex = 0
+    #define PCG_SPINLOCK_LOCK(mutex)    \
+                do {} while(__sync_lock_test_and_set(&mutex, 1))
+    #define PCG_SPINLOCK_UNLOCK(mutex)  __sync_lock_release(&mutex)
+#else
+    #warning No implementation of spinlocks provided.  No thread safety.
+    #define PCG_SPINLOCK_DECLARE(mutex) volatile int mutex = 0
+    #define PCG_SPINLOCK_LOCK(mutex)    \
+                do { while(mutex == 1){} mutex = 1; } while(0)
+    #define PCG_SPINLOCK_UNLOCK(mutex)  mutex = 0;
+#endif
+
+#endif // PCG_SPINLOCK_H_INCLUDED

data/ext/pcg_random/rb_constants.c

@@ -0,0 +1,13 @@
+#include <ruby.h>
+#include "rb_constants.h"
+
+VALUE pcg_rb_zero,
+      pcg_rb_one;
+
+void
+pcg_init_rb_constants(void)
+{
+    /* Commonly used ruby objects */
+    pcg_rb_zero = INT2FIX(0u);
+    pcg_rb_one  = INT2FIX(1u);
+}

data/ext/pcg_random/rb_constants.h

@@ -0,0 +1,11 @@
+#ifndef PCG_RB_CONSTANTS_H
+#define PCG_RB_CONSTANTS_H 1
+
+#include <ruby.h>
+
+extern VALUE pcg_rb_zero,
+             pcg_rb_one;
+
+void pcg_init_rb_constants(void);
+
+#endif /* PCG_RB_CONSTANTS_H */

data/lib/pcg_random/version.rb

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

data/lib/pcg_random.rb

@@ -0,0 +1,2 @@
+require "pcg_random/version"
+require "pcg_random/pcg_random"

data/pcg_random.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pcg_random/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pcg_random'
+  spec.version       = PCGRandom::VERSION
+  spec.authors       = ['Vaibhav Yenamandra']
+  spec.email         = ['yvvaibhav@gmail.com']
+
+  spec.summary       = %q{Ruby interface to the pcg random number generator}
+  spec.description   = %q{PCG is a family of simple fast space-efficient statistically good algorithms for random number generation. Unlike many general-purpose RNGs, they are also hard to predict. This library aims to act as the ruby interface to this set of functions}
+  spec.homepage      = 'https://github.com/vaibhav-y/pcg_random'
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.extensions    = ['ext/pcg_random/extconf.rb']
+
+  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 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry', '~> 0'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: pcg_random
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Vaibhav Yenamandra
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  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
+  for random number generation. Unlike many general-purpose RNGs, they are also hard
+  to predict. This library aims to act as the ruby interface to this set of functions
+email:
+- yvvaibhav@gmail.com
+executables: []
+extensions:
+- ext/pcg_random/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/pcg_random/entropy.c
+- ext/pcg_random/entropy.h
+- ext/pcg_random/extconf.rb
+- ext/pcg_random/pcg_random.c
+- ext/pcg_random/pcg_random.h
+- ext/pcg_random/pcg_seed.c
+- ext/pcg_random/pcg_seed.h
+- ext/pcg_random/pcg_spinlock.h
+- ext/pcg_random/rb_constants.c
+- ext/pcg_random/rb_constants.h
+- lib/pcg_random.rb
+- lib/pcg_random/version.rb
+- pcg_random.gemspec
+homepage: https://github.com/vaibhav-y/pcg_random
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby interface to the pcg random number generator
+test_files: []