random 0.2.0

data/test/unit/test_chi_square.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+
+require 'math/statistics/chi_square'
+
+class TestChiSquare < Test::Unit::TestCase
+  def test_01_ensure_proper_parsing_of_file
+    assert_equal(nil,     Math::Statistics.critical_chi_square_value(1, 0.995))
+    assert_equal(nil,     Math::Statistics.critical_chi_square_value(1, 0.99))
+    assert_equal(0.001,   Math::Statistics.critical_chi_square_value(1, 0.975))
+    assert_equal(6.635,   Math::Statistics.critical_chi_square_value(1, 0.01))
+    assert_equal(7.879,   Math::Statistics.critical_chi_square_value(1, 0.005))
+
+    assert_equal(0.010,   Math::Statistics.critical_chi_square_value(2, 0.995))
+    assert_equal(0.020,   Math::Statistics.critical_chi_square_value(2, 0.99))
+    assert_equal(5.991,   Math::Statistics.critical_chi_square_value(2, 0.05))
+    assert_equal(10.597,  Math::Statistics.critical_chi_square_value(2, 0.005))
+
+    assert_equal(8.907,   Math::Statistics.critical_chi_square_value(19, 0.975))
+    assert_equal(38.582,  Math::Statistics.critical_chi_square_value(19, 0.005))
+
+    assert_equal(104.215, Math::Statistics.critical_chi_square_value(70, 0.005))
+
+    assert_equal(67.328,  Math::Statistics.critical_chi_square_value(100, 0.995))
+  end
+end

data/test/unit/test_mersenne_twister.rb

@@ -0,0 +1,131 @@
+require 'test/unit'
+
+require 'random'
+include Random
+
+class TestMersenneTwister < Test::Unit::TestCase
+  NumReps = 30
+  NumSmallReps = NumReps / 10
+
+  def test_01_initialize
+    mt1 = MersenneTwister.new
+    assert_kind_of(Random::MersenneTwister, mt)
+    assert_equal(0,          mt.min)
+    assert_equal(-1 + 2**32, mt.max)
+    
+    # Lets just check that we do not get the same value multiple times
+    # (which happens if the state has not been initialized for example)
+    first_10 = Array.new(10).map {mt1.next}
+    assert(10 == first_10.uniq.length,
+           "First 10 generated nums: #{first_10.inspect}")
+  end
+
+  def setup
+    @mt = MersenneTwister.new(rand(1e4))
+  end
+
+  # Default test object
+  def mt; @mt; end
+
+  def test_02_rand_int_limited
+    NumSmallReps.times do
+      assert_chi_square {mt.rand_int_limited(10)}
+    end
+  end
+
+  def take_next(num, rng)
+    Array.new(num).map {rng.next}
+  end
+
+  def assert_next(num, mt1, mt2)
+    assert_equal(take_next(num, mt1), take_next(num, mt2))
+  end
+
+  def test_03_same_seed_gives_same_sequence
+    NumReps.times do
+      seed = rand(1e6)
+      mt1, mt2 = MersenneTwister.new(seed), MersenneTwister.new(seed)
+      assert_next(1000, mt1, mt2)
+    end
+  end
+
+  def test_04_different_seed_gives_different_sequence
+    NumReps.times do
+      seed = rand(1e6)
+      mt1 = MersenneTwister.new(seed)
+      mt2 = MersenneTwister.new(seed+1+rand(1e3))
+      assert(take_next(100, mt1) != take_next(100, mt2))
+    end
+  end
+
+  def test_05_rand_float
+    NumSmallReps.times do
+      assert_chi_square {(10.0 * mt.rand_float).floor}
+    end
+  end
+
+  def test_06_rand_without_arg
+    NumSmallReps.times do
+      assert_chi_square do
+        rv = mt.rand()
+        assert_kind_of(Float, rv)
+        (10.0 * rv).floor
+      end
+    end
+  end
+
+  def test_07_rand_with_small_int_arg
+    NumSmallReps.times do
+      df = Math::Statistics.valid_degrees_of_freedom.random_element
+      limit = df + 1
+      assert_chi_square do
+        rv = mt.rand(limit)
+        assert(rv.kind_of?(Fixnum) && rv >= 0 && rv < limit)
+        rv
+      end
+    end
+  end
+
+  def test_08_state
+    NumReps.times do
+      s = mt.state
+      assert_kind_of(Array, s)
+      assert_equal(624+1, s.length)
+      s.each {|e| assert(Integer === e)}
+    end
+  end
+
+  def test_09_state_set
+    NumReps.times do
+      mt1 = MersenneTwister.new(rand(1e6))
+      state_taken_at = rand(1e3)
+      state_taken_at.times {mt1.next}
+      state = mt1.state
+      assert_kind_of(Array, state)
+      assert_equal(624+1, state.length)
+      mt2 = MersenneTwister.new(rand(1e6))
+      mt2.state = state
+      assert_equal(mt1.state, mt2.state)
+      assert_equal(state,     mt1.state)
+      assert_next(1000, mt1, mt2)
+    end
+  end
+
+  def test_10_marshaling
+    NumReps.times do
+      mt1 = MersenneTwister.new(rand(1e6))
+      state_taken_at = rand(1e3)
+      state_taken_at.times {mt1.next}
+      mstr1 = Marshal.dump(mt1)
+      mt2 = Marshal.load(mstr1)
+      assert_next(1000, mt1, mt2)
+      assert_equal(Marshal.dump(mt1), Marshal.dump(mt2))
+    end
+  end
+
+  def test_11_rand
+    assert_rand(mt)
+    assert_chi_square        {mt.rand(2)}
+    assert_chi_square_floats {mt.rand}
+  end
+end

data/test/unit/test_random_number_generator.rb

@@ -0,0 +1,168 @@
+require 'test/unit'
+
+require 'random/random_number_generator'
+include Random
+
+# Mock sub-class that implements next simply by taking values from an array.
+class MockRNG < Random::RandomNumberGenerator
+  def initialize(*values)
+    @values, @len = values, values.length
+    @index = 0
+  end
+
+  def next
+    n = @values[@index]
+    @index = (@index + 1) % @len
+    n
+  end
+
+  def marshal_dump; [@values, @index]; end
+  def marshal_load(ary)
+    @values, @index = ary
+    @len = @values.length
+  end
+
+  # Lift protected methods so we can test them
+  public :calc_mask, :mask, :num_bits_to_represent, :mask_for_int, :add_bits
+end
+
+class TestRandomNumberGenerator < Test::Unit::TestCase
+  NumReps = 30
+  NumSmallReps = NumReps / 10
+
+  attr_reader :rng
+
+  def setup
+    @rng = MockRNG.new(*(0..1000))
+  end
+
+  def test_01_initialize
+    assert_kind_of(MockRNG, rng)
+    assert_equal(0,         rng.min)
+    assert_equal(2**32-1,   rng.max)
+    assert_equal(32,        rng.num_random_bits)
+    assert_equal(4,         rng.num_random_bytes)
+  end
+
+  def test_02_calc_mask
+    assert_equal(0b0000, rng.calc_mask(0))
+    assert_equal(0b0001, rng.calc_mask(1))
+    assert_equal(0b0011, rng.calc_mask(2))
+    assert_equal(0b0111, rng.calc_mask(3))
+    assert_equal(0b1111, rng.calc_mask(4))
+    assert_equal(0x1f,   rng.calc_mask(5))
+    assert_equal(0x3f,   rng.calc_mask(6))
+    assert_equal(0x7f,   rng.calc_mask(7))
+    assert_equal(0xff,   rng.calc_mask(8))
+    (9..65).each {|i| assert_equal(2**i - 1, rng.calc_mask(i))}
+    assert_equal(2**1000 - 1, rng.calc_mask(1000))
+  end
+
+  def test_03_mask
+    assert_equal(0b0000, rng.mask(0))
+    assert_equal(0b0001, rng.mask(1))
+    assert_equal(0b0011, rng.mask(2))
+    assert_equal(0b0111, rng.mask(3))
+    assert_equal(0b1111, rng.mask(4))
+    assert_equal(0x1f,   rng.mask(5))
+    assert_equal(0x3f,   rng.mask(6))
+    assert_equal(0x7f,   rng.mask(7))
+    assert_equal(0xff,   rng.mask(8))
+    (9..65).each {|i| assert_equal(2**i - 1, rng.mask(i))}
+    assert_equal(2**1000 - 1, rng.mask(1000))
+  end
+
+  def test_04_num_bits
+    (0..1).each {|i| assert_equal(1, rng.num_bits_to_represent(i))}
+    (2..3).each {|i| assert_equal(2, rng.num_bits_to_represent(i))}
+    (4..7).each {|i| assert_equal(3, rng.num_bits_to_represent(i))}
+    (8..15).each {|i| assert_equal(4, rng.num_bits_to_represent(i))}
+    (16..31).each {|i| assert_equal(5, rng.num_bits_to_represent(i))}
+    (32..63).each {|i| assert_equal(6, rng.num_bits_to_represent(i))}
+    assert_equal(7, rng.num_bits_to_represent(64))
+    assert_equal(8, rng.num_bits_to_represent(128))
+    assert_equal(1023, rng.num_bits_to_represent(2**1023-1))
+    assert_equal(1024, rng.num_bits_to_represent(2**1023))
+    assert_equal(1025, rng.num_bits_to_represent(2**1024))
+    assert_equal(2048, rng.num_bits_to_represent(2**2048-1))
+    assert_equal(2049, rng.num_bits_to_represent(2**2048))
+  end
+
+  def test_05_mask_for_int
+    assert_equal(0x0001, rng.mask_for_int(0))
+    assert_equal(0x0001, rng.mask_for_int(1))
+    assert_equal(0x0003, rng.mask_for_int(2))
+    assert_equal(0x0003, rng.mask_for_int(3))
+    assert_equal(0x0007, rng.mask_for_int(7))
+    assert_equal(0x000f, rng.mask_for_int(13))
+  end
+
+  def collect_samples(numSamples = 1e4, &block)
+    counts = Hash.new(0)
+    numSamples.to_i.times {counts[block.call] += 1}
+    counts
+  end
+
+  def test_06_rand_int_limited
+    samples = collect_samples {rng.rand_int_limited(0)}
+    assert_equal((0..0).to_a, samples.keys.sort) 
+
+    samples = collect_samples {rng.rand_int_limited(1)}
+    assert_equal((0..1).to_a, samples.keys.sort)
+
+    samples = collect_samples {rng.rand_int_limited(10)}
+    assert_equal((0..10).to_a, samples.keys.sort)
+
+    samples = collect_samples {rng.rand_int_limited(30)}
+    assert_equal((0..30).to_a, samples.keys.sort)
+  end
+
+  def test_07_rand_num
+    samples = collect_samples {rng.rand_num(7, 7)}
+    assert_equal((7..7).to_a, samples.keys.sort) 
+
+    samples = collect_samples {rng.rand_num(32, 34)}
+    assert_equal((32..34).to_a, samples.keys.sort)
+
+    samples = collect_samples {rng.rand_num(1, 6)}
+    assert_equal((1..6).to_a, samples.keys.sort)    
+  end
+
+  def test_08_rand_bytes
+    rng = MockRNG.new(0x01020304, 0x050607ff)
+    assert_equal(4.chr, rng.rand_bytes(1))
+    assert_equal(0xff.chr + 7.chr, rng.rand_bytes(2))
+    assert_equal(4.chr + 3.chr + 2.chr, rng.rand_bytes(3))
+    assert_equal(0xff.chr + 7.chr + 6.chr + 5.chr, rng.rand_bytes(4))
+    assert_equal(4.chr + 3.chr + 2.chr + 1.chr + 0xff.chr, rng.rand_bytes(5))
+
+    assert_equal(4.chr + 3.chr + 2.chr + 1.chr + 0xff.chr + 7.chr, 
+                 rng.rand_bytes(6))
+    assert_equal(4.chr + 3.chr + 2.chr + 1.chr + 0xff.chr + 7.chr + 6.chr, 
+                 rng.rand_bytes(7))
+    assert_equal(4.chr + 3.chr + 2.chr + 1.chr + 
+                 0xff.chr + 7.chr + 6.chr + 5.chr, 
+                 rng.rand_bytes(8))
+    assert_equal(4.chr + 3.chr + 2.chr + 1.chr + 
+                 0xff.chr + 7.chr + 6.chr + 5.chr +
+                 4.chr, 
+                 rng.rand_bytes(9))
+  end
+
+  def test_09_add_bits
+    assert_equal(0,      rng.add_bits(0, 0, 1))
+    assert_equal(1,      rng.add_bits(0, 1, 1))
+    assert_equal(2,      rng.add_bits(0, 2, 2))
+    assert_equal(3,      rng.add_bits(0, 2, 3))
+    assert_equal(7,      rng.add_bits(1, 2, 3))
+    assert_equal(3,      rng.add_bits(0, 2, 7))
+    assert_equal(10,     rng.add_bits(5, 1, 2))
+    assert_equal(0xffff, rng.add_bits(1, 15, 0xffff))
+    assert_equal(0xfff,  rng.add_bits(0, 12, 0xffff))
+    assert_equal(-1 + 2**64,  rng.add_bits(3, 62, -1 + 2**64))
+  end
+
+  def test_10_rand
+    assert_rand(rng)
+  end
+end

data/test/unit/test_random_testing.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+
+require 'random/testing'
+include Random
+
+class TestRandomTesting < Test::Unit::TestCase
+  def test_01_totally_uniform_should_easily_pass
+    assert(Testing.chi_square_test({0 => 5000, 1 => 5000}, 0.1))
+    assert(Testing.chi_square_test({0 => 2500, 1 => 2500,
+                                    2 => 2500, 3 => 2500}, 0.1))
+  end
+
+  def assert_false(v)
+    assert(v ? false : true)
+  end
+
+  def test_02_totally_nonuniform_should_fail
+    assert_false(Testing.chi_square_test({0 => 0, 1 => 10000}, 0.005))
+    assert_false(Testing.chi_square_test({0 => 10, 1 => 10,
+                                           2 => 9970, 3 => 10}, 0.005))
+  end
+end

data/test/unit/test_rng.rb

@@ -0,0 +1,9 @@
+require 'test/unit'
+
+require 'random'
+
+class TestRNG < Test::Unit::TestCase
+  def test_01_MersenneTwister_is_the_default_RNG
+    assert_equal(Random::MersenneTwister, Random::RNG)
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: random
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+date: 2006-04-13 00:00:00 +02:00
+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).
+require_paths: 
+- lib
+- ext
+- lib
+email: Robert.Feldt@gmail.com
+homepage: http://www.rubyforge.org/projects/random
+rubyforge_project: 
+description: 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.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- Robert Feldt
+files: 
+- 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/simple_example.rb
+- test/acceptance/wagner_distribution_1_0
+- test/acceptance/wagner_distribution_1_0/testWagner.out
+- test/acceptance/wagner_distribution_1_0/test_compare_to_wagners_test_output.rb
+- test/performance/test_mersenne_twister.rb
+- test/unit/expected_mersenne_4357.txt
+- test/unit/test_mersenne_twister.rb
+- test/unit/test_random_testing.rb
+- test/unit/test_rng.rb
+- test/unit/test_chi_square.rb
+- test/unit/#mt19937ar.c#
+- test/unit/test_random_number_generator.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/random/extconf.rb
+requirements: []
+
+dependencies: []
+