rubylabs 0.5.4

data/lib/hashlab.rb

@@ -0,0 +1,224 @@
+=begin rdoc
+  
+== HashLab
+
+Methods used in experiments on hash tables.  
+
+<b>NOTE:</b> the +insert+ and +find+ methods defined here are "stubs" used to test the hash
+functions.  Load the file <tt>hashmethods.rb</tt> to overwrite the stubs with the actual
+methods that create and search buckets.
+
+=end
+
+module RubyLabs
+
+module HashLab
+
+=begin rdoc
+
+Ruby version of the ``card catalog box'' number, a trivial hash function that
+maps two-letter strings to numbers between 0 and 675.
+
+=end
+
+# :begin :ccb
+  def ccb(s) 
+    return s[0].ord * 26 + s[1].ord
+  end
+# :end :ccb
+  
+=begin rdoc
+
+The "small card catalog box" number, a version of ccb that works
+for a smaller catalog (n = 100 boxes).
+
+=end
+
+# :begin :sccb
+  def sccb(s) 
+    return ccb(s) % 100
+  end
+# :end :sccb
+  
+=begin rdoc
+
+"Randomized" version of sccb that uses prime numbers to do
+a better job of scattering words more evenly.
+
+=end
+
+# :begin :rccb
+  def rccb(s) 
+    return (s[0].ord * 31 + s[1].ord * 107) % 100
+  end
+# :end :rccb
+  
+=begin rdoc
+
+Compute the sum of the letters in a string, where each letter is weighted
+according to its position.  Requires the +ord+ method added to Fixnum in the
+RubyLabs module.
+
+=end
+
+# :begin :radix26
+  def radix26(s)
+  	x = 0
+  	s.each_byte do |b|
+  		x = x * 26 + b.ord
+  	end
+  	return x
+  end
+# :end :radix26
+
+=begin rdoc
+  Trival hash function that uses only the first letter in the input string.  +s+ is the
+  string to hash, +n+ is the size of the hash table.
+=end
+
+# :begin :h0
+  def h0(s, n)
+  	return s[0].ord % n  
+  end
+# :end :h0
+
+=begin rdoc
+  Slightly better hash function that uses the first two letters in the input string.  +s+ is the
+  string to hash, +n+ is the size of the hash table.
+=end
+
+# :begin :h1
+  def h1(s, n)
+  	return ((s[0].ord * 26) + s[1].ord) % n  
+  end
+# :end :h1
+
+=begin rdoc
+  Hash function based on the radix-26 representation of the input string.  +s+ is the
+  string to hash, +n+ is the size of the hash table.
+=end
+
+# :begin :hn
+  def hn(s, n)
+  	return radix26(s) % n  
+  end
+# :end :hn
+
+  alias h hn
+
+=begin rdoc
+  
+Make a hash table with +n+ buckets.  The optional parameter is a symbol specifying
+an alternative hash function (<tt>:h0</tt> or <tt>:h1</tt>); the default is the method +hn+, which
+uses the radix26 function.
+
+The object returned by this method is an array of the designated size.  A bit of
+Ruby magic defines three new methods just for the new object:
+[<tt>h=(f)</tt>] tells the table to use method f for the hash function (:h0, :h1, or nil)
+[<tt>h</tt>] returns the id of the hash function currently being used
+[<tt>hash(s)</tt>] call the current hash function on string s
+
+=end
+
+  def make_table(n, f = nil)
+    t = Array.new(n)
+  
+    class <<t
+      attr_accessor :h
+    
+      def hash(s)
+        return case self.h
+          when :h0 : h0(s, self.size)
+          when :h1 : h1(s, self.size)
+          else       hn(s, self.size)
+        end
+      end
+    end
+  
+    t.h = f
+    return t
+  end
+
+=begin rdoc
+  Return +true+ or +false+, depending on whether string +s+ is in hash table +t+.  The
+  table must be an object created by a call to <tt>make_table</tt>.
+=end
+	
+# :begin :find
+  def find(s, t)
+  	i = t.hash(s)
+  	return (t[i] == s)
+  end
+# :end :find
+
+=begin rdoc
+  Insert string +s+ into hash table +t+.  The
+  table must be an object created by a call to <tt>make_table</tt>.
+=end
+	
+# :begin :insert
+  def insert(s, t)
+  	i = t.hash(s)
+    if t[i].nil?
+      t[i] = s
+      return true
+    else
+      puts "collision!"
+      return false
+    end
+  end
+# :end :insert
+
+=begin rdoc
+  Print a nicely formatted representation of hash table +t+.  The optional parameter
+  is the number of rows to print, e.g. to print just the first 10 rows of a large table
+  +t+ call <tt>print_table(t,10)</tt>.  Skips rows that have empty buckets.
+=end
+
+  def print_table(t, max = nil)
+    max = t.length unless max
+  	max.times { |i| print_row(i, t) unless t[i].nil? }
+  	nil
+  end
+
+  def print_row(n, t)   # :nodoc:
+  	printf "%4d: ", n
+  	p t[n]
+  end
+
+=begin rdoc
+  Print usage statistics for hash table +t+.  Prints lengths of longest and shortest
+  buckets, number of empty buckets, and mean bucket length.
+=end
+	
+  def print_stats(t)
+    max = 0
+    min = Float::MAX
+    nzero = 0
+    sum = 0
+    t.each do |bucket|
+    	n = bucket.nil? ? 0 : bucket.length
+      min = n if n < min
+      max = n if n > max
+      sum += n
+      nzero += 1 if n == 0
+    end
+    puts "shortest bucket: #{min} items"
+    puts "longest bucket: #{max} items"
+    puts "empty buckets: #{nzero}"
+    puts "mean bucket length: #{sum.to_f / (t.length - nzero)}" unless nzero == t.length
+  	nil
+  end
+
+=begin rdoc
+  Scan the hash table +t+ and print all the buckets that have more than +cutoff+ entries.
+=end
+
+  def print_long_rows(t, cutoff = 5)
+  	t.length.times { |i| print_row(i, t) if !t[i].nil? && t[i].length >= cutoff }
+  	nil
+  end
+  
+end # HashLab
+
+end # RubyLabs

data/lib/introlab.rb

@@ -0,0 +1,14 @@
+=begin rdoc
+  
+Fahrenheit to Celsius conversion.
+
+=end
+
+=begin rdoc
+  Convert the temperature +f+ (in degrees Fahrenheit) into the equivalent
+  temperature in degrees Celsius.
+=end
+
+def celsius(f)
+  (f - 32) * 5 / 9
+end

data/lib/iterationlab.rb

@@ -0,0 +1,130 @@
+
+=begin rdoc
+  
+== IterationLab
+
+The methods implemented in this module are 
++contains?+ (linear search returning true or false),
++location+ (linear search returning the index of specified item), and
++isort+ (insertion sort).  See the RecursionLab module for more
+sophisticated "divide and conquer" searching and sorting algorithms.  
+
+=end
+
+module RubyLabs
+
+module IterationLab
+
+=begin rdoc
+Do a linear search of array +a+ to find item +key+, returning
++true+ or +false+ depending on whether the item was found.  
+=end
+
+# :begin :contains?
+	def contains?(a, k)
+	  a.each { |x| return true if x == k}
+		return false
+	end
+# :end :contains?
+
+=begin rdoc
+Do a linear search of array +a+ to find item +k+, returning
+the index of the first occurrence of +k+ or +nil+ if +k+ is
+not found.  
+=end
+
+# :begin :search
+	def search(a, k)
+	  i = 0
+	  while i < a.length
+	    return i if a[i] == k
+	    i += 1
+	  end
+		return nil
+	end
+# :end :search
+
+=begin rdoc
+Return a copy of +array+, sorted with the insertion sort algorithm.  
+On each iteration remove an item from the
+array, find a location for it to the left of its original position,
+and insert it back into the array at the new location.
+=end
+
+# :begin :isort :insert_left :less
+	def isort(array)
+	  a = array.clone           # don't modify the input array....
+	  i = 1
+	  while i < a.length
+	    insert_left(a, i)       # find a place for a[i] somewhere to the left
+	    i += 1
+	  end
+	  return a
+	end
+# :end :isort
+
+# :begin :insert_left
+  def insert_left(a, i)
+    x = a.slice!(i)								  # remove the item at location i
+    j = i-1													# start scanning from the left of i
+    while j >= 0 && less(x, a[j])
+      j = j-1												# move left
+    end
+    a.insert(j+1, x)							  # insert x back into a at location j    
+  end
+# :end :insert_left
+
+# :begin :less
+  def less(x, y)
+    return x < y
+  end
+# :end :less
+
+=begin rdoc
+Simple demonstration of why nested loops lead to n^2 operations
+=end
+
+# :begin :nested
+  def nested(n)
+    n.times do |i|
+      n.times do |j|
+        puts "i = #{i}, j = #{j}"
+      end
+    end
+  end
+# :end :nested
+
+# code used in figure next to nested
+
+  def isnest(n)
+    i = 1
+    while i < n
+      j = i-1
+      while j >= 0 
+        puts "i = #{i}, j = #{j}"
+        j = j-1
+      end
+      i = i+1
+    end
+  end
+
+=begin rdoc
+A helper method that can be called from a probe to display the contents
+of an array during a search or sort.
+=end
+
+	def brackets(a, i)
+	  if i <= 0
+	    return ("[" + a.join("  ") + "]")
+    elsif i >= a.length
+      return " " + a.join("  ") + "  [ ]"
+    else
+      pre = a.slice(0..(i-1))
+      post = a.slice(i..-1)
+      return " " + pre.join("  ") + " [" + post.join("  ") + "]"
+	  end
+	end
+	
+end # IterationLab
+
+end # RubyLabs

data/lib/randomlab.rb

@@ -0,0 +1,294 @@
+
+=begin rdoc
+  
+== RandomLab
+
+Random number generators and associated methods.
+
+=end
+
+module RubyLabs
+	
+module RandomLab
+  
+require 'statistics2.rb'
+
+=begin rdoc
+  Simple random number generator, using "roulette wheel" algorithm.
+=end
+
+class Wheel
+  
+  @@x = 0
+  @@c = 337
+  @@m = 1000
+  
+  def Wheel.rand(n)
+    @@x = (@@x + @@c) % @@m
+    return @@x % n
+  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"
+    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
+  
+  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"
+    end
+  end
+  
+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
+  end
+  return counts
+end
+# :end :poker_test
+
+=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).
+=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]
+  end
+  return sum
+end
+
+=begin rdoc
+  Make a random array of +n+ Card objects (selected without replacement).
+=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)
+  end
+  return a
+end
+
+=begin rdoc
+  Make a hand using numbers in array +a+ (used for testing)
+=end
+
+def deal(a)
+  a.map { |x| Card.new(x) }
+end
+
+=begin rdoc
+  Return a random shuffling of all 52 cards
+=end
+
+def shuffle
+  permutation((0..51).to_a).map { |x| Card.new(x) }
+end
+
+=begin rdoc
+  Classify a poker hand -- returns a symbol describing a hand.  Return values:
+    :pair
+    :two_pair
+    :three_of_a_kind
+    :full_house
+    :straight
+    :flush
+    :four_of_a_kind
+    :straight_flush
+=end
+
+# TODO:  royal flush in RAND test?
+
+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
+  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
+  end
+end
+
+
+=begin rdoc
+  Class to represent cards from a standard 52-card deck.  Includes comparators
+  to sort by rank or suit.
+  
+  Call Card.new to get a random card, or Card.new(id) to get a specific card
+  where id is a number between 0 and 51.
+=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
+  
+  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
+  
+  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)
+    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
+  
+  @@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"
+        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"
+      end
+    end
+    return s
+    # "#{@rank} #{@suit}"
+  end
+  
+  alias to_s inspect
+  
+  def Card.print_latex
+    @@outputform = :latex
+  end
+  
+  def Card.print_utf8
+    @@outputform = :utf8
+  end
+  
+  
+end
+
+end # RandomLab
+
+end # RubyLabs