cheap_random 0.9.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+doc/
+random/
+

data/LICENSE.md

@@ -0,0 +1,20 @@
+Copyright (c) 2006 - 2012 Bardi Einarsson
+
+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,85 @@
+CheapRandom
+============
+
+Description
+-----------
+**CheapRandom** is a set of tools for pseudo random number generation from arbitrary data. The properties of the **CheapRandom seed** make convenient random number generation possible -- useful for easily repeatable software testing. The **CheapRandom algorithm** is information conserving and generally appears to produce lower chi-squared statistics than **Kernel::rand** i.e. it appears to be more random. The **CheapRandom algorithm**, an original work by Bardi Einarsson, has been in use for 6 years.
+
+Why should one use CheapRandom?
+-------------------------------
+Simple and powerful: The **CheapRandom algorithm** is fast, fast enough to be practical to use in ruby as ruby.  The properties of the **CheapRandom seed** (see below) make management of seeds and random data easy and verifiable. 
+
+Version
+-------
+v0.9.1 with comprehensive tests, developed using ruby 1.9.3 and rspec 2.10.0.
+
+Installation
+------------
+Clone the repository. Create a directory called **random** in the repository root. Use **examples/make\_seed.rb** to make a **the.seed** file - (a 256 byte permutation file) from arbitrary data using the **CheapRandom default seed**.
+
+Usage and documentation
+-----------------------
+Study the programs in the **examples** and **spec** directories and use the **.rb** files in the **lib** directory. See below for more information.
+
+License
+-------
+Copyright (c) 2006 - 2012 Bardi Einarsson. Released under the MIT License.  See the [LICENSE][license] file for further details.
+
+[license]: https://github.com/bardibardi/cheap_random/blob/master/LICENSE.md
+
+Create a large file of random bytes
+-----------------------------------
+Copy (or link) some large file (with a known hash) to the **random** directory. Use **examples/cr.rb** to randomize it into a **.random** file (the rspec tests expect **test.zip** and **test.zip.random**).
+
+Use a large file of random bytes as a source of random numbers
+--------------------------------------------------------------
+Use **examples/cb.rb** to see how to use **lib/cheap\_bits.rb** to create a random number generator which uses that large file. **spec/using\_cheap\_bits\_cheap\_random\_spec.rb** uses **lib/cheap\_bits.rb** to generate random numbers. It should be compared with **spec/cheap\_random\_spec.rb** which uses **Kernel::rand**.
+
+Manage a large file used as the source of random numbers
+--------------------------------------------------------
+The large file does not need to be kept if it is something like **jruby-bin-1.6.7.2.zip**. For example, one can keep a reference to its internet location, its sha1 hash and the **CheapRandom seed** file used when creating its **.random** file.
+
+Manage the seed file used when generating .random files
+-------------------------------------------------------
+The **CheapRandom seed** file does not need to be kept if it is generated from the **CheapRandom default seed** and some arbitrary file, say a picture of a pet cat. One can simply keep the picture of the pet cat.
+
+CheapBits#random(n) in lib/cheap\_bits.rb
+-----------------------------------------
+**random(n)**, where n is an integer greater than zero, behaves like **Kernel::rand(n)**. It is only dependent on the **.random** file, not on how the **.random** file was generated. Note that the **.random** file is treated like a ring buffer of random bits.
+
+CheapRandom::cheap\_random3!(is\_randomizing, perm, s)
+------------------------------------------------------
+**cheap\_random3!** updates **s**, a byte string. **perm** is a **CheapRandom seed**, a byte string of 256 bytes all different. **is\_randomizing** is a boolean which determines whether or **s** is being randomized or un-randomized. **cheap\_random3!** returns another perm / **CheapRandom seed**. **spec/cheap\_random\_spec.rb** is used to test **cheap\_random3!**. **spec/using\_cheap\_bits\_cheap\_random\_spec.rb** is also used to test **cheap\_random3!** and to demonstrate the use of **lib/cheap\_bits.rb**.
+
+Properties of the CheapRandom seed
+----------------------------------
+**CheapRandom seeds** are easy to identify. All the **CheapRandom seeds** are 256 bytes, all different.
+
+**CheapRandom seeds** can be used to identify files. **CheapRandom seeds** are a type of hash function result. When **test.zip** is processed into **test.zip.random**, **test.zip.seed** is also produced. **test.zip.seed** is the result of **cheap\_random3!** on **test.zip**.
+
+Given the same start seed -- **the.seed**, the result seed files **test.zip.seed** and **test.zip.random.seed** are always identical. (**test.zip.random.seed** is the result of **cheap\_random3!** on **test.zip.random**.)
+
+make\_seed.rb
+-------------
+**ruby examples/make\_seed.rb pet\_cat.png** => **random/pet\_cat.png.seed** which should be copied to **random/the.seed**
+
+cr.rb
+-----
+**ruby examples/cr.rb test.zip** => **random/test.zip.random** and **random/test.zip.seed**
+
+cb.rb
+-----
+**ruby examples/cb.rb** => listing of byte frequencies for **random/test.zip.random**
+
+chi\_squared.rb
+---------------
+**ruby examples/chi\_squared.rb test.zip** => a listing of a chi-squared statistic for **random/test.zip.random** followed by a listing of a chi-squared statistic for the same amount of data generated by **Kernel::rand 256**
+
+Test
+----
+Make sure that the **random** directory exists and contains the files **pet\_cat.png**, **pet\_cat.png.seed**, **the.seed**, **test.zip** and **test.zip.random** as described above. Run **rspec**. The tests are quite comprehensive.
+
+Other possible uses of CheapRandom
+----------------------------------
+There are a number of intriguing possible uses for the **CheapRandom algorithm** and the **CheapRandom seed** properties beyond random number generation.
+

data/cheap_random.gemspec

@@ -0,0 +1,38 @@
+Gem::Specification.new do |s|
+  s.name = 'cheap_random'
+  s.version = '0.9.2'
+  s.date = '2012-06-12'
+  s.summary = 'pseudo random number generation from arbitrary data'
+  s.description = <<-EOT
+    **CheapRandom** is a set of tools for pseudo random number generation from arbitrary data. The properties of the **CheapRandom seed** make convenient random number generation possible -- useful for easily repeatable software testing. The **CheapRandom algorithm** is information conserving and generally appears to produce lower chi-squared statistics than **Kernel::rand** i.e. it appears to be more random. The **CheapRandom algorithm**, an original work by Bardi Einarsson, has been in use for 6 years.
+  EOT
+
+  s.authors = ['Bardi Einarsson']
+  s.email = ['bardi_e@hotmail.com']
+  s.homepage = 'https://github.com/bardibardi/cheap_random'
+  s.required_ruby_version = '>= 1.9.2'
+  s.add_development_dependency('rspec', '~> 2.2')
+  s.files = %w(
+cheap_random.gemspec
+.gitignore
+LICENSE.md
+README.md
+examples/cb.rb
+examples/chi_squared.rb
+examples/cr.rb
+examples/make_seed.rb
+lib/cheap_big_file.rb
+lib/cheap_bits.rb
+lib/cheap_byte_count.rb
+lib/cheap_dependency.rb
+lib/cheap_file.rb
+lib/cheap_random.rb
+lib/cheap_random/version.rb
+lib/cheap_test.rb
+spec/cheap_big_file_spec.rb
+spec/cheap_bits_spec.rb
+spec/cheap_random_spec.rb
+spec/using_cheap_bits_cheap_random_spec.rb
+)
+end
+

data/examples/cb.rb

@@ -0,0 +1,18 @@
+p File.absolute_path(__FILE__)
+CHEAP_DEPENDENCY_ENV_NAME = 'CD'
+load File.expand_path('../lib/cheap_dependency.rb', File.dirname(__FILE__))
+CheapDependency.cd_get('cheap_bits')
+
+BASE_DIR = File.expand_path('../random', File.dirname(__FILE__))
+RANDOM_FILE_SOURCE = "test.zip"
+XLAT_EXT = '.random'
+CB = CheapBits.new(9, BASE_DIR, RANDOM_FILE_SOURCE, XLAT_EXT)
+
+def l
+  load File.absolute_path(__FILE__)
+end
+
+if !CheapDependency.cd_test?
+  p CB.get_many_random 441241, 256
+end
+

data/examples/chi_squared.rb

@@ -0,0 +1,48 @@
+p File.absolute_path(__FILE__)
+CHEAP_DEPENDENCY_ENV_NAME = 'CD'
+load File.expand_path('../lib/cheap_dependency.rb', File.dirname(__FILE__))
+CheapDependency.cd_get('cheap_byte_count')
+
+BASE_DIR = File.expand_path('../random', File.dirname(__FILE__))
+XLAT_EXT = '.random'
+
+def byte_count_array(file_name)
+  afn = "#{BASE_DIR}/#{file_name}#{XLAT_EXT}"
+  CheapByteCount.byte_count_array_from_file afn
+end
+
+def chi(a)
+  d = a.length
+  n = a.reduce(:+)
+  p n
+  e = (n*1.0)/d
+  p e
+  c = a.reduce(0) {|acc, r| acc + (r - e)*(r - e)/e}
+  [d - 1, c]
+end
+
+def rand_array(a)
+  d = a.length
+  n = a.reduce(:+)
+  rand_a = []
+  d.times {rand_a << 0}
+  n.times {i = rand(d); rand_a[i] += 1}
+  rand_a 
+end
+
+def chi_of_bytes(file_name)
+  bca = byte_count_array file_name
+  chi bca
+end
+
+def l
+  load File.absolute_path(__FILE__)
+end
+
+if !CheapDependency.cd_test?
+  file_name = ARGV[0]
+  bca = byte_count_array file_name
+  p chi(bca)
+  p chi(rand_array(bca))
+end
+

data/examples/cr.rb

@@ -0,0 +1,33 @@
+p File.absolute_path(__FILE__)
+CHEAP_DEPENDENCY_ENV_NAME = 'CD'
+load File.expand_path('../lib/cheap_dependency.rb', File.dirname(__FILE__))
+CheapDependency.cd_get(
+  'cheap_random',
+  'cheap_file',
+  'cheap_big_file'
+)
+if CheapDependency.cd_test?
+  CheapDependency.cd_get 'cheap_test'
+end
+
+BASE_DIR = File.expand_path('../random', File.dirname(__FILE__))
+# SEED = CheapRandom.cheap_seed!('secret' * 100)
+# CheapFile.to_file "#{BASE_DIR}/the.seed", SEED
+SEED = CheapFile.from_file "#{BASE_DIR}/the.seed"
+XLAT = lambda {|is_do, perm, s| CheapRandom.cheap_random3! is_do, perm, s}
+XLAT_EXT = '.random'
+#    CheapFile.new(BASE_DIR, XLAT_EXT, SEED, XLAT).xlat_small_file file_name
+CF = CheapBigFile.new(9, BASE_DIR, XLAT_EXT, SEED, XLAT)
+
+def l
+  load File.absolute_path(__FILE__)
+end
+
+if !CheapDependency.cd_test?
+  file_name = ARGV[0]
+  generated_seed = CF.xlat_big_file file_name
+  seed_file_name = "#{BASE_DIR}/#{file_name}.seed"
+  CheapFile.to_file seed_file_name, generated_seed
+  p generated_seed.each_byte.inject([], :<<)
+end
+

data/examples/make_seed.rb

@@ -0,0 +1,23 @@
+p File.absolute_path(__FILE__)
+CHEAP_DEPENDENCY_ENV_NAME = 'CD'
+load File.expand_path('../lib/cheap_dependency.rb', File.dirname(__FILE__))
+CheapDependency.cd_get(
+  'cheap_random',
+  'cheap_file',
+  'cheap_big_file'
+)
+
+BASE_DIR = File.expand_path('../random', File.dirname(__FILE__))
+SEED = CheapRandom.reverse_perm
+XLAT = lambda {|is_do, perm, s| CheapRandom.cheap_random3! is_do, perm, s}
+XLAT_EXT = '.random'
+CF = CheapBigFile.new(9, BASE_DIR, XLAT_EXT, SEED, XLAT)
+
+if !CheapDependency.cd_test?
+  file_name = ARGV[0]
+  generated_seed = CF.xlat_big_file file_name, false
+  seed_file_name = "#{BASE_DIR}/#{file_name}.seed"
+  CheapFile.to_file seed_file_name, generated_seed
+  p generated_seed.each_byte.inject([], :<<)
+end
+

data/lib/cheap_big_file.rb

@@ -0,0 +1,70 @@
+class CheapBigFile < CheapFile
+
+  def self.readblock(fd_in, half_block_size)
+    fd_in.readpartial half_block_size
+  rescue EOFError
+    nil
+  end
+
+  def self.write(fd_out, s)
+    fd_out.write s if fd_out
+  end
+
+  def self.wipe!(s)
+    (0...s.length).each {|i| s.setbyte i, 255}
+  end
+
+  def self.eof_sout_from_blocks(half_block_size, s0, s1)
+    return [true, nil] unless s0
+    return [true, s0] unless s1
+    return [true, s0 + s1] if half_block_size > s1.length
+    [false, s0]
+  end
+
+  def self.xlat(fd_in, fd_out, half_block_size, is_do, seed, xlat_lambda)
+    perm = seed
+    s0 = readblock fd_in, half_block_size
+    eof = false
+    while !eof do
+      s1 = readblock fd_in, half_block_size
+      eof, sout = eof_sout_from_blocks half_block_size, s0, s1
+      if sout
+        perm = xlat_lambda.call is_do, perm, sout
+        write fd_out, sout
+      end
+      if sout.length > half_block_size
+        wipe! s0
+        wipe! s1
+      end
+      s0 = s1
+    end
+    perm
+  end
+
+  def initialize(block_size_exponent, base_dir, xlat_ext, seed, xlat_lambda)
+    super base_dir, xlat_ext, seed, xlat_lambda
+    @block_size = 1 << block_size_exponent
+    @half_block_size = @block_size >> 1
+  end
+
+  def xlat_big(fd_in, fd_out, is_do)
+    self.class.xlat(fd_in, fd_out, @half_block_size, is_do, @seed, @xlat)
+  end
+
+  def xlat_big_file(fn, should_write = true)
+    is_do, afn, new_afn = self.class.is_do_afn_new_afn @base_dir, fn, @xlat_ext
+    perm = nil
+    File.open(afn, 'rb') do |fd_in|
+      if should_write
+        File.open(new_afn, 'wb') do |fd_out|
+          perm = xlat_big(fd_in, fd_out, is_do)
+        end
+      else
+        perm = xlat_big(fd_in, nil, is_do)
+      end
+    end
+    perm
+  end
+
+end #CheapBigFile
+

data/lib/cheap_bits.rb

@@ -0,0 +1,127 @@
+class CheapBits
+
+  def self.readblock(fd_in, block_size)
+    fd_in.readpartial block_size
+  rescue EOFError
+    nil
+  end
+
+  def self.getbit(random_block, bit_offset)
+    byte_offset = bit_offset >> 3
+    byte_bit_offset = bit_offset - (byte_offset << 3)
+    byte = random_block.getbyte(byte_offset)
+    1 & (byte >> (7 - byte_bit_offset))
+  end
+
+  def initialize(block_size_exponent, base_dir, fn, xlat_ext)
+    @afn = "#{base_dir}/#{fn}#{xlat_ext}"
+    @block_size = 1 << block_size_exponent
+    @fd_in = nil
+    @current_block = ''
+    @bits_total = 0
+    @bit_offset = 0
+  end
+
+  def readblock
+    open unless @fd_in
+    s = self.class.readblock @fd_in, @block_size
+    if !s
+      rewind
+      s = self.class.readblock @fd_in, @block_size
+    end
+    @current_block = s
+    @bits_total = @current_block.length << 3
+    @bit_offset = 0
+    s
+  end
+
+  def close
+    @fd_in.close if @fd_in
+  end
+
+  def open
+    @fd_in = File.open(@afn)
+  end
+
+  def rewind
+    close
+    open
+    @current_block = ''
+    @bits_total = 0
+    @bit_offset = 0
+  end
+
+  def getbit
+    readblock if @bit_offset == @bits_total
+    bit = self.class.getbit(@current_block, @bit_offset)
+    @bit_offset += 1
+    bit
+  end
+
+  def getbits_as_number(how_many)
+    return nil unless how_many > 0
+    first_one_bit_found = false
+    bits = 0
+    how_many.times do
+      bit = getbit
+      if first_one_bit_found
+        bits = bits << 1
+        bits += bit
+      else
+        if 1 == bit
+          bits = 1
+          first_one_bit_found = true
+        end
+      end
+    end
+    bits
+  end
+
+  def random(n)
+    return nil unless n > 0
+    return 0 if 1 == n
+    bits_needed = 0
+    power_of_two = 1
+    while n > power_of_two
+      bits_needed += 1
+      power_of_two = power_of_two << 1
+    end
+    bits = power_of_two
+    while bits >= n
+      bits = getbits_as_number bits_needed
+    end
+    bits
+  end
+
+  def broken_random(n)
+    current = n
+    acc = 0
+    while current > 0
+      odd = 1 == 1 & current
+      current = current >> 1
+      if current > 0
+        acc += current if 1 == getbit
+      end
+      if odd
+        if (1 == getbit)
+          acc += 1
+        else
+          current += 1
+        end
+      end
+    end
+    acc - 1
+  end
+
+  def get_many_random(how_many, what)
+    a = []
+    what.times {a << 0}
+    how_many.times do
+      r = random(what)
+      a[r] +=  1
+    end
+    a
+  end
+
+end #CheapBits
+

data/lib/cheap_byte_count.rb

@@ -0,0 +1,30 @@
+class CheapByteCount
+
+  def self.readblock(fd_in)
+    fd_in.readpartial 4096
+  rescue EOFError
+    nil
+  end
+
+  def self.byte_count_array_from_file(file_name)
+    bca = nil
+    File.open(file_name, 'rb') do |fd_in|
+      bca = new(fd_in).byte_count_array
+    end
+    bca
+  end
+
+  attr_reader :byte_count_array
+
+  def initialize(fd_in)
+    @byte_count_array = []
+    256.times {@byte_count_array << 0}
+    while s = self.class.readblock(fd_in) do
+      s.each_byte do |b|
+        @byte_count_array[b] += 1
+      end
+    end
+  end
+  
+end
+

data/lib/cheap_dependency.rb

@@ -0,0 +1,40 @@
+module CheapDependency
+
+  def self.cd_test?
+    'test' == ENV[CHEAP_DEPENDENCY_ENV_NAME]
+  end
+
+  def self.cd_test(load)
+    ENV[CHEAP_DEPENDENCY_ENV_NAME] = 'test' if load
+    ENV[CHEAP_DEPENDENCY_ENV_NAME] = 'no_test' unless load
+  end
+
+  def self.cd_exists_absolute_fn(relative_fn_base)
+    afn = File.expand_path("#{relative_fn_base}.rb", File.dirname(__FILE__))
+    [File.exists?(afn), afn]
+  end
+
+  def self.cd_require_relative(relative_fn_base)
+    exists, afn = cd_exists_absolute_fn relative_fn_base
+    require_relative relative_fn_base if exists
+    require relative_fn_base unless exists
+  end
+
+  def self.cd_load_relative(relative_fn_base)
+    exists, afn = cd_exists_absolute_fn relative_fn_base
+    load afn if exists
+    require relative_fn_base unless exists
+  end
+
+  def self.cd_get(*relative_fn_base_array)
+    relative_fn_base_array.each do |relative_fn_base|
+      if cd_test?
+        cd_load_relative relative_fn_base
+      else
+        cd_require_relative relative_fn_base
+      end
+    end
+  end
+
+end
+

data/lib/cheap_file.rb

@@ -0,0 +1,47 @@
+class CheapFile
+
+  def self.file?(afn)
+    File.file? afn
+  end
+
+  def self.from_file(afn)
+    f = File.new afn, 'rb'
+    s = f.read
+    s.force_encoding 'ASCII-8BIT'
+  end
+  
+  def self.to_file(afn, s)
+    f = File.new afn, "wb"
+    f.write s
+    f.close
+  end
+ 
+  def self.is_do_afn_new_afn(base_dir, fn, xlat_ext)
+    afn = "#{base_dir}/#{fn}"
+    xlat_match = afn =~ Regexp.new("\\#{xlat_ext}$")
+    new_afn = afn[0, xlat_match] if xlat_match
+    new_afn = afn + xlat_ext unless xlat_match
+    [!xlat_match, afn, new_afn]
+  end
+
+  def initialize(base_dir, xlat_ext, seed, xlat_lambda)
+    @base_dir = base_dir
+    @xlat_ext = xlat_ext
+    @seed = seed
+    @xlat = xlat_lambda
+  end
+
+  def xlat_small(is_do, s)
+    @xlat.call is_do, @seed, s
+  end
+
+  def xlat_small_file(fn, should_write = true)
+    is_do, afn, new_afn = self.class.is_do_afn_new_afn @base_dir, fn, @xlat_ext
+    s = self.class.from_file afn
+    perm = xlat_small is_do, s
+    self.class.to_file new_afn, s if should_write
+    perm
+  end
+
+end #CheapFile
+

data/lib/cheap_random.rb

@@ -0,0 +1,175 @@
+module CheapRandom
+
+  def self.subperm(perm, length)
+    result = ' ' * length
+    idx = 0
+    (0..255).each do |x|
+      if perm.getbyte(x) < length
+        result.setbyte idx, perm.getbyte(x)
+        idx += 1
+      end
+    end
+    result
+  end
+  
+  def self.permute(perm, buffer, offset, length)
+    disp = 0
+    temp = 0
+    y = 0
+    (0...length).each do |x| 
+      while perm.getbyte(y) >= length do
+        y += 1
+      end
+      disp = offset + perm.getbyte(y)
+      y += 1
+      temp = buffer.getbyte disp
+      buffer.setbyte disp, buffer.getbyte(offset + x)
+      buffer.setbyte(offset + x, temp)
+    end
+    nil
+  end
+  
+  def self.unpermute(perm, buffer, offset, length)
+    disp = 0
+    temp = 0
+    y = 255
+    (1..length).each do |x| 
+      while perm.getbyte(y) >= length do
+        y -= 1
+      end
+      disp = offset + perm.getbyte(y)
+      y -= 1
+      temp = buffer.getbyte disp
+      buffer.setbyte disp, buffer.getbyte(offset + length - x)
+      buffer.setbyte(offset + length - x, temp)
+    end
+    nil
+  end
+  
+  # is_randomizing is a boolean
+  # cheap_random with is_randomizing true, randomizes
+  # cheap_random with is_randomizing false, un-randomizes
+  # perm is a read only string of length 256 with each
+  # byte represented once
+  # perm is cheap_random's seed
+  # nextperm is a writeable string of length 256
+  # comes in as a copy of perm
+  # it is the next seed for use in chain seeding
+  # translation is a buffer needed for perm reversed as a substitution transformation
+  # buffer is read as unrandomized text
+  # and written as randomized text
+  # offset is a pointer into the buffer
+  # length is from 1 to 256
+  # it is the number of bytes to process
+  # starting at offset in buffer
+  def self.cheap_random7(is_randomizing, perm, nextperm, translation, buffer, offset, length)
+    if is_randomizing then
+      random_cheap_random(perm, nextperm, buffer, offset, length)
+    else
+      (0..255).each do |x|
+        translation.setbyte perm.getbyte(x), x
+      end
+      unrandom_cheap_random(perm, nextperm, translation, buffer, offset, length)
+    end
+    return nil
+  end
+  
+  def self.random_cheap_random(perm, nextperm, buffer, offset, length)
+    disp = 0
+    temp = 0
+    y = 0
+    (0...length).each do |x| 
+      disp = offset + x
+      y = buffer.getbyte(disp) ^ perm.getbyte(x)
+      y = perm.getbyte((y + x + x + x) & 255)
+      buffer.setbyte disp, y
+      temp = nextperm.getbyte x
+      nextperm.setbyte x, nextperm.getbyte(y)
+      nextperm.setbyte y, temp
+    end
+    y = 0
+    (0...length).each do |x| 
+      while perm.getbyte(y) >= length do
+        y += 1
+      end
+      disp = offset + perm.getbyte(y)
+      y += 1
+      temp = buffer.getbyte disp
+      buffer.setbyte disp, buffer.getbyte(offset + x)
+      buffer.setbyte(offset + x, temp)
+    end
+    nil
+  end
+  
+  def self.unrandom_cheap_random(perm, nextperm, translation, buffer, offset, length)
+    disp = 0
+    temp = 0
+    y = 255
+    (1..length).each do |x| 
+      while perm.getbyte(y) >= length do
+        y -= 1
+      end
+      disp = offset + perm.getbyte(y)
+      y -= 1
+      temp = buffer.getbyte disp
+      buffer.setbyte disp, buffer.getbyte(offset + length - x)
+      buffer.setbyte(offset + length - x, temp)
+    end
+    y = 0
+    (0...length).each do |x| 
+      disp = offset + x
+      y = buffer.getbyte disp
+      buffer.setbyte(disp, ((translation.getbyte(y) + 768 - x - x - x) & 255) ^ perm.getbyte(x))
+      temp = nextperm.getbyte(x)
+      nextperm.setbyte x, nextperm.getbyte(y)
+      nextperm.setbyte y, temp
+    end
+    nil
+  end
+  
+  def self.next_block_size(size)
+    return 256 if size > 511
+    return size if size <= 256
+    size - (size >> 1)
+  end
+  
+  # length > 0
+  def self.cheap_random5!(is_randomizing, startperm, buffer, offset, length)
+    nextperm = startperm + 'NEXT'
+    perm = (' ' * 256) + 'PERM'
+    translation = (' ' * 256) + 'TRAN'
+    len = length
+    off = offset
+    while len > 0 do
+      bs = next_block_size len
+      (0..255).each do |x|
+        perm.setbyte x, nextperm.getbyte(x)
+      end
+      cheap_random7(is_randomizing, perm, nextperm, translation, buffer, off, bs)
+      off += bs
+      len -= bs
+    end
+    nextperm[0..255]
+  end
+  
+  def self.reverse_perm
+    s = ' ' * 256
+    (0..255).each do |x|
+      s.setbyte(x, 255 - x)
+    end
+    s
+  end
+ 
+  def self.cheap_random3!(is_randomizing, perm, s)
+    cheap_random5!(is_randomizing, perm, s, 0, s.length)
+  end
+  
+  def self.cheap_seed!(s)
+    ip = reverse_perm
+    result = cheap_random3!(true, ip, s)
+    cheap_random3!(false, ip, s)
+    result
+  end
+  
+end # CheapRandom
+  

data/lib/cheap_random/version.rb

@@ -0,0 +1,4 @@
+module CheapRandom
+  VERSION = '0.9.1'
+end
+

data/lib/cheap_test.rb

@@ -0,0 +1,52 @@
+module CheapTest
+
+  def self.random(n)
+    rand(n)
+  end
+
+  def self.cheap_perm_check!(perm, s)
+    return nil if length > 256
+    CheapRandom::permute perm, s, 0, length
+    CheapRandom::unpermute perm, s, 0, length
+  end
+ 
+  def self.random_string(len)
+    s = ' ' * len
+    (0...len).each do |x|
+      s.setbyte x, random(256)
+    end
+    s
+  end
+ 
+  def self.identity_perm
+    s = ' ' * 256
+    (0..255).each do |x|
+      s.setbyte x, x
+    end
+    s
+  end
+
+  def self.random_perm
+    s = identity_perm
+    i = 256
+    (0..255).each do |x|
+      temp = s.getbyte x
+      y = x + random(i)
+      s.setbyte x, s.getbyte(y)
+      s.setbyte y, temp
+      i -= 1
+    end
+    s
+  end
+  
+  def self.is_reversible?
+    s = random_string(random(10000))
+    x = s + 'X'
+    ip = random_perm
+    CheapRandom::cheap_random3!(true, ip, s)
+    CheapRandom::cheap_random3!(false, ip, s)
+    s == x[0...(s.length)]
+  end
+  
+end #CheapTest
+

data/spec/cheap_big_file_spec.rb

@@ -0,0 +1,50 @@
+load 'cheap_file.rb'
+load 'cheap_big_file.rb'
+require 'stringio'
+
+module CheapTest
+
+  FAKE_XLAT = lambda do |is_do, perm, s|
+    return [s.length] unless perm
+    perm << s.length
+  end
+
+  CF = CheapBigFile.new(9, nil, nil, nil, FAKE_XLAT)
+
+end
+
+describe "CheapBigFile's block handling for CheapRandom" do
+  it "should return blocks usable as 256 byte chunks" do
+    (257..3000).each do |i|
+      fd_in = StringIO.new('x' * i)
+      a = CheapTest::CF.xlat_big fd_in, nil, CheapTest::FAKE_XLAT
+      len = a.length
+      exist = len > 0
+      exist.should == true
+      total = a.reduce(:+)
+      total.should == i
+      last_block_big_enough = a[-1] > 255
+      last_block_big_enough.should == true
+      a[0..-2].each do |size|
+        big_enough = size > 255
+        big_enough.should == true
+        multiple_of_256 = 0 == (size % 256)
+        multiple_of_256.should == true
+      end
+    end
+  end
+end
+
+describe "CheapBigFile's block handling for CheapRandom" do
+  it "should return small blocks less than size 257" do
+    (1..256).each do |i|
+      fd_in = StringIO.new('x' * i)
+      a = CheapTest::CF.xlat_big fd_in, nil, CheapTest::FAKE_XLAT
+      len = a.length
+      len.should == 1
+      same_size = a[-1] == i
+      same_size.should == true
+    end
+  end
+end
+

data/spec/cheap_bits_spec.rb

@@ -0,0 +1,65 @@
+load 'cheap_file.rb'
+load 'cheap_big_file.rb'
+load 'cheap_bits.rb'
+load 'cheap_byte_count.rb'
+
+module CheapTest
+
+  BASE_DIR ||= File.expand_path('../random', File.dirname(__FILE__))
+  RANDOM_FILE_SOURCE ||= "test.zip"
+  XLAT_EXT ||= '.random'
+  CB ||= CheapBits.new(9, BASE_DIR, RANDOM_FILE_SOURCE, XLAT_EXT)
+  FILE_NAME = "#{BASE_DIR}/#{RANDOM_FILE_SOURCE}#{XLAT_EXT}"
+
+  def self.random(n)
+    CB.random n
+  end
+
+end
+
+describe "CheapBits random(1)" do
+  it "should return 0" do
+    is_zero = 0 == CheapTest.random(1)
+    is_zero.should == true
+  end
+end
+
+describe "CheapBits random" do
+  it "should get an in bounds number" do
+    inbounds = 256 > CheapTest.random(256)
+    inbounds.should == true
+  end
+end
+
+describe "CheapBits getbit" do
+  fake_random_block = ' ' * 8
+  (0..7).each {|i| fake_random_block.setbyte(7 - i, 1 << i) }
+  it "should get the correct bit" do
+    (0..7).each do |i|
+      bit = CheapBits.getbit fake_random_block, ((i << 3) + i)
+      bit.should == 1
+    end
+  end
+end
+
+describe "CheapBits get_many_random" do
+  it "should be plausibly random" do
+    a = CheapTest::CB.get_many_random 30000, 3
+    a.each do |i|
+      plausible = i > 9750
+      plausible.should == true
+    end
+  end
+end
+
+describe "CheapBits get_many_random" do
+  it "should process all bytes in file" do
+    bca = CheapByteCount.byte_count_array_from_file CheapTest::FILE_NAME
+    how_many = File.new(CheapTest::FILE_NAME).size
+    CheapTest::CB.rewind
+    a = CheapTest::CB.get_many_random how_many, 256
+    same_byte_count_profile = bca == a
+    same_byte_count_profile.should == true
+  end
+end
+

data/spec/cheap_random_spec.rb

@@ -0,0 +1,10 @@
+load 'cheap_random.rb'
+load 'cheap_test.rb'
+
+describe "CheapRandom randomizer" do
+  it "should reversibly randomize arbitrary strings when using arbitrary seed permutations" do
+    reversed = CheapTest.is_reversible?
+    reversed.should == true
+  end
+end
+

data/spec/using_cheap_bits_cheap_random_spec.rb

@@ -0,0 +1,35 @@
+load 'cheap_random.rb'
+load 'cheap_test.rb'
+
+load 'cheap_file.rb'
+load 'cheap_big_file.rb'
+load 'cheap_bits.rb'
+
+module CheapTest
+
+  BASE_DIR ||= File.expand_path('../random', File.dirname(__FILE__))
+  RANDOM_FILE_SOURCE ||= "test.zip"
+  XLAT_EXT ||= '.random'
+  CB ||= CheapBits.new(9, BASE_DIR, RANDOM_FILE_SOURCE, XLAT_EXT)
+
+  def self.random(n)
+    CB.random n
+  end
+
+end
+
+describe "CheapTest random" do
+  it "should be using the CheapBits RANDOM_FILE_SOURCE" do
+    bit = CheapTest.random 2
+    is_a_bit = 2 > bit
+    is_a_bit.should == true
+  end
+end
+
+describe "CheapRandom randomizer" do
+  it "should reversibly randomize arbitrary strings when using arbitrary seed permutations" do
+    reversed = CheapTest.is_reversible?
+    reversed.should == true
+  end
+end
+

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: cheap_random
+version: !ruby/object:Gem::Version
+  version: 0.9.2
+  prerelease: 
+platform: ruby
+authors:
+- Bardi Einarsson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.2'
+description: ! '    **CheapRandom** is a set of tools for pseudo random number generation
+  from arbitrary data. The properties of the **CheapRandom seed** make convenient
+  random number generation possible -- useful for easily repeatable software testing.
+  The **CheapRandom algorithm** is information conserving and generally appears to
+  produce lower chi-squared statistics than **Kernel::rand** i.e. it appears to be
+  more random. The **CheapRandom algorithm**, an original work by Bardi Einarsson,
+  has been in use for 6 years.
+
+'
+email:
+- bardi_e@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- cheap_random.gemspec
+- .gitignore
+- LICENSE.md
+- README.md
+- examples/cb.rb
+- examples/chi_squared.rb
+- examples/cr.rb
+- examples/make_seed.rb
+- lib/cheap_big_file.rb
+- lib/cheap_bits.rb
+- lib/cheap_byte_count.rb
+- lib/cheap_dependency.rb
+- lib/cheap_file.rb
+- lib/cheap_random.rb
+- lib/cheap_random/version.rb
+- lib/cheap_test.rb
+- spec/cheap_big_file_spec.rb
+- spec/cheap_bits_spec.rb
+- spec/cheap_random_spec.rb
+- spec/using_cheap_bits_cheap_random_spec.rb
+homepage: https://github.com/bardibardi/cheap_random
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: pseudo random number generation from arbitrary data
+test_files: []