rubylabs 0.6.2 → 0.6.4

data/lib/rubylabs.rb

@@ -10,9 +10,8 @@ Methods used to monitor execution of programs during experiments.
 
 SCRIPT_LINES__ = Hash.new unless defined? SCRIPT_LINES__
 
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'bin'))
+# $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'bin'))
 
-autoload :Temps,    		  "temps.rb"
 autoload :SieveLab, 		  "sievelab.rb"
 autoload :IterationLab,   "iterationlab.rb"
 autoload :RecursionLab,   "recursionlab.rb"
@@ -21,7 +20,7 @@ autoload :BitLab, 			  "bitlab.rb"
 autoload :MARSLab, 			  "marslab.rb"
 autoload :RandomLab, 		  "randomlab.rb"
 autoload :EncryptionLab, 	"encryptionlab.rb"
-autoload :ELIZALab, 		  "elizalab.rb"
+autoload :ElizaLab, 		  "elizalab.rb"
 autoload :SphereLab,      "spherelab.rb"
 autoload :TSPLab, 			  "tsplab.rb"
 
@@ -479,9 +478,46 @@ Similar to TestArray, but draws random words from a file.
   
   end # Source
   
-end # RubyLabs
+=begin rdoc
+  Priority queue class -- simple wrapper for an array that can only be updated via
+  +<<+ and +shift+ operations.  Also responds to +length+, +first+, and +last+, 
+  and allows direct access to an item through an index expression, but does not allow 
+  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.
+=end
 
-include RubyLabs
+  class PriorityQueue
+
+    def initialize
+      @q = Array.new
+    end
+
+    def <<(obj)
+      raise "Object cannot be inserted into priority queue" unless obj.respond_to?(:<)
+      i = 0
+      while (i < @q.length)
+        break if obj < @q[i]
+        i += 1
+      end
+      @q.insert(i, obj)
+    end
+
+    %w{shift length first last to_s inspect clear empty?}.each do |name|
+      eval "def #{name}() @q.#{name} end"
+    end
+
+    def [](i)
+      @q[i]
+    end
+    
+    def collect(&f)
+      @q.map { |x| f.call(x) }
+    end
+
+  end # PriorityQueue
+
+end # RubyLabs
 
 class Fixnum
   
@@ -506,3 +542,5 @@ characters (1-letter strings) +ord+ will return the ASCII value.
 	end
 
 end # Fixnum
+
+include RubyLabs

data/test/bit_test.rb

@@ -5,11 +5,13 @@ include BitLab
 
 class TestBits < Test::Unit::TestCase
 
+  def test_00_banner
+    print "\nBitLab"
+  end
+  
   # Make some Code objects
   
   def test_01_codes
-    print "\n  codes"
-    
     c0 = 10.code
     assert_equal c0.to_s, "1010"
     assert_equal c0.length, 4
@@ -37,9 +39,7 @@ class TestBits < Test::Unit::TestCase
   
   # Parity bit tests
   
-  def test_02_parity
-    print "\n  parity"
-    
+  def test_02_parity    
     a = ?A.code(8)
     assert_equal a.chr, "A"
     assert a.even_parity?
@@ -65,9 +65,7 @@ class TestBits < Test::Unit::TestCase
 
   # Make an encoding scheme for 5 items -- we should get 5 binary codes from 000 to 100
 
-  def test_03_make_codes
-    print "\n  make_codes"
-    
+  def test_03_make_codes  
     a = RandomArray.new(:cars, 5)
     assert_equal a.length, 5
     
@@ -82,9 +80,7 @@ class TestBits < Test::Unit::TestCase
   
   # Make some Message objects
   
-  def test_04_messages
-    print "\n  messages"
-    
+  def test_04_messages  
     s = "hello"
 
     msg1 = encode(s, :ascii)
@@ -110,8 +106,6 @@ class TestBits < Test::Unit::TestCase
   # Tree nodes 
   
   def test_05_nodes
-    print "\n  nodes"
-    
     n0 = Node.new("A", 0.2)
     assert_equal n0.char, "A"
     assert_equal n0.freq, 0.2
@@ -131,8 +125,6 @@ class TestBits < Test::Unit::TestCase
   # Priority queue
   
   def test_06_priority_queue
-    print "\n  priority queue"
-    
     n0 = Node.new("A", 0.2)
     n1 = Node.new("B", 0.4)
     n2 = Node.new("C", 0.3)
@@ -154,8 +146,6 @@ class TestBits < Test::Unit::TestCase
   # Huffman tree and encoding
   
   def test_07_huffman
-    print "\n  Huffman tree"
-    
     data = File.join(File.dirname(__FILE__), '..', 'data')
     freq = read_frequencies("#{data}/hafreq.txt")
     

data/test/eliza_test.rb

@@ -0,0 +1,159 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+=begin rdoc
+  Tests for the Eliza module (the RubyLabs version of Joseph Weizenbaum's ELIZA
+  program).
+  
+  The tests make and exercise Pattern and Rule objects used to transform English 
+  sentences.  Tests should try expressions that will be typed interactively by
+  students exploring ways of defining rules, and the calls made when rules are
+  read from a file.
+=end
+
+include ElizaLab
+
+class TestEliza < Test::Unit::TestCase
+  
+  def test_00_banner
+    print "\nElizaLab"
+  end
+  
+  # A Pattern object represents a sentence pattern, which associates a regular
+  # expression with a set of possible responses.
+
+	# Example from MARS tests, showing how to build a "source file" and assemble it:
+	
+  # def test_xx
+  #   source = [
+  #     "@label  mov #0, #1      ; label needs to be alphanumeric",
+  #     "l@bel   mov #0, #1      ; label needs to be alphanumeric",
+  #     "mov #0, #1              ; unlabeled line must start with space",
+  #     "label @bogus #0, #1     ; opcode with non-alphanumeric",
+  #     "label b@gus #0, #1      ; opcode with non-alphanumeric",
+  #     "label muv #0, #1        ; unknown opcode",
+  #     "   mov #b@gus, #1       ; messed up operand",
+  #     "   mov #0 #1            ; missing comma",
+  #     "  EQU 3                 ; missing label on pseudo-op",
+  #     "x EQU 3x                ; arg not an integer",
+  #     "  END foo               ; undefined label",
+  #   ]
+  #   
+  #   name, code, symbols, errors = MARS.assemble(source)
+  #   
+  #   assert_equal source.length, errors.length       # every line generates an error
+  #   assert_equal 0, code.length                     # should be no instructions generated
+  # end
+  
+  # The simplest pattern has a literal word, and cycles through sentences when applied
+  # to inputs that contain that word
+  
+  def test_01_literal
+    p = Pattern.new("father", ["yes", "no"])
+    assert p.match("father knows best")
+    assert_equal "yes", p.apply("father knows best")
+    assert_equal "no", p.apply("father knows best")
+    assert_equal "yes", p.apply("father knows best")
+    assert_nil p.apply("who's your daddy")
+  end
+  
+  # Literals in a pattern are bracketed by \b anchors
+  
+  def test_02_anchors
+    p = Pattern.new("father", ["yes"])
+    assert_nil p.apply("he is a grandfather")
+    assert_equal "yes", p.apply("my father-in-law")
+    assert_nil p.apply("land of my fathers")
+  end
+  
+  # Test the add_response method
+  
+  def test_03_add_response
+    p = Pattern.new("father")
+    p.add_response("one")
+    p.add_response("two")
+    assert_equal "one", p.apply("father knows best")
+    assert_equal "two", p.apply("my father-in-law")
+  end
+
+  # Test word groups
+  
+  def test_04_groups
+    p = Pattern.new("father|mother")
+    assert p.match("father knows best")
+    assert p.match("my mother the car")
+  end
+  
+  # Match parts used in responses
+  
+  def test_05_match_parts
+    p = Pattern.new("I (like|love|adore) my (dog|cat|ducks)")
+    p.add_response("You $1 your $2?")
+    assert_equal "You like your cat?", p.apply("I like my cat")
+    assert_equal "You love your ducks?", p.apply("I love my ducks")
+  end
+  
+  # Wild card pattern
+  
+  def test_06_wildcard
+    p = Pattern.new("I like (.*)")
+    p.add_response("Why do you like $1?")
+    assert_equal "Why do you like to drink beer?", p.apply("I like to drink beer")
+    assert_equal "Why do you like that car?", p.apply("I like that car")
+  end
+  
+  # Postprocessing
+  
+  def test_07_postprocess
+    p = Pattern.new("I am (.*)")
+    p.add_response("Are you really $1?")
+    assert_equal "Are you really afraid of your dog?", p.apply("I am afraid of your dog")
+    Eliza.post["I"] = "you"
+    Eliza.post["your"] = "my"
+    assert_equal "Are you really afraid of my dog?", p.apply("I am afraid of your dog")
+    assert_equal "Are you really sorry you dropped my computer?", p.apply("I am sorry I dropped your computer")
+  end
+  
+  # Preprocessing
+  
+  def test_08_preprocess
+    p = Pattern.new("I am (.*)")
+    p.add_response("Are you really $1?")
+    assert_nil p.apply("I'm sorry")
+    Eliza.pre["I'm"] = "I am"
+    assert_equal "Are you really sorry?", p.apply("I'm sorry")
+  end
+  
+  # Case insensitive matches
+  
+  def test_09_case
+    p = Pattern.new("I am (.*)")
+    p.add_response("Are you really $1?")
+    assert_equal "Are you really sorry?", p.apply("i am sorry")
+    Eliza.pre["I'm"] = "I am"
+    assert_equal "Are you really sorry?", p.apply("i'm sorry")
+  end
+  
+  # Load the 'doctor' script, try a few sentences -- this test is highly dependent on the rules
+  # in the script....
+  
+  # def test_10_doctor
+  #   assert Eliza.load(:doctor)
+  #   assert_equal "How do you do? Please state your problem.", Eliza.transform("hello")    
+  #   assert_equal "Do computers worry you?", Eliza.transform("I don't trust computers")
+  #   assert_equal "Why are you concerned over my hat?", Eliza.transform("I like your hat")
+  #   assert_equal "How do you know you can't do it?", Eliza.transform("I can't do it")
+  # end
+  
+  
+  # Examples of lines that should be flagged as errors:
+
+  # unknown keyword:
+  #:foo bar
+
+  # Missing arguments, first arg not a var name:
+  #:alias
+  #:alias foo bar baz
+
+end
+

data/test/encryption_test.rb

@@ -5,10 +5,13 @@ include EncryptionLab
 
 class TestEncryption < Test::Unit::TestCase
 
+  def test_00_banner
+    print "\nEncryptionLab"
+  end
+  
 	# Caesar cypher
 	
   def test_01_caesar
-    print "\n  Caesar cypher"
     assert_equal caesar("abcdefghijklmnopqrstuvwxyz"), "defghijklmnopqrstuvwxyzabc"
     assert_equal caesar("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), "DEFGHIJKLMNOPQRSTUVWXYZABC"
     assert_equal caesar("abcdefghijklmnopqrstuvwxyz", 13), "nopqrstuvwxyzabcdefghijklm"

data/test/iteration_test.rb

@@ -5,10 +5,13 @@ include IterationLab
 
 class TestIterativeAlgoritms < Test::Unit::TestCase
   
+  def test_00_banner
+    print "\nIterationLab"
+  end
+  
   # Test the contains? method (our version of include?)
   
   def test_01_contains
-    print "\n  contains?"
     a = ["fee", "fie", "foe", "fum"]
     assert contains?(a, "fee")
     assert contains?(a, "foe")
@@ -19,7 +22,6 @@ class TestIterativeAlgoritms < Test::Unit::TestCase
 	# Same as above, but using the location method (our version of index)
 	
   def test_02_search
-    print "\n  search"
     a = ["fee", "fie", "foe", "fum"]
     assert_equal 0, search(a, "fee")
     assert_equal 2, search(a, "foe")
@@ -30,7 +32,6 @@ class TestIterativeAlgoritms < Test::Unit::TestCase
 	# Make some test arrays, sort them	
 
 	def test_02_msort
-    print "\n  msort"
 	  [15, 16, 17].each do |size|
   		a = TestArray.new(size)
   		assert_equal isort(a), a.sort

data/test/mars_test.rb

@@ -33,6 +33,10 @@ include MARSLab
 
 class TestMARS < Test::Unit::TestCase
   
+  def test_00_banner
+    print "\nMARSLab"
+  end
+  
   # Assembling these instructions should lead to one error per line, and
   # no code generated.
 	

data/test/random_test.rb

@@ -5,6 +5,10 @@ include RandomLab
 
 class TestRandoms < Test::Unit::TestCase
   
+  def test_00_banner
+    print "\nRandomLab"
+  end
+  
   # The prng_sequence method makes a sequence of numbers using a linear congruential
   # method with the specified a, c, and m values
   

data/test/recursion_test.rb

@@ -5,12 +5,15 @@ include RecursionLab
 
 class TestRecursiveAlgoritms < Test::Unit::TestCase
 
+  def test_00_banner
+    print "\nRecursionLab"
+  end
+  
 	# Make some test arrays, try successful and unsuccessful searches.
 	# Test array sizes students will use (one less than power of two)
 	# plus some odd ones.
 	
   def test_01_bsearch
-    print "\n  bsearch"
     [14, 15, 16].each do |size|
       a = TestArray.new(size).sort
       assert_not_nil bsearch(a, a.random(:success))
@@ -23,7 +26,6 @@ class TestRecursiveAlgoritms < Test::Unit::TestCase
 	# the array is not modified
 
 	def test_02_msort
-    print "\n  msort"
 	  [15, 16, 17].each do |size|
       a = TestArray.new(size)
       b = a.dup
@@ -35,7 +37,6 @@ class TestRecursiveAlgoritms < Test::Unit::TestCase
 	# Array size not a factor here -- just try a few sorts	
 
 	def test_03_qsort
-    print "\n  qsort"
 	  [15, 16, 17].each do |size|
       a = TestArray.new(size)
       b = a.dup

data/test/rubylabs_test.rb

@@ -3,16 +3,15 @@ require 'test_helper'
 
 class RubyLabsTest < Test::Unit::TestCase
 	
-  def test_00_arrays
-    print "\n  test_array"
+  def test_00_banner
+    print "\nRubyLabs"
+  end
+  
+  def test_01_arrays
     a = TestArray.new(10)
 		assert a.length == 10
 		assert a.include?(a.random(:success))
 		assert !a.include?(a.random(:fail))
   end
 
-	def test_01_scope
-    print "\n  RubyScope [TBD]"
-	end
-
 end

data/test/sieve_test.rb

@@ -5,11 +5,14 @@ include SieveLab
 
 class TestSieve < Test::Unit::TestCase
 
+  def test_00_banner
+    print "\nSieveLab"
+  end
+  
 	# Compare list generated by sieve method with list from Wikipedia.  Test both the main
 	# version (sieve) and the simple prototype that iterates until the worklist is empty.
 	
   def test_01_first_25
-    print "\n  sieve"
     expected = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
 		assert_equal expected, sieve(100)
 		assert_equal expected, proto_sieve(100)
@@ -19,10 +22,10 @@ class TestSieve < Test::Unit::TestCase
 	# pi[i] is the number of primes less than 10**i.  Note: calling sieve(n) with n less than 2
 	# should quietly return an empty list.
 
-	def test_02_pi
-		pi = [0, 4, 25, 168, 1229, 9592]
-		for i in 0..(pi.length-1)
-			assert_equal pi[i], sieve(10**i).length
-		end
-	end
+  def test_02_pi
+    pi = [0, 4, 25, 168, 1229]          # 9592
+    for i in 0..(pi.length-1)
+      assert_equal pi[i], sieve(10**i).length
+    end
+  end
 end

data/test/sphere_test.rb

@@ -18,11 +18,13 @@ include SphereLab
 
 class TestSpheres < Test::Unit::TestCase
 
+  def test_00_banner
+    print "\nSphereLab"
+  end
+  
 	# Vector arithmetic.  Note: calls to assert_equal will also test the == method.
 	
   def test_01_vectors
-    print "\n  vectors"
-
     v1 = Vector.new(1, 1, 1)
     v2 = Vector.new(2, 2, 2)
     v3 = Vector.new(3, 3, 3)
@@ -44,7 +46,6 @@ class TestSpheres < Test::Unit::TestCase
   # each other on the y axis).
   
   def test_02_bodies
-    print "\n  bodies"
     y1 = 1000
     y2 = 0
     b1 = Body.new(1000000, Vector.new(0, y1, 0), Vector.new(0, 0, 0))
@@ -64,7 +65,6 @@ class TestSpheres < Test::Unit::TestCase
   # uses the same force twice)
   
   def test_03_interaction
-    print "\n  interaction"
     y1 = 1000
     y2 = 0
     b1 = Body.new(1000000, Vector.new(0, y1, 0), Vector.new(0, 0, 0))
@@ -85,7 +85,6 @@ class TestSpheres < Test::Unit::TestCase
   # close to where it started, and earth to be about 1/4 through its orbit.  
   
   def test_04_solar_system
-    print "\n  solar system"
     
     bodies = [
       Body.new(1.989E30, Vector.new(0,0.000E00,0), Vector.new(0.000E0,0,0),	"sun"),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubylabs
 version: !ruby/object:Gem::Version 
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors: 
 - conery
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-01-11 00:00:00 -08:00
+date: 2010-02-08 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -44,10 +44,24 @@ files:
 - data/century.txt
 - data/colors.txt
 - data/earth.yaml
+- data/eliza/doctor.txt
 - data/fruit.txt
 - data/hacodes.txt
 - data/hafreq.txt
 - data/hvfreq.txt
+- data/mars/chang1.txt
+- data/mars/dwarf.txt
+- data/mars/ferret.txt
+- data/mars/imp.txt
+- data/mars/mice.txt
+- data/mars/midget.txt
+- data/mars/piper.txt
+- data/mars/plague.txt
+- data/mars/test_celsius.txt
+- data/mars/test_div.txt
+- data/mars/test_hello.txt
+- data/mars/test_mult.txt
+- data/mars/test_threads.txt
 - data/nbody.R
 - data/nbody.out
 - data/nbody.pdf
@@ -103,6 +117,7 @@ specification_version: 3
 summary: Software and data for lab projects in the Science of Computing text.
 test_files: 
 - test/bit_test.rb
+- test/eliza_test.rb
 - test/encryption_test.rb
 - test/iteration_test.rb
 - test/mars_test.rb