rubylabs 0.5.5 → 0.6.2

data/lib/randomlab.rb

@@ -11,145 +11,122 @@ module RubyLabs
 	
 module RandomLab
   
-require 'statistics2.rb'
-
 =begin rdoc
-  Simple random number generator, using "roulette wheel" algorithm.
+  Pseudo-random number generator.  Constraints on a, c, and m:
+  *  c and m must be relatively prime
+  *  a-1 divisible by prime factors of m
+  *  if m is multiple of 4, a-1 must also be a multiple of 4
+
+  Note: some good values (for small m) from Numerical Recipes:
+      m = 53125, a = 171, c = 11213
 =end
 
-class Wheel
+  class PRNG
   
-  @@x = 0
-  @@c = 337
-  @@m = 1000
+    attr_accessor :a, :c, :m, :x
+
+    def initialize(a, c, m)
+      @a = a
+      @c = c
+      @m = m
+      @x = 0
+    end
   
-  def Wheel.rand(n)
-    @@x = (@@x + @@c) % @@m
-    return @@x % n
-  end
+    def state
+      return @x
+    end
   
-  def Wheel.params(*args)
-    if args.length == 0
-      return [@@x, @@m, @@c]
-    elsif args.length == 3
-      @@x, @@m, @@c = args
-    else
-      raise "params: expected 3 integers"
+    def seed(val)
+      @x = val
     end
-  end
-end
-
-=begin rdoc
-  Better random number generator, using parameters from Numerical Recipes in C.
-=end
-
-class PRNG
-
-  @@x = 0
-  @@a = 3
-  @@c = 337
-  @@m = 1000
   
-  def PRNG.rand(n)
-    @@x = (@@x * @@a + @@c) % @@m
-    return @@x % n
-  end
+    # :begin :advance
+    def advance
+      @x = (@x * @a + @c) % @m    
+    end
+    # :end :advance
   
-  def PRNG.params(*args)
-    if args.length == 0
-      return [@@x, @@m, @@a, @@c]
-    elsif args.length == 4
-      @@x, @@m, @@a, @@c = args
-    else
-      raise "params: expected 4 integers"
+    # :begin :random
+    def random(min, max)
+      return nil if max <= min
+      range = max - min + 1
+      return (advance() % range) + min
     end
-  end
+    # :end :random
   
-end
-
-# :begin :uniform_test
-def uniform_test(n, m, opt = nil)
-  bins = Array.new(m,0)
-  n.times { x = rand(m); bins[x] += 1 }
-  exp = Array.new(m, n/m)
-  if opt == :trace
-    print "bins: "
-    p bins
-  end
-  return chi_square_test(bins, exp, opt)
-end
-# :end :uniform_test
-
-# :begin :poker_test
-def poker_test(n, opt = nil)
-  types = [:nada, :pair, :two_pair, :three_of_a_kind, :full_house, :straight, :flush, :four_of_a_kind, :straight_flush]
-  counts = Hash.new
-  types.each { |x| counts[x] = 0 }
-  n.times do
-    h = random_deal(5)
-    # p h
-    t = poker_hand(h)
-    counts[t] += 1
+    def inspect
+      sprintf "#<RandomLab::PRNG a: #{@a} c: #{@c} m: #{@m}>"
+    end
+  
+    alias to_s inspect
+  
+  end # class PRNG
+
+# :begin :prng_sequence
+  def prng_sequence(a, c, m)
+    seq = [0]
+    (m-1).times do
+      seq << (a * seq.last + c) % m
+    end
+    return seq
   end
-  return counts
-end
-# :end :poker_test
+# :end :prng_sequence
 
 =begin rdoc
-  Compute the chi-square statistic for a set of bins containing results from n random draws.
-  The two parameters are arrays of equal length, containing the observed and expected values.
-  Return +true+ if the chi-square is less than the critical value for p = 0.95 (i.e. return
-  false if the hypothesis that the distributions are the same is rejected).
+  Make a new deck of cards
 =end
 
-def chi_square_test(obs, exp, opt = nil)
-  x2 = chi_square(obs, exp)
-  p = Statistics2.chi2dist(obs.length-1, x2)
-  if opt == :trace
-    printf "chi-square: %7.3f p = %.2f\n", x2, p 
-  end
-  return p < 0.95
-end
-
-def chi_square(obs, exp)
-  sum = 0.0
-  for i in 0...obs.length
-    sum += ( (obs[i] - exp[i])**2 ).to_f / exp[i]
+  def new_deck
+    (0..51).map { |i| Card.new(i) }
   end
-  return sum
-end
 
 =begin rdoc
-  Make a random array of +n+ Card objects (selected without replacement).
+  Permute the order of items in x.  Does not copy x -- shuffles the
+  items in place.  Works for strings, arrays, any container that responds to
+  length, [], and []=
 =end
 
-def random_deal(n)
-  h = Hash.new
-	while h.size < n
-		h[ rand(52) ] = 1		
-	end
-	a = Array.new
-  h.keys.each do |x|
-    a << Card.new(x)
+# :begin :permute
+  def permute(x)
+    for i in 0..x.length-2
+      r = random(i, x.length-1)
+      x[i], x[r] = x[r], x[i]
+    end
+    return x
   end
-  return a
-end
+# :end :permute
 
 =begin rdoc
-  Make a hand using numbers in array +a+ (used for testing)
+  A "helper method" for permute, that makes it easier to see which two
+  locations are being swapped.  A call to random(i,j) returns a random
+  integer in the range i..j.  See also PRNG::random
 =end
 
-def deal(a)
-  a.map { |x| Card.new(x) }
-end
+  def random(min, max)
+    return nil if max < min
+    range = max - min + 1
+    return rand(range) + min
+  end
 
 =begin rdoc
-  Return a random shuffling of all 52 cards
+  A "helper method" that can be called via a probe, to print the contents
+  of an array during the execution of the permute method
 =end
 
-def shuffle
-  permutation((0..51).to_a).map { |x| Card.new(x) }
-end
+  def brackets(a, i, r)
+    res = "#{r}: "
+    if i <= 0
+      res += ("[" + a.join("  ") + "]")
+    elsif i >= a.length
+      res += (" " + a.join("  ") + "  [ ]")
+    else
+      pre = a.slice(0..(i-1))
+      post = a.slice(i..-1)
+      res += (" " + pre.join("  ") + " [" + post.join("  ") + "]")
+    end
+    return res
+  end
+
 
 =begin rdoc
   Classify a poker hand -- returns a symbol describing a hand.  Return values:
@@ -163,32 +140,40 @@ end
     :straight_flush
 =end
 
-# TODO:  royal flush in RAND test?
+  def poker_rank(a)
+    rcount = Array.new(Card::Ranks.length, 0)
+    scount = Array.new(Card::Suits.length, 0)
+    a.each do |x|
+      rcount[ Card::Ranks.index(x.rank) ] += 1
+      scount[ Card::Suits.index(x.suit) ] += 1
+    end
+    if rcount.max == 1
+      straight = (rcount.rindex(1) - rcount.index(1) == 4)
+      flush = scount.max == 5
+      return :straight_flush if (straight && flush) 
+      return :straight if straight
+      return :flush if flush
+      return :high_card
+    else
+      rcount.reject! { |x| x == 0 }
+      rcount.sort! { |x,y| y <=> x }
+      return :four_of_a_kind if rcount[0] == 4
+      return :full_house if (rcount[0] == 3 && rcount[1] == 2)
+      return :three_of_a_kind if rcount[0] == 3
+      return :two_pair if (rcount[0] == 2 && rcount[1] == 2)
+      return :pair
+    end
+  end
 
-def poker_hand(a)
-  rcount = Array.new(Card::Ranks.length, 0)
-  scount = Array.new(Card::Suits.length, 0)
-  a.each do |x|
-    rcount[ Card::Ranks.index(x.rank) ] += 1
-    scount[ Card::Suits.index(x.suit) ] += 1
+  def poker_rankings
+    return [:high_card, :pair, :two_pair, :three_of_a_kind, :straight, :flush, :full_house, :four_of_a_kind, :straight_flush]
   end
-  if rcount.max == 1
-    straight = (rcount.rindex(1) - rcount.index(1) == 4)
-    flush = scount.max == 5
-    return :straight_flush if (straight && flush) 
-    return :straight if straight
-    return :flush if flush
-    return :nada
-  else
-    rcount.reject! { |x| x == 0 }
-    rcount.sort! { |x,y| y <=> x }
-    return :four_of_a_kind if rcount[0] == 4
-    return :full_house if (rcount[0] == 3 && rcount[1] == 2)
-    return :three_of_a_kind if rcount[0] == 3
-    return :two_pair if (rcount[0] == 2 && rcount[1] == 2)
-    return :pair
+
+  def poker_counts
+    h = Hash.new
+    poker_rankings.each { |x| h[x] = 0 }
+    return h
   end
-end
 
 
 =begin rdoc
@@ -202,93 +187,343 @@ end
 # To test the expression that assigns suits and ranks:
 #   52.times { |x| puts (x/13).to_s + "  " + (x%13).to_s }
 
-class Card
-  attr_accessor :rank, :suit
+  class Card
+    attr_accessor :rank, :suit
   
-  unless defined? Suits
-    Suits = [:spades, :hearts, :diamonds, :clubs]
-  end
+    unless defined? Suits
+      Suits = [:spades, :hearts, :diamonds, :clubs]
+    end
   
-  unless defined? Ranks
-    Ranks = [:ace, :king, :queen, :jack, :ten, :nine, :eight, :seven, :six, :five, :four, :three, :two]
-  end
+    unless defined? Ranks
+      Ranks = [:ace, :king, :queen, :jack, :ten, :nine, :eight, :seven, :six, :five, :four, :three, :two]
+    end
   
-  def initialize(id = nil)
-    id = rand(52) if id.nil?
-    raise "card must be between 0 and 51" if id < 0 || id > 51
-    @suit = Suits[id / 13]
-    @rank = Ranks[id % 13]
-  end
+    def initialize(id = nil)
+      id = rand(52) if id.nil?
+      raise "card must be between 0 and 51" if id < 0 || id > 51
+      @suit = Suits[id / 13]
+      @rank = Ranks[id % 13]
+    end
   
-  def ==(x)
-    return @suit == x.suit && @rank == x.rank
-  end
+    def ==(x)
+      return @suit == x.suit && @rank == x.rank
+    end
   
-  def <=>(x)
-    r0 = Ranks.index(@rank); r1 = Ranks.index(x.rank)
-    s0 = Suits.index(@suit); s1 = Suits.index(x.suit) 
-    if (res = (s0 <=> s1)) == 0
-      return (r0 <=> r1)
-    else
-      return res
+    def <=>(x)
+      r0 = Ranks.index(@rank); r1 = Ranks.index(x.rank)
+      s0 = Suits.index(@suit); s1 = Suits.index(x.suit) 
+      if (res = (s0 <=> s1)) == 0
+        return (r0 <=> r1)
+      else
+        return res
+      end
     end
-  end
   
-  @@outputform = :utf8
+    @@outputform = :utf8
   
-  def inspect
-    s = ""
-    s << case @rank
-      when :ace     :  "A"
-      when :king    :  "K"
-      when :queen   :  "Q"
-      when :jack    :  "J"
-      when :ten     :  "10"
-      when :nine    :  "9"
-      when :eight   :  "8"
-      when :seven   :  "7"
-      when :six     :  "6"
-      when :five    :  "5"
-      when :four    :  "4"
-      when :three   :  "3"
-      when :two     :  "2"      
-    end
-    if $KCODE[0] == ?U
-      if @@outputform == :utf8
-        s << case @suit
-          when :spades    : "\xe2\x99\xa0"
-          when :hearts    : "\xe2\x99\xa5"
-          when :clubs     : "\xe2\x99\xa3"
-          when :diamonds  : "\xe2\x99\xa6"
+    def inspect
+      s = ""
+      s << case @rank
+        when :ace     :  "A"
+        when :king    :  "K"
+        when :queen   :  "Q"
+        when :jack    :  "J"
+        when :ten     :  "10"
+        when :nine    :  "9"
+        when :eight   :  "8"
+        when :seven   :  "7"
+        when :six     :  "6"
+        when :five    :  "5"
+        when :four    :  "4"
+        when :three   :  "3"
+        when :two     :  "2"      
+      end
+      if $KCODE[0] == ?U
+        if @@outputform == :utf8
+          s << case @suit
+            when :spades    : "\xe2\x99\xa0"
+            when :hearts    : "\xe2\x99\xa5"
+            when :clubs     : "\xe2\x99\xa3"
+            when :diamonds  : "\xe2\x99\xa6"
+          end
+        else
+          s << "!irb" + @suit.to_s.chop
         end
       else
-        s << "!irb" + @suit.to_s.chop
-      end
-    else
-      s << case @suit
-        when :spades    : "S"
-        when :hearts    : "H"
-        when :clubs     : "C"
-        when :diamonds  : "D"
+        s << case @suit
+          when :spades    : "S"
+          when :hearts    : "H"
+          when :clubs     : "C"
+          when :diamonds  : "D"
+        end
       end
+      return s
+      # "#{@rank} #{@suit}"
     end
-    return s
-    # "#{@rank} #{@suit}"
-  end
   
-  alias to_s inspect
+    alias to_s inspect
   
-  def Card.print_latex
-    @@outputform = :latex
-  end
+    def Card.print_latex
+      @@outputform = :latex
+    end
   
-  def Card.print_utf8
-    @@outputform = :utf8
-  end
+    def Card.print_utf8
+      @@outputform = :utf8
+    end 
   
+  end # class Card
+
+=begin rdoc
+  Visualization helpers (private):
+		make_canvas				create a new blank canvas (same one used for all tests)
+	Visualization methods called by students to test a PRNG object:
+		view(type,*args)	initialize canvas for a visualization of the specified type
+		tick_mark(i)			add a tick mark at location i on the number line
+  State vars maintained by the visualization methods:
+		@@drawing					initially nil, set to a Draw object when canvas has been created
+		@@tkroot					top level Tk application that manages the canvas (should never be used)
+		@@visual					set to :line, :histogram, or :dot_plot when drawing initialized
+		@@endpoint				last point on number line (value of n passed to init_line)
+=end
+
+  def make_canvas
+    require 'tk'
   
-end
+    if ! defined? @@tkroot
+    	@@tkroot = TkRoot.new { title "RandomLab" }
+  	end
+	
+  	if @@drawing == nil
+    	@@drawing = Draw.new(@tkroot) 
+    	@@threads = []
+    	@@threads << Thread.new() do
+    		Tk.mainloop
+    	end
+  	end
+  end
+
+	def view(*args)
+    kind = args.shift
+		if ! @@views.include?(kind)
+			puts "view type must be one of #{@@views.join(', ')}"
+		else
+			@@visual = kind
+			case kind
+				when :line
+          @@npoints = args[0]
+          if @@npoints.kind_of? Numeric
+      			make_canvas if @@drawing.nil?
+						@@drawing.new_line(@@npoints)
+					else
+						puts "usage: view(:line, npoints)"
+					end
+				when :dotplot
+          @@max = args[0]
+          if @@max.kind_of? Numeric
+      			make_canvas if @@drawing.nil?
+						@@drawing.new_dotplot(@@max)
+					else
+						puts "usage: view(:dotplot, max)"
+					end
+				when :histogram
+          if args[0].class == Array
+            @@keys = args[0]
+            @@nbins = @@max = @@keys.length
+            @@counts = Hash.new
+            @@keys.each { |k| @@counts[k] = 0 }
+          else
+            @@nbins, @@max = args
+            @@max = @@nbins if @@max.nil?
+            @@keys = nil
+          end
+          if [@@nbins, @@max].all? { |x| x.kind_of? Numeric }
+      			make_canvas if @@drawing.nil?  
+						@@drawing.new_histogram(@@nbins, @@max)
+					else
+						puts "usage: view(:histogram, nbins, max) or view(:histogram, keys)"
+					end
+			end
+		end
+	end
+
+	def tick_mark(i)
+		if @@visual != :line
+			puts "call 'view(:line,n)' to make a number line of size n'"
+		elsif i < 0 || i >= @@npoints
+			puts "tick_mark: 0 <= i < #{@@npoints}"
+		else
+			@@drawing.add_tick(i)
+			sleep(@@delay)
+		end
+		return nil
+	end
+
+  def update_bin(x)
+    if @@visual != :histogram
+      puts "call view(:histogram, n, max) to initialize a histogram with n bins"
+    else
+      i = @@keys ? @@keys.index(x) : x
+      if i.nil?
+        puts "unknown item: #{x}"
+      elsif i < 0 || i >= @@max
+        puts "count: 0 <= i < #{@@max}"
+      else
+			  @@drawing.add_hist(i)
+        @@counts[x] += 1 if @@keys
+			  sleep(@@delay) 
+      end     
+    end
+    return nil
+  end
+
+  def get_counts
+    return @@counts
+  end
+
+  def plot_point(x,y)
+    if @@visual != :dotplot
+      puts "call view(:dotplot, max) to initialize a dot plot"
+		elsif x < 0 || x >= @@max || y < 0 || y >= @@max
+			puts "plot_point: 0 <= x, y < #{@@max}"
+		else
+			@@drawing.add_point(x,y)
+			sleep(@@delay)
+		end
+		return nil
+  end
 
+
+=begin rdoc
+  Make a window to display dot plots and histograms
+=end
+	
+	class Draw 
+
+		attr_accessor :canvas, :ticks, :bins
+
+		@@canvasWidth = @@canvasHeight = 500
+  	@@tickHeight = 20
+  	@@tickWidth = 1
+  	@@traceSize = 10
+  	@@tickColor = 'blue'
+    @@histColor = '#000080'
+    @@dotSize = 2
+    @@dotColor = '#000080'
+
+  	def new_line(nticks)
+      self.erase_objects
+			@title = TkcText.new(@@drawing.canvas, 100, 10, :text => "Number Line")
+			@endpoint = nticks
+			y = @@canvasHeight / 2
+			@line = TkcLine.new( @canvas, 0, y, @@canvasWidth, y, :width => 3, :fill => '#777777' )
+			return nil
+  	end
+
+		def add_tick(i)
+			x = (i.to_f / @endpoint) * @@canvasWidth
+			y = @@canvasHeight / 2
+			@ticks << TkcLine.new( @canvas, x, y, x, y-@@tickHeight, :width => @@tickWidth, :fill => @@tickColor )			
+			@ticks.last(@@traceSize).each_with_index { |t,i| t['fill'] = @palette[i] }
+		end
+
+    def new_histogram(nbins, max)
+      self.erase_objects
+			@title = TkcText.new(@@drawing.canvas, 100, 10, :text => "Histogram")
+			@nbins, @max = nbins, max
+  		@baseline = @@canvasHeight / 2
+      w = @@canvasWidth / @nbins
+      @nbins.times do |i| 
+        x = i * w
+        @bins[i] = TkcRectangle.new( @canvas, x, @baseline, x+w, @baseline-3, :outline => "#CCCCCC", :fill => @@histColor ) 
+      end
+      @dy = 8.0
+      @yt = 50
+      return nil
+    end
+
+    def add_hist(x)
+      i = (x.to_f / @max) * @nbins
+      rect = @bins[i]
+      x1, y1, x2, y2 = rect.coords
+      y1 = y1 - @dy
+      rect.coords = [x1, y1, x2, y2]
+      if y1 < @yt
+        @bins.each do |rect|
+          x1, y1, x2, y2 = rect.coords
+          y1 =  @baseline - ((@baseline - y1) / 2)
+          rect.coords = [x1, y1, x2, y2]
+        end
+        @dy = @dy / 2
+      end
+    end
+
+    def new_dotplot(n)
+      self.erase_objects
+			@title = TkcText.new(@@drawing.canvas, 100, 10, :text => "Dot Plot")
+			@max = n.to_f
+    end
+
+    def add_point(i,j)
+      x = (i.to_f / @max) * @@canvasWidth
+      y = (j.to_f / @max) * @@canvasHeight
+      @points << TkcRectangle.new( @canvas, x, y, x+@@dotSize, y+@@dotSize, :outline => @@dotColor, :fill => @@dotColor ) 
+#			@points.last(@@traceSize).each_with_index { |p,i| p[:outline] = p['fill'] = @palette[i] }
+    end
+ 	
+  	def erase_objects
+      zap(@ticks)
+      zap(@bins)
+      zap(@points)
+      @title.delete if @title
+      @line.delete if @line
+			return nil
+  	end
+
+    private 
+
+    def zap(a)
+     	a.each { |x| x.delete }
+  	  a.clear
+    end
+  	
+  	# Make a range of colors starting from first and going to last in n steps.
+  	# First and last are expected to be 3-tuples of integer RGB values.  The
+  	# result is an array that starts with first, has n-1 intermediate colors,
+  	# and ends with last.  Example: 
+  	#    makePalette( [255,0,0], [0,0,0], 10) 
+  	# makes 11 colors starting with red and ending with black.
+
+  	def makePalette(first, last, n)
+  		d = Array.new(3)
+  		3.times { |i| d[i] = (first[i] - last[i]) / n }
+  		a = [first]
+  		(n-1).times do |i|
+  			a << a.last.clone 
+  			3.times { |j| a.last[j] -= d[j] }
+  		end
+  		a << last
+  		a.map { |c| sprintf("#%02X%02X%02X",c[0],c[1],c[2]) }
+  	end
+
+  	def initialize(parent) 
+  		content = TkFrame.new(parent)
+  		@canvas = TkCanvas.new(content, :borderwidth => 1, :width => @@canvasWidth, :height => @@canvasHeight) 
+   		@canvas.grid :column => 0, :row => 0, :columnspan => 4, :padx => 10, :pady => 10
+  		content.pack :pady => 20
+  		@palette = makePalette( [128,128,255], [32, 32, 255], @@traceSize-1 )
+			@palette << "#0000FF"
+      @ticks = Array.new
+      @bins = Array.new
+      @points = Array.new
+  	end 
+
+  end # class Draw
+    
+  @@drawing = nil
+	@@views = [:line, :dotplot, :histogram]
+  @@delay = 0.01
+  @@keys = nil
+  
 end # RandomLab
 
 end # RubyLabs