rubylabs 0.7.5 → 0.8.0

data/lib/demos.rb

@@ -0,0 +1,141 @@
+=begin rdoc
+  
+Methods in this module are not intended to be used by students.  They are
+implemented here so they can be tested before being included in the book
+or lecture slides.  Instructors can also load this module to use the methods
+in lectures.
+
+=end
+
+module RubyLabs
+	
+module Demos
+
+=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
+
+=begin rdoc
+  This version of the Sieve of Eratosthenes iterates until the worklist is
+  empty.  Use it as a baseline for counting the number of iterations, to
+  compare it to the actual version that iterates until finding the first
+  prime greater than sqrt(n)
+=end
+  
+	def sieve(n)
+	  worklist = Array(2..n)
+		primes = []
+
+	  while worklist.length > 0
+	    primes << worklist.first
+	    worklist.delete_if { |x| x % primes.last == 0 }
+	  end
+
+		return primes
+	end
+
+  def sequence(i,j)
+    Array(i..j)
+  end
+  
+=begin rdoc
+  The HashLab module has preliminary versions of insert and lookup methods
+  that don't use buckets; these are the final versions, with buckets.
+=end
+  
+  def insert(s, t)
+  	i = h(s, t.length)
+    t[i] = Array.new if t[i].nil?
+    t[i] << s
+    return i
+  end
+
+  def lookup(s, t)
+  	i = h(s, t.length)
+  	if t[i] && t[i].include?(s)
+  	  return i
+	  else
+	    return nil
+    end
+  end
+  
+=begin rdoc
+  This is the bare bones version of Eliza.transform, the method that 
+  applies transformation rule to make a response to a sentence.
+=end
+
+  def transform(sentence)
+  	queue = PriorityQueue.new
+  	Eliza.scan(sentence, queue)
+  	response = nil
+  	while queue.length > 0
+  		rule = queue.shift
+  		response = Eliza.apply(sentence, rule)
+  		break if response != nil
+  	end
+  	return response
+  end
+  
+=begin rdoc
+  Compare two ways of writing a loop
+=end
+
+  def loops(n)
+    i = 1
+    while i <= n
+      puts i ** 2
+      i += 1
+    end
+    
+    for i in 1..n
+      puts i**2
+    end
+  end
+  
+=begin rdoc
+  Simple demonstration of why nested loops lead to n^2 operations.  This
+  version is for a loop structure like the one in isort, but it also works
+  for any algorithm that needs all (i,j) pairs and that is symmetric, i.e.
+  (i,j) = (j,i).
+=end
+
+# :begin :nested
+  def nested(n)
+    count = 0
+    i = 0
+    while i < n
+      j = 0
+      while j < i
+        count += 1
+        j += 1
+      end
+      i += 1
+    end
+    return count
+  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
+
+
+
+end # Demos
+
+end # RubyLabs

data/lib/elizalab.rb

@@ -10,6 +10,10 @@ writing their own scripts.
 
 =end
 
+=begin
+  TODO don't add rule to queue more than once (e.g. word repeated in input sentence)
+=end
+
 module RubyLabs
   
 module ElizaLab
@@ -323,7 +327,7 @@ words (a|b|c), and variable names ($x) if they aren't already there.
 
     def Eliza.checkout(script, filename = nil)
       scriptfilename = script.to_s + ".txt"
-      scriptfilename = File.join(@@dataDirectory, scriptfilename)
+      scriptfilename = File.join(@@elizaDirectory, scriptfilename)
       if !File.exists?(scriptfilename)
         puts "Script not found: #{scriptfilename}"
         return nil
@@ -492,7 +496,7 @@ words (a|b|c), and variable names ($x) if they aren't already there.
   		  Eliza.clear
   			rule = nil
     	  if filename.class == Symbol
-    	    filename = File.join(@@dataDirectory, filename.to_s + ".txt")
+    	    filename = File.join(@@elizaDirectory, filename.to_s + ".txt")
         end
   			File.open(filename).each do |line|
   				line.strip!
@@ -615,7 +619,7 @@ words (a|b|c), and variable names ($x) if they aren't already there.
   # the ElizaLab module
   
   @@verbose = false
-	@@dataDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'eliza')
+	@@elizaDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'eliza')
 	@@pre = Dictionary.new
 	@@post = Dictionary.new
 	@@rules = Dictionary.new

data/lib/hashlab.rb

@@ -4,7 +4,7 @@
 
 Methods used in experiments on hash tables.  
 
-<b>NOTE:</b> the +insert+ and +find+ methods defined here are "stubs" used to test the hash
+<b>NOTE:</b> the +insert+ and +lookup+ 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.
 
@@ -13,45 +13,8 @@ methods that create and search buckets.
 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
+  TableView = Struct.new(:table, :nrows)
   
 =begin rdoc
 
@@ -98,18 +61,61 @@ RubyLabs module.
   string to hash, +n+ is the size of the hash table.
 =end
 
-# :begin :hn
-  def hn(s, n)
+# :begin :hr
+  def hr(s, n)
   	return radix26(s) % n  
   end
-# :end :hn
+# :end :hr
 
-  alias h hn
+=begin rdoc
+  Simple hash function used in the first project, to introduce the idea of hashing.
+  Uses a default table size of 10 and the h0 method (which just looks at the first
+  letter in a string).
+=end
+
+# :begin :h
+def h(s, n = 10)
+  return s[0].ord % n
+end
+# :end :h
+
+=begin rdoc
+  Method used in the first project: if +s+ can be added to +t+ (i.e. if no
+  collision) return the location, otherwise return +nil+
+=end
+	
+# :begin :insert
+  def insert(s, t)
+  	i = h(s, t.length)
+    if t[i].nil?
+      t[i] = s
+      return i
+    else
+      return nil
+    end
+  end
+# :end :insert
+
+=begin rdoc
+  Method used in the first project: if +s+ is in array +t+ return the location,
+  otherwise return +nil+
+=end
+
+# :begin :lookup
+  def lookup(s, t)
+  	i = h(s, t.length)
+  	if t[i] == s
+  	  return i
+	  else
+	    return nil
+    end
+  end
+# :end :lookup
 
 =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
+an alternative hash function (<tt>:h0</tt> or <tt>:h1</tt>); the default is the method +hr+, which
 uses the radix26 function.
 
 The object returned by this method is an array of the designated size.  A bit of
@@ -120,104 +126,156 @@ Ruby magic defines three new methods just for the new object:
 
 =end
 
-  def make_table(n, f = nil)
-    t = Array.new(n)
-  
-    class <<t
-      attr_accessor :h
+  class HashTable
     
-      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
+    @@hash_functions = [:h0, :h1, :hr]
+    
+    attr_reader :table
 
+    def initialize(n, f = :hr)
+      raise "HashTable: hash function must be one of #{@@hash_functions.inspect}" unless @@hash_functions.include?(f)
+      @table = Array.new(n)
+      @hash = f
+    end
+    
+    # def hash(s)
+    #   return case @h
+    #     when :h0 : h0(s, @table.length)
+    #     when :h1 : h1(s, @table.length)
+    #     else       hr(s, @table.length)
+    #   end
+    # end
+    
+    def lookup(s)
+    	i = send(@hash, s, @table.length)
+    	return ( @table[i] && @table[i].include?(s) ) ? i : nil
+    end
+    
+    def insert(s)
+    	i = send(@hash, s, @table.length)
+      @table[i] = Array.new if @table[i].nil?
+      @table[i] << s
+      return i
+    end
+    
+    def to_s
+      print_table(self)
+    end
+    
+    def inspect
+      sprintf '#<RubyLabs::HashLab::HashTable: %d rows, :%s>', @table.size, @hash.to_s
+    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>.
+  Print usage statistics for the table.  Prints lengths of longest and shortest
+  buckets, number of empty buckets, and mean bucket length.
 =end
 	
-# :begin :find
-  def find(s, t)
-  	i = t.hash(s)
-  	return (t[i] == s)
-  end
-# :end :find
+    def print_stats
+      max = 0
+      min = Float::MAX
+      nzero = 0
+      sum = 0
+      @table.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
+      printf "shortest bucket: %d\n", min
+      printf "longest bucket:  %d\n", max
+      printf "empty buckets:   %d\n", nzero
+      if max > 0
+        printf "mean bucket length:  %.2f\n", sum.to_f / (@table.length - nzero)
+      end
+    	return nil
+    end
 
 =begin rdoc
-  Insert string +s+ into hash table +t+.  The
-  table must be an object created by a call to <tt>make_table</tt>.
+  Return a list of indices for buckets that have more than +cutoff+ entries.
 =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
+
+    def long_rows(cutoff = 5)
+      rows = Array.new
+    	@table.each_with_index do |row, i| 
+    	  rows << i if !row.nil? && row.length > cutoff
+  	  end
+    	return rows
     end
-  end
-# :end :insert
+    
+  end # HashTable
 
 =begin rdoc
-  Print a nicely formatted representation of hash table +t+.  The optional parameter
+  Print a nicely formatted representation of hash table.  The parameter +t+ can be
+  an array or a HashTable object.  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)
+    t = t.table if t.class == HashTable
     max = t.length unless max
-  	max.times { |i| print_row(i, t) unless t[i].nil? }
-  	nil
+  	max.times { |i| print_row(i, t[i] ) unless t[i].nil? }
+  	return nil
   end
 
-  def print_row(n, t)   # :nodoc:
-  	printf "%4d: ", n
-  	p t[n]
+  def print_row(n, row)   # :nodoc:
+  	printf "%4d: %s\n", n, row.inspect
   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.
+  Verification of numbers shown in the table for the birthday paradox.  Call
+  birthday(n,m) to make a table with n rows and fill it with m random words.
+  Return true if any row has more than one item.
 =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
 
+  def birthday(n, m)
+    t = HashTable.new(n)
+    TestArray.new(m, :words).each { |s| t.insert(s) }
+    # puts t
+    t.table.each { |row| return true if row && row.length > 1 }
+    return false
+  end
+  
 =begin rdoc
-  Scan the hash table +t+ and print all the buckets that have more than +cutoff+ entries.
+  Initialize the canvas with a drawing of an hash table +t+ (a table is
+  just an array augmented with a hash method)
 =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
+  def view_table(t, userOptions = {} )
+    options = @@tableOptions.merge(userOptions)
+    Canvas.init(300, 500, "HashLab")
+    tbl = t.table
+    x0 = options[:tableX]
+    x1 = x0 + options[:cellWidth]
+    # if nil, color = gray, else color = white and draw text
+    # todo -- arrow
+    # todo -- save text, update with call to insert
+    nrows = min(tbl.size, options[:maxRows])
+    nrows.times do |i|
+      y0 = options[:tableY] + i * (options[:cellHeight] + options[:cellYSpace])
+      y1 = y0 + options[:cellHeight]
+      Canvas.rectangle(x0, y0, x1, y1, :fill => options[:cellColor])
+      # Canvas.text(tbl[i].inspect, textx, y0)
+    end
+    @@drawing = TableView.new(t, nrows)
+    Canvas.sync
+    return true    
   end
+
+  @@tableOptions = {
+    :tableX => 20,
+    :tableY => 20,
+    :cellHeight => 15,
+    :cellYSpace => 2,
+    :cellWidth => 30,
+    :cellColor => :lightgray,
+    :textX => 70,
+    :maxRows => 25,
+  }
+  
+
   
 end # HashLab
 

data/lib/introlab.rb

@@ -1,14 +1,53 @@
 =begin rdoc
   
-Fahrenheit to Celsius conversion.
+Methods used in Chapter 2 (the Ruby Workbench)
 
 =end
 
+module RubyLabs
+	
+module IntroLab
+
+=begin rdoc
+  Compute the area of a 5-sided counter that is a square with a missing
+  triangle shape.  The parameter +x+ is the length of one side of the square.
+=end
+
+# :begin :countertop 
+  def countertop(x)
+    square = x**2
+    triangle = ((x/2)**2) / 2
+    return square - triangle
+  end
+# :end :countertop
+
 =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
+  def celsius(f)
+    (f - 32) * 5 / 9
+  end
+
+# :begin :fahrenheit
+  def fahrenheit(c)
+    # your expression goes here
+  end
+# :end :fahrenheit
+
+# :begin :payment
+  def payment(c)
+    # your expression goes here
+  end
+# :end :payment
+
+# :begin :payment
+  def era(runs, ip)
+    return (9.0 / ip) * runs
+  end
+# :end :payment
+
+end # IntroLab
+
+end # RubyLabs

data/lib/iterationlab.rb

@@ -51,20 +51,20 @@ 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
+# :begin :isort :move_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
+	    move_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)
+# :begin :move_left
+  def move_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])
@@ -72,7 +72,7 @@ and insert it back into the array at the new location.
     end
     a.insert(j+1, x)							  # insert x back into a at location j    
   end
-# :end :insert_left
+# :end :move_left
 
 # :begin :less
   def less(x, y)
@@ -80,34 +80,6 @@ and insert it back into the array at the new location.
   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.

data/lib/marslab.rb

@@ -289,7 +289,7 @@ module MARSLab
 			
   	def initialize(filename)
   	  if filename.class == Symbol
-  	    filename = File.join(@@dataDirectory, filename.to_s + ".txt")
+  	    filename = File.join(@@marsDirectory, filename.to_s + ".txt")
       end
 
       if ! File.exists?(filename)
@@ -1062,7 +1062,7 @@ module MARSLab
     def MARS.listing(prog, dest = nil)
       filename = prog.to_s
       filename += ".txt" unless filename =~ /\.txt$/
-      filename = File.join(@@dataDirectory, filename)
+      filename = File.join(@@marsDirectory, filename)
       dest = STDOUT if dest.nil?
       if !File.exists?(filename)
         puts "File not found: #{filename}"
@@ -1092,8 +1092,8 @@ module MARSLab
 =end
 
     def MARS.dir
-      puts "Redcode programs in #{@@dataDirectory}:"
-      Dir.open(@@dataDirectory).each do |file|
+      puts "Redcode programs in #{@@marsDirectory}:"
+      Dir.open(@@marsDirectory).each do |file|
         next if file[0] == ?.
         file.slice!(/\.txt/)
         puts "  " + file
@@ -1120,7 +1120,7 @@ module MARSLab
     # -- Initializations -- These are "global" vars in the outer MARSLab scope that are
     # accessible to all the classes and modules defined inside MARSLab
   
-	@@dataDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'mars')
+	@@marsDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'mars')
 
   @@opcodes = ["DAT", "MOV", "ADD", "SUB", "JMP", "JMZ", "JMN", "DJN", "CMP", "SPL", "END", "SLT", "EQU"]
   @@modes = "@<#"