lfsr 1.0.0

data/scripts/bench

@@ -0,0 +1,21 @@
+require 'benchmark'
+require 'lfsr/pure'
+require 'lfsr/fast'
+
+TIMES = 500_000
+
+puts "Bits\t| Pure\t| C ext\t| rand\t| Vs P.\t| Vs rand"
+
+2.upto(32) do |bits|
+  max = (1 << (bits - 1))+1
+
+  l = LFSR::Fast.const_get("Size#{bits}").new(max)
+  ext = Benchmark.realtime do TIMES.times {l.next_i} end
+
+  l = LFSR::Pure.const_get("Size#{bits}").new(max)
+  pure = Benchmark.realtime do TIMES.times {l.next_i} end
+
+  randt = Benchmark.realtime do TIMES.times {rand(max)} end
+
+  puts sprintf(" #{bits}\t| %.2fs\t| %.2fs\t| %.2fs\t| %.1fX\t| %.1fX",  pure, ext, randt, pure/ext, randt/ext)
+end

data/scripts/genc.rb

@@ -0,0 +1,55 @@
+require 'taps'
+
+code = %$
+#include <stdio.h>
+#include "ruby.h"
+
+#define bit(n) ((reg & (1 << (n))) >> (n))
+#define RUBY_EXPORT __attribute__ ((visibility ("default")))
+
+$
+puts code.strip
+puts
+
+2.upto(MAXBITS) do |size|
+  taps = ([size] + TAPS[size])
+  bits_select = taps.uniq.map {|bit| "bit(#{size - bit})" }.join('^')
+
+  code = %$
+VALUE rb_lfsr_next_i_#{size}(VALUE self) {
+  unsigned long long reg = NUM2ULL(ROBJECT(self)->as.ary[0]), max = NUM2ULL(ROBJECT(self)->as.ary[1]);
+
+  label_shift#{size}:
+  reg = (reg >> 1) | ((#{bits_select}) << 0x#{ sprintf "%x", size - 1 });
+  if (reg > max) goto label_shift#{size};
+
+  ROBJECT(self)->as.ary[0] = ULL2NUM(reg);
+
+  return ULL2NUM(reg - 1);
+}
+$
+  puts code.strip
+  puts
+end
+
+code = %$
+void RUBY_EXPORT Init_lfsr() {
+  VALUE rb_mLFSR = rb_const_get(rb_cObject, rb_intern("LFSR"));
+  VALUE rb_cLFSR_Base = rb_const_get(rb_mLFSR, rb_intern("Base"));
+  VALUE rb_mLFSR_Fast = rb_define_module_under(rb_mLFSR, "Fast");
+
+  VALUE rb_cLFSR_SubClass;
+$
+puts code
+
+2.upto(MAXBITS) do |size|
+  code = %$
+  rb_cLFSR_SubClass = rb_define_class_under(rb_mLFSR_Fast, "Size#{size}", rb_cLFSR_Base);
+  rb_define_method(rb_cLFSR_SubClass, "next_i", rb_lfsr_next_i_#{size}, 0);
+  rb_define_const(rb_cLFSR_SubClass, "MASK", ULL2NUM(0x#{sprintf("%x", (2**size)-1)}LLU));
+$
+  puts code
+end
+
+
+puts "}"

data/scripts/genruby.rb

@@ -0,0 +1,72 @@
+require 'taps'
+
+if ARGV.last == "base"
+  code = %Q$
+module LFSR
+  VERSION = "1.0.0"
+
+  class Base
+    attr_reader :reg
+    attr_accessor :max
+    attr_reader :seed
+
+    def initialize(max = nil, seed = nil)
+      # The C code depends on this being the first ivar to work properly.
+      @reg = 1
+
+      # This should be the second variable.
+      @max = (max || self.class.const_get(:MASK) - 1) + 1
+
+      reset seed
+    end
+
+    def reset(new_seed)
+      @reg = @seed = (new_seed || Time.now.utc.to_i) & self.class.const_get(:MASK)
+      raise ArgumentError, "The seed \#{new_seed} is unacceptable for this register size" if new_seed && @reg == 0
+      @reg = @seed = (new_seed || Time.now.utc.to_i) & self.class.const_get(:MASK) while @reg == 0
+    end
+
+    alias peek reg
+  end
+
+  # Get a LFSR with the appropriate number of bits to reach the maximum needed.
+  def self.gen(max, namespace = LFSR)
+    bits = Math.log2(max + 2).ceil
+    namespace.const_get("Size\#{bits < 3 ? 3 : bits}").new(max)
+  end
+
+  def self.default_to(namespace)
+    2.upto(61) { |n| remove_const("Size\#{n}")} if defined? LFSR::Size2
+    2.upto(61) { |n| const_set("Size\#{n}", namespace.const_get("Size\#{n}")) }
+  end
+end
+$
+  puts code.strip
+
+else
+  puts "require 'lfsr'"
+  puts ""
+  puts "module LFSR::Pure"
+  puts "end"
+  puts
+
+  code = 2.upto(MAXBITS).map do |size|
+    bits_select = ([size] + TAPS[size]).uniq.map {|bit| "@reg[#{size - bit}]" }.join('^')
+
+    shift = %Q{@reg = (@reg >> 1) | ((#{bits_select}) << 0x#{ sprintf "%x", size - 1 })}
+    code = %Q$
+class LFSR::Pure::Size#{size} < LFSR::Base
+  MASK = 0x#{ sprintf("%x", (2**size) - 1) }
+
+  def next_i
+    #{shift}
+    #{shift} while @reg > @max
+    @reg - 1
+  end
+end
+$
+  end
+  puts code.join("\n").strip
+  puts
+  puts "LFSR.default_to(LFSR::Pure)"
+end

data/scripts/taps.rb

@@ -0,0 +1,69 @@
+MAXBITS = 61 # (1<<62) in ruby 1.9.3 becomes a Bignum, we want to deal only with Fixnums
+
+# http://en.wikipedia.org/wiki/LFSR
+TAPS = []
+
+TAPS[0] = []
+TAPS[1] = []
+
+TAPS << [ 2,  1]
+TAPS << [ 3,  2]
+TAPS << [ 4,  3]
+TAPS << [ 4,  3, 2]
+TAPS << [ 5,  3, 2]
+TAPS << [ 6,  5, 4]
+TAPS << [ 6,  5, 4]
+TAPS << [ 8,  6, 5]
+TAPS << [ 9,  7, 6]
+TAPS << [10,  9, 7]
+TAPS << [11,  8, 6]
+TAPS << [12, 10, 9]
+TAPS << [13, 11, 9]
+TAPS << [14, 13, 11]
+TAPS << [14, 13, 11]
+TAPS << [16, 15, 14]
+TAPS << [17, 16, 13]
+TAPS << [18, 17, 14]
+TAPS << [19, 16, 14]
+TAPS << [20, 19, 16]
+TAPS << [19, 18, 17]
+TAPS << [22, 20, 18]
+TAPS << [23, 21, 20]
+TAPS << [24, 23, 22]
+TAPS << [25, 24, 20]
+TAPS << [26, 25, 22]
+TAPS << [27, 24, 22]
+TAPS << [28, 27, 25]
+TAPS << [29, 26, 24]
+TAPS << [30, 29, 28]
+TAPS << [30, 26, 25]
+TAPS << [32, 29, 27]
+TAPS << [31, 30, 26]
+TAPS << [34, 28, 27]
+TAPS << [35, 29, 28]
+TAPS << [36, 33, 31]
+TAPS << [37, 33, 32]
+TAPS << [38, 35, 32]
+TAPS << [37, 36, 35]
+TAPS << [40, 39, 38]
+TAPS << [40, 37, 35]
+TAPS << [42, 38, 37]
+TAPS << [42, 39, 38]
+TAPS << [44, 42, 41]
+TAPS << [40, 39, 38]
+TAPS << [46, 43, 42]
+TAPS << [44, 41, 39]
+TAPS << [45, 44, 43]
+TAPS << [48, 47, 46]
+TAPS << [50, 48, 45]
+TAPS << [51, 49, 46]
+TAPS << [52, 51, 47]
+TAPS << [51, 48, 46]
+TAPS << [54, 53, 49]
+TAPS << [54, 52, 49]
+TAPS << [55, 54, 52]
+TAPS << [57, 53, 52]
+TAPS << [57, 55, 52]
+TAPS << [58, 56, 55]
+TAPS << [60, 59, 56]
+TAPS << [59, 57, 56]

data/test/lfsr_test.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+
+require 'lfsr/pure'
+require 'lfsr/fast'
+require 'set'
+
+class LFSRTests < Test::Unit::TestCase
+  MAX_SEQUENCE_LENGTH = 2**16 # Keep tests at a runnable size... even if we don't test ALL the numbers generated for evey bit size.
+
+  def test_gen
+    assert_equal LFSR.gen(2).class, LFSR::Fast::Size3
+    assert_equal LFSR.gen(3).class, LFSR::Fast::Size3
+    assert_equal LFSR.gen(4).class, LFSR::Fast::Size3
+    assert_equal LFSR.gen(5).class, LFSR::Fast::Size3
+    assert_equal LFSR.gen(6).class, LFSR::Fast::Size3
+    assert_equal LFSR.gen(7).class, LFSR::Fast::Size4
+    assert_equal LFSR.gen(8).class, LFSR::Fast::Size4
+    assert_equal LFSR.gen(9).class, LFSR::Fast::Size4
+
+    assert_equal LFSR.gen(14).class, LFSR::Fast::Size4
+    assert_equal LFSR.gen(15).class, LFSR::Fast::Size5
+    assert_equal LFSR.gen(16).class, LFSR::Fast::Size5
+  end
+
+  2.upto(61) do |bits|
+    ["Pure", "Fast"].each do |namespace|
+
+      define_method("test_#{namespace}_#{bits}_bits") do
+        gen = LFSR.const_get(namespace).const_get("Size#{bits}").new
+        gen.reset(1)
+
+        sequence = []
+
+        (2**bits - 1).times do
+          sequence <<  gen.next_i
+          break if sequence.length > MAX_SEQUENCE_LENGTH
+        end
+
+        assert sequence.uniq!.nil?
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: lfsr
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Emmanuel Oga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-02 00:00:00.000000000 Z
+dependencies: []
+description: ! "    The generation of random numbers is too important to be left to
+  chance.\n    A Linear Feedback Shift Register is an automaton that\n    can be used
+  to generate a long sequence of different pseudo-random numbers.\n"
+email: emmanueloga@gmail.com
+executables: []
+extensions:
+- ext/lfsr/extconf.rb
+extra_rdoc_files:
+- LICENSE
+files:
+- scripts/genc.rb
+- scripts/bench
+- scripts/genruby.rb
+- scripts/taps.rb
+- examples/sample.rb
+- test/lfsr_test.rb
+- LICENSE
+- lfsr.gemspec
+- ext/lfsr/extconf.rb
+- ext/lfsr/lfsr.c
+- ext/lfsr/lfsr.h
+- Rakefile
+- lib/lfsr.rb
+- lib/lfsr/fast.rb
+- lib/lfsr/pure.rb
+- README.markdown
+homepage: http://github.com/EmmanuelOga/lfsr
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Generate sequences of pseudo random numbers
+test_files:
+- test/lfsr_test.rb