rubylabs 0.8.0 → 0.8.1

data/README.rdoc

@@ -1,9 +1,30 @@
-= rubylabs
+== Description
 
-The modules in this Gem have methods and data for lab projects in the textbook
-<em>The Science of Computing: A Problem Solving Approach</em>.  There is one module
-for each chapter, plus a set of common methods shared by more than one module.
+RubyLabs is a collection of modules used for tutorial exercises in the textbook
+<em>{Explorations in Computing: An Introduction to Computer Science}[http://www.cs.uoregon.edu]</em>.  
+There is one module for each chapter in the text:
 
-== Copyright
+<b>IntroLab[link:classes/RubyLabs/IntroLab.html]</b>:: A quick introduction to Ruby, with an exercise leading to the definition of a method to convert temperatures from Fahrenheit to Celsius.
+<b>SieveLab[link:classes/RubyLabs/SieveLab.html]</b>:: A project on the Sieve of Eratosthenes, an algorithm for generating lists of prime numbers.
+<b>IterationLab[link:classes/RubyLabs/IterationLab.html]</b>:: Simple iterative algorithms for searching and sorting.
+<b>RecursionLab[link:classes/RubyLabs/RecursionLab.html]</b>:: More sophisticated algorithms, using a divide and conquer strategy.
+<b>HashLab[link:classes/RubyLabs/HashLab.html]</b>:: Using a hash table to represent a word list, e.g. for a crossword puzzle dictionary.
+<b>BitLab[link:classes/RubyLabs/BitLab.html]</b>:: Projects with binary encodings, including methods for simple error correction with parity bits and text compression with Huffman codes.
+<b>MARSLab[link:classes/RubyLabs/MARSLab.html]</b>:: Using the game of Core War to explore the von Neumann architecture.
+<b>RandomLab[link:classes/RubyLabs/RandomLab.html]</b>:: Creating lists of random numbers with a pseudo-random number generator.
+<b>ElizaLab[link:classes/RubyLabs/ElizaLab.html]</b>:: An introduction to issues in natural language processing, using a version of ELIZA written in Ruby.
+<b>SphereLab[link:classes/RubyLabs/SphereLab.html]</b>:: Introduction to modeling and simulation, culminating in an N-body simulation of the movement of planets in the Solar System.
+<b>TSPLab[link:classes/RubyLabs/TSPLab.html]</b>:: Solving the Traveling Salesman Problem with a genetic algorithm.
+ 
+The main *RubyLabs* module has some common methods (e.g. min and max) used throughout the book.
+
+== Installing
+
+== Examples
+
+== Documentation
+
+A lab manual is available from http://ix.cs.uoregon.edu/~conery/eic.
+
+== Questions
 
-Copyright (c) 2009 John S. Conery. See LICENSE for details.

data/Rakefile

@@ -6,7 +6,7 @@ begin
   Jeweler::Tasks.new do |gem|
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
     gem.name = "rubylabs"
-    gem.summary = %Q{Software and data for lab projects in the Science of Computing text.}
+    gem.summary = %Q{Software and data for lab projects for Explorations in Computing.}
     gem.description = %Q{A set of modules for interactive experiments in an introductory computer science class.}
     gem.email = "conery@cs.uoregon.edu"
     gem.homepage = "http://github.com/conery/rubylabs"

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.8.1

data/data/eliza/doctor.txt

@@ -57,7 +57,7 @@ remember 5
 
 if 3 
   /if (.*)/ 
-    "Do you think its likely that $1?"
+    "Do you think it's likely that $1?"
     "Do you wish that $1?"
     "What do you think about $1?"
     "Really, if $1?"

data/data/tsp/ireland.txt

@@ -8,16 +8,16 @@
 
 :matrix driving distances (in kilometers) between cities
 
-belfast cork 422
-belfast dublin 157
-belfast galway 331
-belfast limerick 364
+belfast cork 425
+belfast dublin 167
+belfast galway 306
+belfast limerick 323
 
-cork dublin 254
-cork galway 200
-cork limerick 100
+cork dublin 257
+cork galway 209
+cork limerick 105
 
-dublin galway 214
-dublin limerick 100
+dublin galway 219
+dublin limerick 198
 
-galway limerick 101
+galway limerick 105

data/lib/bitlab.rb

@@ -10,7 +10,9 @@ module RubyLabs
 
 module BitLab
 
-  QueueView = Struct.new(:queue)
+  QueueView = Struct.new(:queue, :options)
+  NodeView = Struct.new(:circle, :text, :ftext, :lseg, :rseg)
+  NodeCoords = Struct.new(:x, :y, :leftedge, :leftdepth, :rightedge, :rightdepth)
 
 =begin rdoc
   Make a unique binary code for each item in array +a+, returning a Hash that
@@ -163,7 +165,7 @@ module BitLab
     while pq.length > 1
       n1 = pq.shift
       n2 = pq.shift
-      pq << Node.combine( n1, n2)
+      pq << Node.combine(n1, n2)
     end
 
     return pq[0]
@@ -286,7 +288,8 @@ module BitLab
   are Nodes for the roots of subtrees.
   
   Use +new+ to create a new leaf node.  Call the class method +combine+ (an alternative 
-  constructor) to make a new interior node from two existing nodes.
+  constructor) to make a new interior node from two existing nodes.  If the tree is
+  being displayed on the RubyLabs canvas, make a graphic for the new interior node, too. 
   
   The +<+ method allows Nodes to be compared so they can be ordered in a priority
   queue.
@@ -294,18 +297,32 @@ module BitLab
 
   class Node
 
-    attr_accessor :freq, :char, :left, :right
-
+    attr_accessor :freq, :char, :left, :right, :drawing, :coords, :lfchain, :rfchain, :depth
+    
     def initialize(char,freq)
       @char = char
       @freq = freq
   		@left = @right = nil
-    end
-
-    def Node.combine(n1,n2)
-      node = Node.new(nil, n1.freq + n2.freq)
-      node.left = n1
-      node.right = n2
+  		@drawing = @coords = nil
+  		@lfchain = @rfchain = self
+  		@depth = 0
+    end
+
+    # todo -- need to follow chains to end when updating shallower tree
+
+    def Node.combine(leftdesc, rightdesc)
+      node = Node.new(nil, leftdesc.freq + rightdesc.freq)
+      node.left = leftdesc
+      node.right = rightdesc
+      node.depth = 1 + max(leftdesc.depth, rightdesc.depth)
+      node.lfchain = leftdesc
+      node.rfchain = rightdesc
+      if leftdesc.depth > rightdesc.depth
+        rightdesc.rfchain = leftdesc.rfchain
+      elsif leftdesc.depth < rightdesc.depth
+        leftdesc.lfchain = rightdesc.lfchain
+      end
+      draw_root(node, leftdesc, rightdesc) if (leftdesc.drawing && rightdesc.drawing)
       return node
     end
     
@@ -559,28 +576,74 @@ module BitLab
   
   end # Message
   
+  def move_tree(tree, dx, dy)
+    tree.coords.x += dx
+    tree.coords.y += dy
+    Canvas.move(tree.drawing.circle, dx, dy)
+    Canvas.move(tree.drawing.text, dx, dy)
+    Canvas.move(tree.drawing.ftext, dx, dy) if tree.drawing.ftext
+    if tree.left
+      Canvas.move(tree.drawing.lseg, dx, dy)
+      move_tree(tree.left, dx, dy) 
+    end
+    if tree.right
+      Canvas.move(tree.drawing.rseg, dx, dy)
+      move_tree(tree.right, dx, dy)
+    end
+    Canvas.sync
+  end
+  
+  def draw_root(node, left, right)
+    opts = @@drawing.options
+    x = (left.coords.x + right.coords.x) / 2
+    y = left.coords.y - 2 * @@unit
+    draw_node(node, x, y)
+    node.drawing.lseg = Canvas.line(x, y, left.coords.x, left.coords.y).lower
+    node.drawing.rseg = Canvas.line(x, y, right.coords.x, right.coords.y).lower
+    # [left, right].each do |desc|
+    #   desc.drawing.ftext.delete
+    #   desc.drawing.ftext = nil
+    # end
+  end
+
+  def draw_node(node, x, y)
+    return nil unless @@drawing
+    opts = @@drawing.options
+    d = @@unit
+    circ = Canvas.circle( x, y, d / 2, :fill => opts[:nodefill] )
+    text = Canvas.text( node.char, x, y, :anchor => :center )
+    ftext = Canvas.text( node.freq.to_s, x, y-d, {:font => opts[:freqfont], :anchor => :center} )
+    node.drawing = NodeView.new(circ, text, ftext, nil, nil)
+    node.coords = NodeCoords.new(x, y, x, 0, x, 0)
+  end
+  
 =begin rdoc
   Initialize the canvas with a drawing of a priority queue.
 =end
 
-=begin
-  TODO fill in this stub...
-=end
-
   def view_queue(pq, userOptions = {} )
-    options = @@queueOptions.merge(userOptions)
-    Canvas.init(300, 500, "BitLab")
-    @@drawing = QueueView.new(pq)
+    options = @@queueViewOptions.merge(userOptions)
+    Canvas.init(options[:width], options[:height], "BitLab")
+    @@drawing = QueueView.new(pq, options)
+    options[:nodefill] = "lightgray"
+    options[:freqfont] = Canvas.font(:family => 'Helvetica', :size => 10)
     pq.on_canvas = true
+    x = options[:qx]
+    pq.each_with_index do |node, i|
+      draw_node(node, x, options[:qy])
+      x += 3 * @@unit
+    end
     Canvas.sync
     return true    
   end
   
-  def redraw_queue(pq)
-    puts "redraw: #{pq.inspect}"
-  end
-
-  @@queueOptions = {
+  @@unit = 24           # pixels per "tree unit"
+  
+  @@queueViewOptions = {
+    :width => 42 * @@unit,
+    :height => 15 * @@unit,
+    :qy => 50,
+    :qx => 50,
   }
 
   @@bitsDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'huffman')
@@ -590,27 +653,83 @@ end # BitLab
 end # RubyLabs
 
 =begin rdoc
-  Add hooks to the PriorityQueue's shift and << methods so they check to see if the 
-  queue is on the canvas, and if so, update the drawing when an item is removed or added.
+  Add an update method to the PriorityQueue so nodes are moved around on the screen when
+  they are removed from or added to the queue (if the queue is on the canvas). 
+  Note: the << and shift methods call this method when @on_canvas is true.... 
 =end
 
+=begin
+  TODO make time to sleep a parameter
+  todo add comments, rdoc
+  todo distance in units (down, up, spacing) should also be params
+  todo clean up def of Node -- coords not being used, combine with graphics
+=end
 class PriorityQueue
 
   attr_accessor :on_canvas
   
-  alias_method :pqappend, :<<
-
-  def <<(obj)
-    res = pqappend(obj)
-    redraw_queue(self) if on_canvas
-    return res
+  def update(op, node)
+    if op == :shift
+      move_tree(node, 0, 4 * @@unit)         # move subtree rooted at node down 4 units
+    else
+      i = 0
+      dx = @@drawing.options[:qx] - left_edge(@q[0])
+      while @q[i] != node
+        move_tree(@q[i], dx, 0)
+        dx = 3 * @@unit - tree_sep(@q[i], node)
+        move_tree(node, dx, 0)
+        dx = 3 * @@unit - tree_sep(@q[i], @q[i+1])
+        i += 1
+        sleep(0.2)
+      end
+      move_tree(node, 0, -2 * @@unit)
+      if i < @q.length - 1
+        dx = 3 * @@unit - tree_sep(@q[i], @q[i+1])
+        i += 1
+        while i < @q.length
+          sleep(0.2)
+          move_tree(@q[i], dx, 0)
+          i += 1
+        end
+      end
+    end
   end
-
-  alias_method :pqshift, :shift
-
-  def shift
-    res = pqshift
-    redraw_queue(self) if on_canvas
+  
+  def left_edge(tree)
+    x = tree.coords.x
+    while tree.lfchain != tree
+      tree = tree.lfchain
+      x = min(x, tree.coords.x)
+    end
+    return x
+  end
+  
+  def right_edge(tree)
+    x = tree.coords.x
+    while tree.rfchain != tree
+      tree = tree.rfchain
+      x = max(x, tree.coords.x)
+    end
+    return x
+  end
+  
+  def tree_sep(left, right)
+    res = right.coords.x - left.coords.x
+    while (left.rfchain != left && right.lfchain != right)
+      left = left.rfchain
+      right = right.lfchain
+      dist = right.coords.x - left.coords.x
+      res = dist if dist < res
+    end
+    # loop do
+    #   puts "res = #{res}"
+    #   break if left == left.rfchain || right == right.lfchain
+    #   left = left.rfchain
+    #   right = right.lfchain
+    #   puts "down #{left.inspect} --- #{right.inspect}"
+    #   dist = right.coords.x - left.coords.x
+    #   res = dist if dist < res
+    # end
     return res
   end
 
@@ -649,3 +768,17 @@ class Fixnum
   
 end
 
+=begin
+  TODO delete this 
+=end
+
+def test_view
+  vf = read_frequencies(:hafreq)
+  pq = init_queue(vf)
+  view_queue(pq)
+  Canvas.sync
+  return pq
+end
+
+
+

data/lib/demos.rb

@@ -21,19 +21,19 @@ module Demos
   end
 
 =begin rdoc
-  This version of the Sieve of Eratosthenes iterates until the worklist is
+  This version of the Sieve of Eratosthenes iterates until the worksheet 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)
+	  worksheet = Array(2..n)
 		primes = []
 
-	  while worklist.length > 0
-	    primes << worklist.first
-	    worklist.delete_if { |x| x % primes.last == 0 }
+	  while worksheet.length > 0
+	    primes << worksheet.first
+	    worksheet.delete_if { |x| x % primes.last == 0 }
 	  end
 
 		return primes

data/lib/rubylabs.rb

@@ -576,6 +576,7 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
       if RUBY_VERSION =~ %r{^1\.8} && RUBY_PLATFORM =~ %r{darwin} && caller[1].index("(irb)") == 0
         sleep(0.1)
       end
+      # @@tkroot.update :idletasks
     end
     
 =begin rdoc
@@ -585,13 +586,17 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
 
     def Canvas.text(s, x, y, opts = {})
       return nil unless @@canvas
-      opts[:anchor] = :nw
+      opts[:anchor] = :nw unless opts.has_key?(:anchor)
       opts[:text] = s
       text = TkcText.new( @@canvas, x, y, opts)
       @@objects << text
       return text
     end
     
+    def Canvas.font(options)
+      return TkFont.new(options)
+    end
+    
 =begin rdoc
   Draw a line from (x0,y0) to (x1,y1)
 =end
@@ -735,6 +740,10 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
   assignment via an index or any other array operation.
   The +<<+ method checks to make sure an object is comparable (responds to <) before 
   adding it to the queue.
+  
+  If a program that uses a priority queue adds an instance variable named @on_canvas
+  the shift and << methods will call a method named update so drawings that show
+  a queue can be updated.
 =end
 
   class PriorityQueue
@@ -751,9 +760,17 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
         i += 1
       end
       @q.insert(i, obj)
+      update(:insert, obj) if @on_canvas
+      return @q
+    end
+    
+    def shift
+      res = @q.shift
+      update(:shift, res) if @on_canvas
+      return res
     end
 
-    %w{shift length first last to_s inspect clear empty?}.each do |name|
+    %w{length first last to_s inspect clear empty?}.each do |name|
       eval "def #{name}() @q.#{name} end"
     end
 
@@ -764,6 +781,14 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
     def collect(&f)
       @q.map { |x| f.call(x) }
     end
+    
+    def each(&b)
+      @q.each &b
+    end
+    
+    def each_with_index(&b)
+      @q.each_with_index &b
+    end
 
   end # PriorityQueue
 

data/lib/sievelab.rb

@@ -6,7 +6,7 @@
 Use the Sieve of Eratosthenes algorithm to generate a list of prime
 numbers.  The method is an introduction to iteration, using iterators
 to make and filter lists of numbers, and a while loop to repeat the
-filtering step until no more composite numbers are left in the worklist.
+filtering step until no more composite numbers are left in the worksheet.
 
 =end
 
@@ -21,15 +21,15 @@ module SieveLab
 # :begin :sieve
 	def sieve(n)
 	  return [] if n < 2
-	  worklist = Array(2..n)
+	  worksheet = Array(2..n)
 		primes = []
 	
-	  while worklist.first < sqrt(n)
-	    primes << worklist.first
-	    worklist.delete_if { |x| x % primes.last == 0 }
+	  while worksheet.first < sqrt(n)
+	    primes << worksheet.first
+	    worksheet.delete_if { |x| x % primes.last == 0 }
 	  end
 
-		return primes + worklist
+		return primes + worksheet
 	end
 # :end :sieve
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubylabs
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors: 
 - conery
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-17 00:00:00 -07:00
+date: 2010-08-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -114,7 +114,7 @@ rubyforge_project: rubylabs
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: Software and data for lab projects in the Science of Computing text.
+summary: Software and data for lab projects for Explorations in Computing.
 test_files: 
 - test/bit_test.rb
 - test/eliza_test.rb