random 0.2.0

data/LICENSE

@@ -0,0 +1,32 @@
+Random - a Ruby extension library for random number generation
+
+Copyright (c) 2006, Robert Feldt, robert.feldt@gmail.com
+
+All rights reserved.                          
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+  1. Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+
+  3. The names of its contributors may not be used to endorse or promote 
+     products derived from this software without specific prior written 
+     permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README

@@ -0,0 +1,83 @@
+= Random - Ruby classes for pseudorandom number generation
+
+This package contains Random, a ruby extension adding classes for
+generating pseudorandom number generation (PRNG).
+
+Random has the following features:
+
+* A fast PRNG implemented in C and wrapped in a Ruby class. The algorithm is the well-known and widely used MersenneTwister.
+
+* Multiple independent random streams can be active at the same time (since the PRNG is wrapped in a class and objects of that class are independent).
+
+* PRNG objects supports marshaling.
+
+This is in contrast to Ruby's standard srand/rand methods. Even though the standard methods use the same PRNG algorithm (the MersenneTwister) only a single (global) PRNG exists for each ruby invocation and its state cannot be saved to disc. Random alleviates these problems. This is especially important for scientific and simulation applications.
+
+== Download
+
+The latest version of Random can be found at
+
+* http://rubyforge.org/projects/random/
+
+== Installation
+
+=== GEM Installation
+
+Download and install Random with the following.
+
+   gem install --remote random
+
+=== Running the Random Test Suite
+
+Random comes with an extensive test suite. If you wish to run it:
+
+* CD into the top project directory of random.
+* Type:
+
+     rake                  # If you have a version of rake installed
+
+== Online Resources and References
+
+* Documentation Home:  coming!
+* Project Page: http://rubyforge.org/projects/random
+* API Documents: coming!
+
+== Simple Example
+
+Once installed, you can use random as follows:
+
+:include: doc/simple_example.rb
+
+== Credits
+
+[<b>Richard Wagner</b>] For the C++ implementation of the MersenneTwister which is the basis for Random::MersenneTwister.
+
+== License
+
+Random is available under a BSD-style license.
+
+:include: LICENSE
+
+== Support
+
+The Random homepage is http://random.rubyforge.org.  You can find the Random
+RubyForge page at http://rubyforge.org/projects/random.
+
+Feel free to submit commits or feature requests. If you send a patch,
+please also update and send the corresponding unit tests.
+
+It would be great to get help with creating pre-compiled gems of this to simplify for users that do not have a build environment. Please email if you can help with this (especially for non-linux targets).
+
+For other information, feel free to ask on the ruby-talk mailing list
+(which is mirrored to comp.lang.ruby) or contact
+mailto:robert.feldt@gmail.com.
+
+---
+
+= Other stuff
+
+Author::   Robert Feldt <robert.feldt@gmail.com>
+Requires:: Ruby 1.8.2 or later (but only tested with 1.8.4)
+License::  Copyright 2006 by Robert Feldt
+           Released under a BSD-style license.  See the LICENSE file
+           included in the distribution.

data/Rakefile

@@ -0,0 +1,247 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+PROJECT = "random"
+
+VERSION_FILE = "VERSION"
+#MANIFEST_FILE = "Manifest"
+README_FILE = "README"
+TODO_FILE = "TODO"
+RAKE_FILE = "Rakefile"
+
+CLEAN.include("ext/**/*.so")
+CLEAN.include("ext/**/*.o")
+CLEAN.include("ext/**/Makefile")
+CLEAN.include("CHANGES")
+CLEAN.include("CODE_STATS")
+
+task :default => [:test]
+
+
+#############################################################################
+# Version related
+#############################################################################
+
+# Read the version from the version file
+def Version()
+  File.open(VERSION_FILE) {|fh| fh.read.strip}
+end
+
+# Update the version num on disc
+def update_version
+  v = Version().split(".").map {|vp| vp.to_i}
+  new_v = yield(v)
+  File.open(VERSION_FILE, "w") {|fh| fh.write(new_v)}
+  puts Version()
+end
+
+def inc_tiny; update_version {|v| "#{v[0]}.#{v[1]}.#{v[2]+1}\n"}; end
+def inc_minor; update_version {|v| "#{v[0]}.#{v[1]+1}.0\n"}; end
+def inc_major; update_version {|v| "#{v[0]+1}.0.0\n"}; end
+
+task :version do
+  puts Version()
+end
+task :inc_tiny  do
+  inc_tiny()
+end
+task :inc_minor do 
+  inc_minor()
+end
+task :inc_major do
+  inc_major()
+end
+
+
+#############################################################################
+# Test related
+#############################################################################
+
+UTestFiles = FileList["test/unit/**/test*.rb"]
+ATestFiles = FileList["test/acceptance/**/*test*.rb"]
+PTestFiles = FileList["test/performance/**/test*.rb"]
+
+task :setup_for_test => [:pack_and_geminstall] do
+  require 'rubygems'
+  require 'test/common'
+end
+
+def load_files(list)
+  list.each {|f| puts "Loading #{f}"; require f}
+end
+
+task :utest => [:setup_for_test] do
+  load_files UTestFiles
+end
+
+task :atest => [:setup_for_test] do
+  load_files ATestFiles
+end
+
+task :ptest => [:setup_for_test] do
+  load_files PTestFiles
+end
+
+task :test => [:setup_for_test] do
+  load_files UTestFiles
+  load_files ATestFiles
+end
+
+task :ut => :utest
+task :at => :atest
+task :pt => :ptest
+
+
+############################################################################
+# RDoc related
+############################################################################
+
+file "CHANGES" do
+  system "darcs changes > CHANGES"
+end
+
+file "CODE_STATS" do
+  system "rake stats > CODE_STATS"
+end
+
+rd = Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = "Random -- Pseudorandom Number Generators for Ruby"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'LICENSE', 'TODO', 'CHANGES', 'CODE_STATS')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('ext/**/*.c')
+end
+
+
+#############################################################################
+# Gem and package related
+#############################################################################
+
+BaseFileToIncludeGlobs = [
+    "README", 
+    "TODO", 
+    "LICENSE", 
+    "VERSION",
+    "Rakefile", 
+    "ext/random/mersenne_twister_ext.c", 
+    "ext/random/extconf.rb",
+    "lib/random.rb",
+    "lib/random/array_random_element.rb",
+    "lib/random/random_number_generator.rb",
+    "lib/random/testing.rb",
+    "lib/math/statistics/chi_square.rb",
+    "lib/math/statistics/table_chi_square_probabilities.html",
+    "doc/**/*",
+]
+
+TestFilesToIncludeGlobs = [
+    "test/acceptance/**/*", 
+    "test/performance/**/*", 
+    "test/unit/**/*",
+]
+
+PkgFileGlobs = BaseFileToIncludeGlobs + TestFilesToIncludeGlobs
+
+def gem_spec
+  Gem::Specification.new do |s|
+    s.name = PROJECT
+    s.version = Version()
+    s.platform = Gem::Platform::RUBY
+    s.summary = "Stand-alone random number generator (RNG) class allowing multiple, active RNG's at the same time (which is not possible with Ruby's rand/srand)."
+    s.author = "Robert Feldt"
+    s.email = "Robert.Feldt@gmail.com"
+    s.homepage = "http://www.rubyforge.org/projects/random"
+
+    s.description = <<EOS
+A Mersenne-Twister random number generator (RNG) packed up as a class. This allows multiple RNG streams to be active at the same time (which Ruby's normal rand/srand does not allow). The Mersenne-Twister is implemented with fast C code for speed.
+EOS
+    
+    s.require_paths << "ext"
+    s.require_paths << "lib"
+
+    s.has_rdoc = false
+
+    s.files = []
+    PkgFileGlobs.each do |globpat|
+      fs = Dir.glob(globpat).delete_if {|i| i.include?(".svn")}
+      s.files += fs
+    end
+
+    s.extensions = ["ext/random/extconf.rb"]
+  end
+end
+
+Rake::GemPackageTask.new(gem_spec()) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+def gem_name
+  Dir["pkg/*.gem"].first
+end
+
+task :gem_uninstall do
+  system "sudo gem uninstall random"
+end
+
+task :pack_and_geminstall => [:gem_uninstall, :package] do
+  system "sudo gem install #{gem_name()}"
+end
+
+
+#############################################################################
+# Rubyforge related
+#############################################################################
+
+# Create a package (a name for a top-level "item" which can then have multiple
+# releases where each release can have multiple files)
+def create_package(packageName = "random")
+  system "rubyforge create_package #{PROJECT} #{packageName}"
+end
+
+# Release a <file> with a given <release_name> in the given <package>.
+def release_file(file, release_name, package = PROJECT)
+  group_id = PROJECT
+  system "rubyforge add_release #{group_id} #{package} #{release_name} #{file}"
+end
+
+# Delete a package (and all its files)
+def delete_package(packageName)
+  system "rubyforge create_package random #{ARGV.last}"
+end
+
+# We use a temporary package name for now, should be PROJECT later...
+#PACKAGE_NAME = "1801"  # if of the test package in random group
+PACKAGE_NAME = "368"  # Name of random package
+
+task :pack => [:gen_paper, :package]
+
+desc "Create package and release to rubyforge"
+task :rubyforge_release => [:pack] do
+  puts "Logging in to rubyforge"
+  system "rubyforge login"
+
+  release_name = "#{PROJECT}-#{Version()}"
+  files_to_release = FileList["pkg/#{release_name}.gem"]
+  files_to_release.each do |file|
+    puts "Releasing #{file} to Rubyforge"
+    release_file(file, release_name, PACKAGE_NAME)
+  end
+end
+
+############################################################################
+# Code stats
+############################################################################
+begin
+  require 'feldt/rake/codestatstask'
+
+  Rake::CodeStatsTask.new do |t|
+    t.code_directories = ['lib']  # not needed since it is the default
+    t.test_directories = ['test'] # not needed since it is the default
+  end
+rescue Exception => e
+end

data/TODO

@@ -0,0 +1,4 @@
+=== Primary
+
+=== Secondary
+* Add more randomness testing algorithms (now only chi-square test)

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/doc/simple_example.rb

@@ -0,0 +1,17 @@
+  require 'rubygems'
+  require 'random'
+
+  mt = Random::RNG.new()
+  mt.rand                     # like Ruby's normal rand
+  mt.rand_num(1, 6)           # gives a random integer in 1..6
+  mt.rand_float_exclusive     # gives random float >= 0.0 and <  1.0
+  mt.rand_float               # gives random float >= 0.0 and <= 1.0
+  mt.rand_int_with_bits(1000) # gives random integer with 1000 random bits
+  mt.rand_bytes(10)           # gives a random string of length 10
+  mt.next                     # next random number in RNG stream (typically an
+                              #  integer >= 0 and < 2**32)
+  str = Marshal.dump(mt)      # Marshal the full state of mt to a string
+  mt2 = Marshal.load(str)     #  and read it back in.
+  mt2.next == mt.next         # => true
+  a = (1..100).to_a
+  a.random_element            # gives a random element from the array

data/ext/random/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+srcs = %w{
+mersenne_twister_ext
+}
+
+$objs = srcs.collect {|src| src + ".o"}
+
+create_makefile 'mersenne_twister_ext'

data/ext/random/mersenne_twister_ext.c

@@ -0,0 +1,465 @@
+/* MersenneTwister class for Ruby 
+ * Robert Feldt robert.feldt@gmail.com
+ *
+ * based on code by Makoto Matsumoto, Takuji Nishimura, Shawn Cokus, and
+ * Richard Wagner. Main basis has been Richard Wagner's v1.0 15 May 2003
+ * version MersenneTwister.h.
+ *
+ * The Mersenne Twister is an algorithm for generating random numbers.  It
+ * was designed with consideration of the flaws in various other generators.
+ * The period, 2^19937-1, and the order of equidistribution, 623 dimensions,
+ * are far greater.  The generator is also fast; it avoids multiplication and
+ * division, and it benefits from caches and pipelines.  For more information
+ * see the inventors' web page at http://www.math.keio.ac.jp/~matumoto/emt.html
+ *
+ * Reference
+ * M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
+ * Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions on
+ * Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
+ *
+ * Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
+ * Copyright (C) 2000 - 2003, Richard J. Wagner
+ * Copyright (C) 2006, Robert Feldt
+ *
+ * All rights reserved.                          
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *
+ *   3. The names of its contributors may not be used to endorse or promote 
+ *      products derived from this software without specific prior written 
+ *      permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+ * The original code included the following notice:
+ *
+ *     When you use this, send an email to: matumoto@math.keio.ac.jp
+ *     with an appropriate reference to your work.
+ *
+ * It would be nice to CC: rjwagner@writeme.com and Cokus@math.washington.edu
+ * and robert.feldt@gmail.com when you write.
+ */
+#include "ruby.h"
+#include <time.h>
+
+static VALUE mRandom;
+static VALUE cRandomNumberGenerator;
+static VALUE cMersenneTwister;
+
+typedef unsigned long uint32;  // unsigned integer type, at least 32 bits
+    
+#define N      (624)           // length of state vector
+#define SAVE   (N + 1)         // length of array for save()
+#define M      (397)           // period parameter			
+
+typedef struct {
+  uint32 state[N];  // internal state
+  uint32 *pNext;    // next value to get from state
+  int left;         // number of values left before reload needed
+} MersenneTwister;
+
+#define hiBit(u)         (u & 0x80000000UL)
+#define loBit(u)         (u & 0x00000001UL)
+#define loBits(u)         (u & 0x7fffffffUL)
+#define mixBits(u,v)     (hiBit(u) | loBits(v))
+#define twist(m, s0, s1) ((m) ^ (mixBits((s0),(s1))>>1) ^(-loBit(s1) & 0x9908b0dfUL))
+
+inline void reload(MersenneTwister* mt) {
+  // Generate N new values in state
+  // Made clearer and faster by Matthew Bellew (matthew.bellew@home.com)
+  register uint32 *p = mt->state;
+  register int i;
+
+  for( i = N - M; i--; ++p )
+    *p = twist( p[M], p[0], p[1] );
+  for( i = M; --i; ++p )
+    *p = twist( p[M-N], p[0], p[1] );
+  *p = twist( p[M-N], p[0], mt->state[0] );
+
+  mt->left = N, mt->pNext = mt->state;
+}
+
+// integer in [0,2^32-1]
+inline uint32 rand_int(MersenneTwister* mt) {
+  // Pull a 32-bit integer from the generator state
+  // Every other access function simply transforms the numbers extracted here
+  register uint32 s1;
+  
+  if( mt->left == 0 ) {
+    reload(mt);
+  }
+
+  (mt->left)--;
+		
+  s1 = *(mt->pNext);
+  mt->pNext++;
+  s1 ^= (s1 >> 11);
+  s1 ^= (s1 <<  7) & 0x9d2c5680UL;
+  s1 ^= (s1 << 15) & 0xefc60000UL;
+  return ( s1 ^ (s1 >> 18) );
+}
+
+// real number in [0,1] (inclusive)
+inline double rand_double(MersenneTwister* mt) { 
+  return ((double)rand_int(mt)) * (1.0/4294967295.0); 
+}
+
+// real number in [0,n] (inclusive)
+inline double rand_double_scaled(MersenneTwister* mt, const double n ) {
+  return rand_double(mt) * n; 
+}
+
+// real number in [0,1) (exclusive)
+inline double rand_double_excl(MersenneTwister* mt) { 
+  return ((double)rand_int(mt)) * (1.0/4294967296.0); 
+}
+
+// real number in [0,n) (exclusive)
+inline double rand_double_scaled_excl(MersenneTwister* mt, const double n ) {
+  return rand_double_excl(mt) * n; 
+}
+
+// integer in [0,n] for n < 2^32
+inline uint32 rand_int_small_limited(MersenneTwister* mt, const uint32 n ) {
+  register uint32 i;
+  register uint32 used = n;
+
+  // Find which bits are used in n
+  // Optimized by Magnus Jonsson (magnus@smartelectronix.com)
+  used |= used >> 1;
+  used |= used >> 2;
+  used |= used >> 4;
+  used |= used >> 8;
+  used |= used >> 16;
+	
+  // Draw numbers until one is found in [0,n]
+  i = rand_int(mt) & used;
+  while( i > n ) {
+    i = rand_int(mt) & used; // toss unused bits to shorten search
+  }
+
+  return i;
+}
+
+inline void initialize_state( MersenneTwister* mt, const uint32 seed ) {
+  // Initialize generator state with seed
+  // See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
+  // In previous versions, most significant bits (MSBs) of the seed affect
+  // only MSBs of the state array.  Modified 9 Jan 2002 by Makoto Matsumoto.
+  register uint32 *s = mt->state;
+  register uint32 *r = mt->state;
+  register int i = 1;
+  *s++ = seed & 0xffffffffUL;
+  for( ; i < N; ++i ) {
+    *s++ = ( 1812433253UL * ( *r ^ (*r >> 30) ) + i ) & 0xffffffffUL;
+    r++;
+  }
+}
+
+inline void seed( MersenneTwister* mt, const uint32 oneSeed ) {
+  // Seed the generator with a simple uint32
+  initialize_state(mt, oneSeed);
+  reload(mt);
+}
+
+inline void seed_from_array( MersenneTwister* mt, 
+			     uint32 *const bigSeed, 
+			     const uint32 seedLength ) {
+  // Seed the generator with an array of uint32's
+  // There are 2^19937-1 possible initial states.  This function allows
+  // all of those to be accessed by providing at least 19937 bits (with a
+  // default seed length of N = 624 uint32's).  Any bits above the lower 32
+  // in each element are discarded.
+  // Just call seed() if you want to get array from /dev/urandom
+  initialize_state(mt, 19650218UL);
+  register int i = 1;
+  register uint32 j = 0;
+  register int k = ( N > seedLength ? N : seedLength );
+  for( ; k; --k ) {
+    mt->state[i] =
+      mt->state[i] ^ ( (mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1664525UL );
+    mt->state[i] += ( bigSeed[j] & 0xffffffffUL ) + j;
+    mt->state[i] &= 0xffffffffUL;
+    ++i;  ++j;
+    if( i >= N ) { mt->state[0] = mt->state[N-1];  i = 1; }
+    if( j >= seedLength ) j = 0;
+  }
+  for( k = N - 1; k; --k ) {
+    mt->state[i] =
+      mt->state[i] ^ ( (mt->state[i-1] ^ (mt->state[i-1] >> 30)) * 1566083941UL );
+    mt->state[i] -= i;
+    mt->state[i] &= 0xffffffffUL;
+    ++i;
+    if( i >= N ) { mt->state[0] = mt->state[N-1];  i = 1; }
+  }
+  mt->state[0] = 0x80000000UL;  // MSB is 1, assuring non-zero initial array
+  reload(mt);
+}
+
+
+/////////////////////////////////////////////////////////////////////////////
+// Ruby wrapper functions
+/////////////////////////////////////////////////////////////////////////////
+
+void mt_free(MersenneTwister* mt) {
+  if(mt) {
+    xfree(mt);
+  }
+}
+
+static VALUE 
+mt_alloc(VALUE klass) {
+  MersenneTwister *mt;
+  VALUE obj;
+
+  mt = (MersenneTwister*)xcalloc(sizeof(MersenneTwister), 1);
+  obj = Data_Wrap_Struct(klass, 0, mt_free, mt);
+
+  return obj;
+}
+
+// Get a unique seed
+inline uint32 hash( time_t t, clock_t c ) {
+  // Get a uint32 from t and c
+  // Better than uint32(x) in case x is floating point in [0,1]
+  // Based on code by Lawrence Kirby (fred@genesis.demon.co.uk)
+
+  static uint32 differ = 0;  // guarantee time-based seeds will change
+
+  uint32 h1 = 0;
+  unsigned char *p = (unsigned char *) &t;
+  size_t i, j;
+
+  for( i = 0; i < sizeof(t); ++i ) {
+    h1 *= UCHAR_MAX + 2U;
+    h1 += p[i];
+  }
+  uint32 h2 = 0;
+  p = (unsigned char *) &c;
+  for( j = 0; j < sizeof(c); ++j ) {
+    h2 *= UCHAR_MAX + 2U;
+    h2 += p[j];
+  }
+  return ( h1 + differ++ ) ^ h2;
+}
+
+/* Initialize an instance of the Mersenne Twister RNG. The seed can either
+ * be a 32 bit unsigned integer (ie a Ruby Integer in the range 
+ * 0..(-1+2**32)) or an array of 624 32 bit unsigned integers (the state
+ * used by the Mersenne Twister algorithm). If an array larger than 624
+ * is given only the first 624 integers are used. If no seed is used
+ * we use a (fixed) default value.
+ */
+static VALUE
+mt_initialize(int argc, VALUE* argv, VALUE self) {
+  MersenneTwister* mt;
+  VALUE arg_seed;
+  register int i;
+  uint32 array_seed[N];
+  uint32 oneSeed;
+  uint32 max;
+
+  Data_Get_Struct(self, MersenneTwister, mt);
+
+  rb_scan_args(argc, argv, "01", &arg_seed);
+
+  // Get a new seed if none were given
+  if(TYPE(arg_seed) == T_NIL) {
+    arg_seed = UINT2NUM(hash(time(NULL), clock()));
+  }
+
+  switch (TYPE(arg_seed)) {
+
+  case T_ARRAY:
+    // Find max number of numbers in seed array
+    if (RARRAY(arg_seed)->len < N)
+      max = RARRAY(arg_seed)->len;
+    else
+      max = N;
+
+    // Translate Ruby Integers to uint32s
+    for( i = 0; i<max; i++) {
+      array_seed[i] = NUM2UINT(rb_ary_entry(arg_seed, i));
+    }
+    for(; i<N; i++) {
+      array_seed[i] = (uint32)0;
+    }
+
+    // Then seed from that
+    seed_from_array(mt, array_seed, max);
+    break;
+    
+  case T_BIGNUM:
+  case T_FIXNUM:
+    seed(mt, (uint32)NUM2UINT(arg_seed));
+    break;
+
+  default:
+    rb_raise(rb_eException, "Invalid argument");
+    break;
+  }
+  
+  return self;
+}
+
+static VALUE
+mt_small_seed(VALUE self, VALUE arg1) {
+  register uint32 *s;
+  register int i;
+  uint32 oneSeed = (uint32)NUM2UINT(arg1);
+  MersenneTwister *mt;
+  Data_Get_Struct(self, MersenneTwister, mt);
+}
+
+static VALUE
+mt_gen_uint32(VALUE self)
+{
+  MersenneTwister *mt;
+
+  Data_Get_Struct(self, MersenneTwister, mt);
+
+  return UINT2NUM(rand_int(mt));
+}
+
+static VALUE
+mt_rand_int_small_limited(VALUE self, VALUE limit)
+{
+  uint32 lim = NUM2UINT(limit);
+  MersenneTwister *mt;
+
+  if(lim == 0) {
+    return UINT2NUM(0);
+  }
+
+  Data_Get_Struct(self, MersenneTwister, mt);
+
+  return UINT2NUM(rand_int_small_limited(mt, lim));
+}
+
+static VALUE
+mt_rand_float(VALUE self)
+{
+  MersenneTwister *mt;
+  
+  Data_Get_Struct(self, MersenneTwister, mt);
+  return rb_float_new(rand_double(mt));
+}
+
+static VALUE
+mt_rand_float_excl(VALUE self)
+{
+  MersenneTwister *mt;
+  
+  Data_Get_Struct(self, MersenneTwister, mt);
+  return rb_float_new(rand_double_excl(mt));
+}
+
+static VALUE
+mt_state(VALUE self)
+{
+  register VALUE ary;
+  register const uint32 *s;
+  register int i = N;
+  MersenneTwister *mt;
+
+  Data_Get_Struct(self, MersenneTwister, mt);
+
+  s = mt->state;
+  ary  = rb_ary_new();
+
+  for( ; i--; s++) {
+    rb_ary_push(ary, UINT2NUM(*s));
+  }
+
+  rb_ary_push(ary, UINT2NUM(mt->left));
+
+  //printf("get: left=%u, s-n=%u, s[0]=%u, s[623]=%u\n", 
+  //	 mt->left, mt->pNext - mt->state, mt->state[0], mt->state[623]);
+
+  return ary;
+}
+
+static VALUE
+mt_state_set(VALUE self, VALUE ary)
+{
+  register uint32 *s;
+  register int i = N;
+  MersenneTwister *mt;
+
+  Data_Get_Struct(self, MersenneTwister, mt);
+
+  s = mt->state;
+
+  for(i = 0; i < N; s++) {
+    *s = NUM2UINT(rb_ary_entry(ary, i++));
+  }
+
+  mt->left = NUM2UINT(rb_ary_entry(ary, i));
+  mt->pNext = &(mt->state[N-mt->left]);
+
+  //  printf("set: left=%u, s-n=%u, s[0]=%u, s[623]=%u\n", 
+  //	 mt->left, mt->pNext - mt->state, mt->state[0], mt->state[623]);
+
+  return ary;
+}
+  
+static VALUE
+mt_load(VALUE klass, VALUE str)
+{
+  VALUE ary;
+  VALUE obj = rb_funcall(klass, rb_intern("new"), 1, INT2FIX(4357));
+
+  ary = rb_funcall(rb_eval_string("Marshal"), rb_intern("load"), 1, str);
+  mt_state_set(obj, ary);
+
+  return obj;
+}
+
+void Init_mersenne_twister_ext()
+{
+  // Require the base module and get references to the module and super class.
+  rb_require("random");
+  mRandom = rb_eval_string("Random");
+  cRandomNumberGenerator = rb_eval_string("Random::RandomNumberGenerator");
+
+  // Define the MT class itself and its allocator
+  cMersenneTwister = 
+    rb_define_class_under(mRandom, "MersenneTwister", cRandomNumberGenerator);
+  rb_define_alloc_func(cMersenneTwister, mt_alloc);
+
+  // Instance methods
+  rb_define_method(cMersenneTwister, "initialize", mt_initialize, -1);
+
+  rb_define_method(cMersenneTwister, "next", mt_gen_uint32, 0);
+  rb_define_method(cMersenneTwister, "gen_uint32", mt_gen_uint32, 0); 
+
+  rb_define_method(cMersenneTwister, "rand_int_small_limited", 
+		   mt_rand_int_small_limited, 1);
+
+  rb_define_method(cMersenneTwister, "rand_float", mt_rand_float, 0); 
+  rb_define_method(cMersenneTwister, "rand_float_excl", mt_rand_float_excl, 0);
+
+  rb_define_method(cMersenneTwister, "state", mt_state, 0);
+  rb_define_method(cMersenneTwister, "state=", mt_state_set, 1);
+  rb_define_method(cMersenneTwister, "marshal_dump", mt_state, 0);
+  rb_define_method(cMersenneTwister, "marshal_load", mt_state_set, 1);
+}