fibonacci_rng 1.2.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4999cbec6a694cd39c97612604da2d3aef472ebc
-  data.tar.gz: 6615b8208ac015d76658f2b07cb4509832342e5c
+  metadata.gz: dff4345e5771a9194053e94d27556d1fee55e67c
+  data.tar.gz: 719c15db8a33d8308a41175ea371923e55d3352f
 SHA512:
-  metadata.gz: 77e649c937622ba4b341ce2d2da7a98a46a030455f323a93fcf21382302ce5306fcb3135ef730fc83681abc2d888747124dd82ddae664602540c9f8b15094ede
-  data.tar.gz: 43afbd3b1ae190f3c50f91ad01c41d238709bbbc456a9b46d77a91a98fb728a51339a69d69055286d0e47d7ef2a2c3866c43d5009798b70c968b2f1daa2a6f46
+  metadata.gz: 11c14fa2466aaffdc31e98f67c6d930c204e27dbc1c2c5f43efa7bfba111912f4ee24c993b7850ed0396697016aa1189704c0130cebadf1795bd49e8f1d6251c
+  data.tar.gz: dd5df2c9398baeb1fd6b25c5ee499895c5125fd910c03f2ad87dd7f47019b72fabe92939564b2db17ac361f7641eccb54088cef52cee6b0e94c0611c45793819

data/README.md

@@ -268,6 +268,27 @@ TOP  = 0x10000000
 
 ```
 
+## Error Detection
+
+Like all systems, the fibonacci random number generator has a failure mode. If
+it should happen that all the internal data registers have a value of zero, the
+generator will be trapped in an endless state of zero output. It will cease to
+operate as a pseudo random number generator.
+
+While it is possible to show that this cannot occur in small generators, the
+case for larger ones is more difficult to analyze. To this end, the code now
+incorporates a test that at least one non-zero register is present. If this
+test should fail an exception "InvalidFibonacciRngState" is raised so that
+the application can take appropriate action.
+
+To date, torture testing of the generator has yielded no failures, but this is
+not a proof that one cannot happen.
+
+The test scans the registers until it finds a non-zero value. This means that
+it almost always only needs to look at one register, saving a great deal of
+execution time.
+
+
 ## Contributing
 
 Creating a good pseudo random number generator is quite an undertaking. For

data/fibonacci_rng.gemspec

@@ -9,10 +9,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Peter Camilleri"]
   spec.email         = ["peter.c.camilleri@gmail.com"]
   spec.homepage      = "https://github.com/PeterCamilleri/fibonacci_rng"
-  spec.description   = "A Fibonacci inspired pseudo random number generator. " +
-                       "[Updated] The algorithm is changed to use bit rotate " +
-                       "instead of bit shift."
-  spec.summary       = "[Updated] A Fibonacci inspired pseudo random number generator."
+  spec.description   = "A Fibonacci inspired pseudo random number generator " +
+                       "with error detection."
+  spec.summary       = "A Fibonacci inspired pseudo random number generator."
   spec.license       = "MIT"
 
   raw_list = `git ls-files`.split($/)
@@ -20,7 +19,7 @@ Gem::Specification.new do |spec|
 
   spec.files         = raw_list
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.test_files    = spec.files.grep(%r{^(test)/})
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 1.9.3'

data/lib/fibonacci_rng.rb

@@ -4,6 +4,7 @@ require_relative "fibonacci_rng/seeder"
 require_relative "fibonacci_rng/hasher"
 require_relative "fibonacci_rng/spinner"
 require_relative "fibonacci_rng/generator"
+require_relative "fibonacci_rng/validate"
 require_relative "fibonacci_rng/version"
 
 #The class of Fibonacci inspired random number generators.

data/lib/fibonacci_rng/generator.rb

@@ -25,12 +25,14 @@ class FibonacciRng
       do_spin
     end until (value = @buffer[0]) < limit
 
+    validate
     value % sides
   end
 
   #Get a pseudo random byte
   def byte
     do_spin
+    validate
     @buffer[0] & BYTE
   end
 
@@ -44,12 +46,14 @@ class FibonacciRng
   #Get a pseudo random word
   def word
     do_spin
+    validate
     @buffer[0] & WORD
   end
 
   #Get a pseudo random float
   def float
     do_spin
+    validate
     raw_float / BASE
   end
 
@@ -58,6 +62,7 @@ class FibonacciRng
     do_spin
     part_one = raw_float * BASE
     do_spin
+    validate
     (part_one + raw_float) / DOUBLE
   end
 

data/lib/fibonacci_rng/hasher.rb

@@ -22,6 +22,7 @@ class FibonacciRng
     end
 
     do_spin if str.empty?
+    validate
   end
 
   private
@@ -32,6 +33,7 @@ class FibonacciRng
     do_spin
     @buffer[index] += value
     do_spin
+    validate
   end
 
 end

data/lib/fibonacci_rng/spinner.rb

@@ -8,6 +8,8 @@ class FibonacciRng
     count.times do
       do_spin
     end
+    
+    validate
   end
 
   private

data/lib/fibonacci_rng/validate.rb

@@ -0,0 +1,18 @@
+# coding: utf-8
+
+# The class of RNG errors.
+class InvalidFibonacciRngState < RuntimeError; end
+
+#The class of Fibonacci inspired random number generators.
+class FibonacciRng
+
+  #Validate the sanity of the generator.
+  def validate
+    @buffer.each do |element| 
+      return true unless element.zero?
+    end
+    
+    fail InvalidFibonacciRngState
+  end
+
+end

data/lib/fibonacci_rng/version.rb

@@ -2,5 +2,5 @@
 
 #The class of Fibonacci inspired random number generators.
 class FibonacciRng
-  VERSION = "1.2.5"
+  VERSION = "2.0.0"
 end

data/prng.rb

@@ -21,7 +21,7 @@ module PrngTestSuite
     puts "Where:"
     puts "  <locn>  fib code location, either 'gem' or 'local'"
     puts "  <gen>   select a generator, either 'fib' or 'int'"
-    puts "  <test>  select a test, either 'chisq', 'auto', or 'scatter'"
+    puts "  <test>  select one of 'chisq', 'auto', 'scatter', or 'torture'"
     puts "  <max>   the number of bins to test    (2..65535)"
     puts "  <count> the number of samples to test (1..1000000)"
     puts
@@ -45,6 +45,7 @@ require_relative 'tools/internal_rng'
 require_relative 'tools/chi_squared'
 require_relative 'tools/auto_corr'
 require_relative 'tools/scatter_plot'
+require_relative 'tools/torture_test'
 
 module PrngTestSuite
 
@@ -63,6 +64,8 @@ module PrngTestSuite
       tester = AutoCorrelator.new
     elsif ARGV[2] == 'scatter'
       tester = ScatterPlot.new
+    elsif ARGV[2] == 'torture'
+      tester = TortureTest.new
     else
       PrngTestSuite.usage "Error: missing or invalid test parameter."
     end

data/tests/fibinacci_rng_tests.rb

@@ -1,251 +1,289 @@
-# coding: utf-8
-
-require_relative '../lib/fibonacci_rng'
-gem              'minitest'
-require          'minitest/autorun'
-require          'minitest_visible'
-
-#Test the monkey patches applied to the Object class.
-class FibonacciRngTester < Minitest::Test
-
-  #Track mini-test progress.
-  include MinitestVisible
-
-  def test_how_we_build_generators
-    gen = FibonacciRng.new
-    assert_equal(8, gen.depth)
-    assert_equal(String, gen.seed.class)
-    assert_equal(1024, gen.init)
-
-    gen = FibonacciRng.new('seed')
-    assert_equal(8, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(1024, gen.init)
-
-    gen = FibonacciRng.new('seed', 12)
-    assert_equal(12, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(1152, gen.init)
-
-    gen = FibonacciRng.new('seed', 12, 2048)
-    assert_equal(12, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(2048, gen.init)
-  end
-
-  def test_building_with_keywords
-    gen = FibonacciRng.new(seed: 'seed')
-    assert_equal(8, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(1024, gen.init)
-
-    gen = FibonacciRng.new(depth: 12)
-    assert_equal(12, gen.depth)
-    assert_equal(String, gen.seed.class)
-    assert_equal(1152, gen.init)
-
-    gen = FibonacciRng.new(seed: 'seed', depth: 12)
-    assert_equal(12, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(1152, gen.init)
-
-    gen = FibonacciRng.new(depth: 12, seed: 'seed')
-    assert_equal(12, gen.depth)
-    assert_equal('seed', gen.seed)
-    assert_equal(1152, gen.init)
-
-    gen = FibonacciRng.new(seed: 'seed', init: 2048)
-    assert_equal('seed', gen.seed)
-    assert_equal(2048, gen.init)
-  end
-
-  def test_that_rejects_bad_parms
-    assert_raises { FibonacciRng.new('seed', 1) }
-    assert_raises { FibonacciRng.new('seed', 65536) }
-  end
-
-  def test_that_it_creates_dice_rolls
-    prng = FibonacciRng.new
-
-    100.times do
-      assert((0...6) === prng.dice(6))
-    end
-  end
-
-  def test_that_it_creates_bytes
-    prng = FibonacciRng.new
-
-    100.times do
-      assert((0...256) === prng.byte)
-    end
-  end
-
-  def test_that_it_creates_words
-    prng = FibonacciRng.new
-
-    100.times do
-      assert((0...65536) === prng.word)
-    end
-  end
-
-  def test_that_it_creates_floats
-    prng = FibonacciRng.new
-
-    100.times do
-      value = prng.float
-      assert((value >= 0.0) && (value < 1.0))
-    end
-  end
-
-  def test_compatible_global_dice_rolls
-    100.times do
-      assert((0...6) === FibonacciRng.rand(6))
-    end
-  end
-
-  def test_compatible_global_dice_rolls_range
-    100.times do
-      assert((0...6) === FibonacciRng.rand(0...6))
-    end
-  end
-
-  def test_compatible_global_floats
-    100.times do
-      value = FibonacciRng.rand(0)
-      assert((value >= 0.0) && (value < 1.0))
-    end
-  end
-
-  def test_random_string
-    prng = FibonacciRng.new
-
-    rs = prng.bytes(10)
-
-    assert(rs.is_a?(String))
-    assert_equal(10, rs.length)
-  end
-
-  def test_that_it_makes_unique_sequences
-    prnga = FibonacciRng.new
-    prngb = FibonacciRng.new
-
-    buffa = []
-    buffb = []
-
-    100.times do
-      buffa << prnga.dice(6)
-      buffb << prngb.dice(6)
-    end
-
-    assert(buffa != buffb)
-  end
-
-  def test_that_it_makes_repeatable_sequences
-    prnga = FibonacciRng.new(0)
-    prngb = FibonacciRng.new(0)
-
-    buffa = []
-    buffb = []
-
-    100.times do
-      buffa << prnga.dice(6)
-      buffb << prngb.dice(6)
-    end
-
-    assert(buffa == buffb)
-  end
-
-  def test_that_it_creates_unique_seeds
-    result = []
-    10_000.times do
-      result << FibonacciRng.new_seed
-    end
-
-    result.uniq!
-    assert_equal(10_000, result.length)
-  end
-
-  def test_building_strings
-    rng = FibonacciRng.new(0)
-    assert_equal("c}l'(q@g\\z", rng.string(10))
-    assert_equal('2727573312', rng.string(10, '0123456789'))
-    assert_equal('khto lk si', rng.string(10, 'Always look on the bright side of life.'))
-
-    rng = FibonacciRng.new("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
-    assert_equal(",-+Idi6~ ~", rng.string(10))
-    assert_equal('5901964804', rng.string(10, '0123456789'))
-  end
-
-  def test_for_data_stability
-    #Make sure incompatibilities do not creep in.
-    expected = [184,  93,   0, 240,  34, 184,   4, 220, 126, 132,
-                 13,  67, 166, 107, 165,  66,  68, 120, 102, 110,
-                212,  99,  80, 167,   9,  56,  47, 167, 127, 195,
-                169,  34, 184,  97, 136, 176, 214, 104, 218, 103,
-                180,  16,  83, 204, 128,  81,  63,  56, 237, 165,
-                  0,  88, 129,  40, 152,  44, 189,  35, 205, 249,
-                 77,  94, 142,  18,  60, 248,  49, 172, 235,  83,
-                 84,  65, 181, 117,  16, 170, 222,  97, 130, 217]
-
-    prng = FibonacciRng.new("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
-    result = Array.new(80) { prng.byte }
-    assert_equal(expected, result)
-
-    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
-    result = Array.new(80) { prng.byte }
-    assert_equal(expected, result)
-
-
-    expected = [0.466758593916893,    0.8060004059225321,
-                0.8063845634460449,   0.8676037490367889,
-                0.350975576788187,    0.2556227296590805,
-                0.4873242452740669,   0.07484667748212814,
-                0.2968141995370388,   0.5417192056775093,
-                0.4288134817034006,   0.26460993848741055,
-                0.13613684102892876,  0.27074786089360714,
-                0.11685592867434025,  0.814235333353281,
-                0.6137734726071358,   0.9152738898992538,
-                0.6325213424861431,   0.22782298550009727,
-                0.6877559795975685,   0.9354030545800924,
-                0.18385234475135803,  0.5579136144369841,
-                0.7501311469823122,   0.04208622872829437,
-                0.31922253780066967,  0.6471036206930876,
-                0.4305369835346937,   0.2239683922380209,
-                0.9770196247845888,   0.3727417625486851]
-
-    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
-    result = Array.new(32) { prng.float }
-    #assert_equal(expected, result)
-
-    (0...32).each do |i|
-      assert_in_delta(expected[i], result[i], 1.0e-16)
-    end
-
-    expected = [0.46675859541818576,  0.8063845650620829,
-                0.3509755772643215,   0.48732424541347974,
-                0.29681420054606944,  0.428813482196275,
-                0.13613684153323594,  0.11685593019097174,
-                0.6137734743119663,   0.6325213429104964,
-                0.6877559813398925,   0.18385234579055312,
-                0.7501311470607039,   0.31922253900599407,
-                0.43053698395186735,  0.9770196254788744,
-                0.105776653432334,    0.17992045162625886,
-                0.7068137351637119,   0.09374992924495854,
-                0.4741257221497737,   0.2717329622804037,
-                0.6427948478921109,   0.048162101812947195,
-                0.649627174383166,    0.27438020721066836,
-                0.9478733559036244,   0.6199505789910625,
-                0.8043054302444751,   0.9363898295339244,
-                0.6613804354420972,   0.5876014495519649]
-
-    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
-    result = Array.new(32) { prng.double }
-    #assert_equal(expected, result)
-
-    (0...32).each do |i|
-      assert_in_delta(expected[i], result[i], 1.0e-16)
-    end
-
-  end
-
-end
+# coding: utf-8
+
+require_relative '../lib/fibonacci_rng'
+gem              'minitest'
+require          'minitest/autorun'
+require          'minitest_visible'
+
+#Test the monkey patches applied to the Object class.
+class FibonacciRngTester < Minitest::Test
+
+  #Track mini-test progress.
+  include MinitestVisible
+
+  def test_how_we_build_generators
+    gen = FibonacciRng.new
+    assert(gen.validate)
+    assert_equal(8, gen.depth)
+    assert_equal(String, gen.seed.class)
+    assert_equal(1024, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new('seed')
+    assert(gen.validate)
+    assert_equal(8, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(1024, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new('seed', 12)
+    assert(gen.validate)
+    assert_equal(12, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(1152, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new('seed', 12, 2048)
+    assert(gen.validate)
+    assert_equal(12, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(2048, gen.init)
+    assert(gen.validate)
+  end
+
+  def test_building_with_keywords
+    gen = FibonacciRng.new(seed: 'seed')
+    assert(gen.validate)
+    assert_equal(8, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(1024, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new(depth: 12)
+    assert(gen.validate)
+    assert_equal(12, gen.depth)
+    assert_equal(String, gen.seed.class)
+    assert_equal(1152, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new(seed: 'seed', depth: 12)
+    assert(gen.validate)
+    assert_equal(12, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(1152, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new(depth: 12, seed: 'seed')
+    assert(gen.validate)
+    assert_equal(12, gen.depth)
+    assert_equal('seed', gen.seed)
+    assert_equal(1152, gen.init)
+    assert(gen.validate)
+
+    gen = FibonacciRng.new(seed: 'seed', init: 2048)
+    assert(gen.validate)
+    assert_equal('seed', gen.seed)
+    assert_equal(2048, gen.init)
+    assert(gen.validate)
+  end
+
+  def test_that_it_detects_fatal_conditions
+    gen = FibonacciRng.new
+    assert(gen.validate)
+
+    gen.define_singleton_method(:kill) do
+      @buffer = Array.new(@buffer.length, 0)
+    end
+
+    gen.kill #Force a fatal error condition.
+
+    assert_raises(InvalidFibonacciRngState) {gen.validate}
+    assert_raises(InvalidFibonacciRngState) {gen.spin(6)}
+    assert_raises(InvalidFibonacciRngState) {gen.dice(6)}
+    assert_raises(InvalidFibonacciRngState) {gen.byte}
+    assert_raises(InvalidFibonacciRngState) {gen.word}
+    assert_raises(InvalidFibonacciRngState) {gen.float}
+    assert_raises(InvalidFibonacciRngState) {gen.double}
+
+  end
+
+  def test_that_rejects_bad_parms
+    assert_raises { FibonacciRng.new('seed', 1) }
+    assert_raises { FibonacciRng.new('seed', 65536) }
+  end
+
+  def test_that_it_creates_dice_rolls
+    prng = FibonacciRng.new
+
+    100.times do
+      assert((0...6) === prng.dice(6))
+    end
+  end
+
+  def test_that_it_creates_bytes
+    prng = FibonacciRng.new
+
+    100.times do
+      assert((0...256) === prng.byte)
+    end
+  end
+
+  def test_that_it_creates_words
+    prng = FibonacciRng.new
+
+    100.times do
+      assert((0...65536) === prng.word)
+    end
+  end
+
+  def test_that_it_creates_floats
+    prng = FibonacciRng.new
+
+    100.times do
+      value = prng.float
+      assert((value >= 0.0) && (value < 1.0))
+    end
+  end
+
+  def test_compatible_global_dice_rolls
+    100.times do
+      assert((0...6) === FibonacciRng.rand(6))
+    end
+  end
+
+  def test_compatible_global_dice_rolls_range
+    100.times do
+      assert((0...6) === FibonacciRng.rand(0...6))
+    end
+  end
+
+  def test_compatible_global_floats
+    100.times do
+      value = FibonacciRng.rand(0)
+      assert((value >= 0.0) && (value < 1.0))
+    end
+  end
+
+  def test_random_string
+    prng = FibonacciRng.new
+
+    rs = prng.bytes(10)
+
+    assert(rs.is_a?(String))
+    assert_equal(10, rs.length)
+  end
+
+  def test_that_it_makes_unique_sequences
+    prnga = FibonacciRng.new
+    prngb = FibonacciRng.new
+
+    buffa = []
+    buffb = []
+
+    100.times do
+      buffa << prnga.dice(6)
+      buffb << prngb.dice(6)
+    end
+
+    assert(buffa != buffb)
+  end
+
+  def test_that_it_makes_repeatable_sequences
+    prnga = FibonacciRng.new(0)
+    prngb = FibonacciRng.new(0)
+
+    buffa = []
+    buffb = []
+
+    100.times do
+      buffa << prnga.dice(6)
+      buffb << prngb.dice(6)
+    end
+
+    assert(buffa == buffb)
+  end
+
+  def test_that_it_creates_unique_seeds
+    result = []
+    10_000.times do
+      result << FibonacciRng.new_seed
+    end
+
+    result.uniq!
+    assert_equal(10_000, result.length)
+  end
+
+  def test_building_strings
+    rng = FibonacciRng.new(0)
+    assert_equal("c}l'(q@g\\z", rng.string(10))
+    assert_equal('2727573312', rng.string(10, '0123456789'))
+    assert_equal('khto lk si', rng.string(10, 'Always look on the bright side of life.'))
+
+    rng = FibonacciRng.new("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
+    assert_equal(",-+Idi6~ ~", rng.string(10))
+    assert_equal('5901964804', rng.string(10, '0123456789'))
+  end
+
+  def test_for_data_stability
+    #Make sure incompatibilities do not creep in.
+    expected = [184,  93,   0, 240,  34, 184,   4, 220, 126, 132,
+                 13,  67, 166, 107, 165,  66,  68, 120, 102, 110,
+                212,  99,  80, 167,   9,  56,  47, 167, 127, 195,
+                169,  34, 184,  97, 136, 176, 214, 104, 218, 103,
+                180,  16,  83, 204, 128,  81,  63,  56, 237, 165,
+                  0,  88, 129,  40, 152,  44, 189,  35, 205, 249,
+                 77,  94, 142,  18,  60, 248,  49, 172, 235,  83,
+                 84,  65, 181, 117,  16, 170, 222,  97, 130, 217]
+
+    prng = FibonacciRng.new("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
+    result = Array.new(80) { prng.byte }
+    assert_equal(expected, result)
+
+    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
+    result = Array.new(80) { prng.byte }
+    assert_equal(expected, result)
+
+
+    expected = [0.466758593916893,    0.8060004059225321,
+                0.8063845634460449,   0.8676037490367889,
+                0.350975576788187,    0.2556227296590805,
+                0.4873242452740669,   0.07484667748212814,
+                0.2968141995370388,   0.5417192056775093,
+                0.4288134817034006,   0.26460993848741055,
+                0.13613684102892876,  0.27074786089360714,
+                0.11685592867434025,  0.814235333353281,
+                0.6137734726071358,   0.9152738898992538,
+                0.6325213424861431,   0.22782298550009727,
+                0.6877559795975685,   0.9354030545800924,
+                0.18385234475135803,  0.5579136144369841,
+                0.7501311469823122,   0.04208622872829437,
+                0.31922253780066967,  0.6471036206930876,
+                0.4305369835346937,   0.2239683922380209,
+                0.9770196247845888,   0.3727417625486851]
+
+    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
+    result = Array.new(32) { prng.float }
+    #assert_equal(expected, result)
+
+    (0...32).each do |i|
+      assert_in_delta(expected[i], result[i], 1.0e-16)
+    end
+
+    expected = [0.46675859541818576,  0.8063845650620829,
+                0.3509755772643215,   0.48732424541347974,
+                0.29681420054606944,  0.428813482196275,
+                0.13613684153323594,  0.11685593019097174,
+                0.6137734743119663,   0.6325213429104964,
+                0.6877559813398925,   0.18385234579055312,
+                0.7501311470607039,   0.31922253900599407,
+                0.43053698395186735,  0.9770196254788744,
+                0.105776653432334,    0.17992045162625886,
+                0.7068137351637119,   0.09374992924495854,
+                0.4741257221497737,   0.2717329622804037,
+                0.6427948478921109,   0.048162101812947195,
+                0.649627174383166,    0.27438020721066836,
+                0.9478733559036244,   0.6199505789910625,
+                0.8043054302444751,   0.9363898295339244,
+                0.6613804354420972,   0.5876014495519649]
+
+    prng.reseed("%s*08^_Tg{NnirtZ-94)q9z2l+~bB5")
+    result = Array.new(32) { prng.double }
+    #assert_equal(expected, result)
+
+    (0...32).each do |i|
+      assert_in_delta(expected[i], result[i], 1.0e-16)
+    end
+
+  end
+
+end

data/tools/torture_test.rb

@@ -0,0 +1,27 @@
+# coding: utf-8
+
+#A Scatter Plot tester
+class TortureTest
+
+  #Run a scatter plot test on the random number generator.
+  def run(gen, max, count)
+    max   *=1000
+    count *=1000
+
+    puts "Starting torture test with #{max} loops of #{count} tests."
+
+    max.times do |i|
+      gen.spin(count)
+      print (i+1).to_s.rjust(8)
+    end
+
+    puts
+    puts "No errors were detected."
+    return
+
+    rescue InvalidFibonacciRngState
+      puts
+      puts "InvalidFibonacciRngState detected."
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fibonacci_rng
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Peter Camilleri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-15 00:00:00.000000000 Z
+date: 2018-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -94,8 +94,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.5'
-description: A Fibonacci inspired pseudo random number generator. [Updated] The algorithm
-  is changed to use bit rotate instead of bit shift.
+description: A Fibonacci inspired pseudo random number generator with error detection.
 email:
 - peter.c.camilleri@gmail.com
 executables: []
@@ -115,6 +114,7 @@ files:
 - lib/fibonacci_rng/hasher.rb
 - lib/fibonacci_rng/seeder.rb
 - lib/fibonacci_rng/spinner.rb
+- lib/fibonacci_rng/validate.rb
 - lib/fibonacci_rng/version.rb
 - prng.rb
 - rakefile.rb
@@ -125,6 +125,7 @@ files:
 - tools/chi_squared.rb
 - tools/internal_rng.rb
 - tools/scatter_plot.rb
+- tools/torture_test.rb
 homepage: https://github.com/PeterCamilleri/fibonacci_rng
 licenses:
 - MIT
@@ -145,9 +146,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
-summary: "[Updated] A Fibonacci inspired pseudo random number generator."
+summary: A Fibonacci inspired pseudo random number generator.
 test_files: []
-has_rdoc: