rubylabs 0.7.5 → 0.8.0

data/test/bit_test.rb

@@ -66,7 +66,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  
-    a = RandomArray.new(:cars, 5)
+    a = TestArray.new(5, :cars)
     assert_equal a.length, 5
     
     c = make_codes(a)
@@ -122,7 +122,7 @@ class TestBits < Test::Unit::TestCase
     assert ! n2.leaf?
   end
   
-  # Priority queue
+  # Priority queue -- uses the class defined in RubyLabs, but adds some "hooks"
   
   def test_06_priority_queue
     n0 = Node.new("A", 0.2)
@@ -132,6 +132,8 @@ class TestBits < Test::Unit::TestCase
     pq = PriorityQueue.new
     [n0,n1,n2].each { |x| pq << x }
     
+    assert_nil pq.on_canvas
+    
     assert_equal pq.length, 3
     assert_equal pq.first, n0
     assert_equal pq.last, n1
@@ -146,9 +148,7 @@ class TestBits < Test::Unit::TestCase
   # Huffman tree and encoding
   
   def test_07_huffman
-    data = File.join(File.dirname(__FILE__), '..', 'data')
-    freq = read_frequencies("#{data}/hafreq.txt")
-    
+    freq = read_frequencies(:hafreq)
     tree = build_tree(freq)
     assert_equal tree.freq, 1.0
     
@@ -157,7 +157,6 @@ class TestBits < Test::Unit::TestCase
     assert_equal codes["W"].to_s, "110010"
     
     msg = encode("ALOHA", tree)
-    
     assert_equal msg.to_s, "100000010000110"
     assert_equal decode(msg, tree), "ALOHA"    
   end

data/test/eliza_test.rb

@@ -11,6 +11,34 @@ require 'test_helper'
   read from a file.
 =end
 
+=begin
+  TODO refactor Eliza.load, into two methods, one to read the file, the other to "compile" the lines
+  TODO test compiling by making a script in this file and passing it to the compile method
+=end
+
+# 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
+
 include ElizaLab
 
 class TestEliza < Test::Unit::TestCase
@@ -18,33 +46,10 @@ 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
   

data/test/hash_test.rb

@@ -0,0 +1,96 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+require 'stringio'
+
+include HashLab
+
+class TestHash < Test::Unit::TestCase
+
+  def test_00_banner
+    print "\nHashLab"
+  end
+  
+  # Test the simple hash functions
+  
+  def test_01_simple_hash_functions
+    assert_equal 0, h("apple")
+    assert_equal 5, h("zebra")
+
+    assert_equal 0, h0("aardvark", 10)
+    assert_equal 0, h0("aardvark", 1000)
+    assert_equal 5, h0("zymurgy", 10)
+    assert_equal 25, h0("zymurgy", 1000)
+
+    assert_equal 0, h1("aardvark", 10)
+    assert_equal 0, h1("aardvark", 1000)
+    assert_equal 4, h1("zymurgy", 10)
+    assert_equal 674, h1("zymurgy", 1000)
+  end
+  
+  # Test radix-26 and hash function that uses it
+  
+  def test_02_radix26
+    assert_equal 783, radix26("bed")
+    assert_equal 784, radix26("bee")
+    assert_equal 8013894328, radix26("zymurgy")
+    
+    assert_equal 8, hr("zymurgy", 10)
+    assert_equal 28, hr("zymurgy", 100)
+    assert_equal 328, hr("zymurgy", 1000)
+    assert_equal 4328, hr("zymurgy", 10000)    
+  end
+  
+  # Test the stand-alone insert and lookup methods (w/o bucket)
+  
+  def test_03_insert_and_lookup
+    t = Array.new(10)
+    assert_equal 3, insert("duck", t)
+    assert_equal 7, insert("husky", t)
+    assert_equal 1, insert("bruin", t)
+    assert_nil insert("beaver", t)
+    
+    assert_equal 3, lookup("duck", t)
+    assert_equal 1, lookup("bruin", t)
+    assert_nil lookup("trojan", t)
+  end
+  
+  # Make a HashTable object, repeat insert and lookup tests, then 
+  # capture the output from print_stats to verify the table structure
+  
+  def test_04_hash_table
+    t = HashTable.new(10, :h0)
+    assert_equal 3, t.insert("duck")
+    assert_equal 1, t.insert("beaver")
+    assert_equal 7, t.insert("husky")
+    assert_equal 2, t.insert("cougar")
+    assert_equal 2, t.insert("cardinal")
+    assert_equal 1, t.insert("bear")
+    assert_equal 1, t.insert("bruin")
+    assert_equal 9, t.insert("trojan")
+    assert_equal 8, t.insert("sun devil")
+    assert_equal 2, t.insert("wildcat")
+    
+    assert_equal 3, t.lookup("duck")
+    assert_equal 1, t.lookup("bear")
+    assert_nil t.lookup("eagle")
+    assert_nil t.lookup("buffalo")
+    
+    oldout = $stdout
+    newout = StringIO.new
+    $stdout = newout
+    t.print_stats
+    $stdout = oldout
+    lines = newout.string.split("\n")
+    
+    assert_equal 0, get_value("shortest", lines)
+    assert_equal 3, get_value("longest", lines)
+    assert_equal 4, get_value("empty", lines)
+    assert_equal 1.67, get_value("mean", lines)
+  end
+  
+  def get_value(s, a)
+    line = a.grep(Regexp.new(s))[0]
+    return line[/\d+\.?\d*/].to_f
+  end
+  
+end

data/test/iteration_test.rb

@@ -1,5 +1,6 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'test_helper'
+require 'stringio'
 
 include IterationLab
 
@@ -31,11 +32,29 @@ class TestIterativeAlgoritms < Test::Unit::TestCase
 
 	# Make some test arrays, sort them	
 
-	def test_02_msort
+	def test_03_isort
 	  [15, 16, 17].each do |size|
   		a = TestArray.new(size)
   		assert_equal isort(a), a.sort
     end
 	end
 	
+	# Capture the output of a trace when sorting a list of 5 numbers.  Expect
+	# four lines, with left bracket moving one number to the right each time.
+	
+	def test_04_trace
+    assert Source.clear
+    oldout = $stdout
+    newout = StringIO.new
+    $stdout = newout
+    Source.probe :isort, 5, "puts brackets(a,i)"
+    trace { isort(TestArray.new(5)) }
+    $stdout = oldout
+    lines = newout.string.split("\n")
+	  assert_equal 4, lines.length
+	  assert_match /\d+\s+\[.*\]/, lines[0]
+	  assert_match /\d+\s+\d+\s+\[.*\]/, lines[1]
+	  assert_match /\[\d+\]/, lines[-1]
+	end
+	
 end

data/test/random_test.rb

@@ -70,7 +70,7 @@ class TestRandoms < Test::Unit::TestCase
   def test_04_deck
     d = new_deck
     check_all_cards(d)
-    permute(d)
+    permute!(d)
     check_all_cards(d)
     d.sort!
     assert_equal new_deck, d

data/test/rubylabs_test.rb

@@ -1,5 +1,8 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'test_helper'
+require 'stringio'
+
+include IterationLab
 
 class RubyLabsTest < Test::Unit::TestCase
 	
@@ -7,11 +10,101 @@ class RubyLabsTest < Test::Unit::TestCase
     print "\nRubyLabs"
   end
   
+  # A test array is an array of randomly selected integers. A method named random
+  # should return a number that is guaranteed to be in the array, when passed the
+  # :success option, or a number that is not in the array, when passed :fail
+  
   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
+  
+  # Simple test to make sure log2 is defined...
+  
+  def test_02_log2
+    assert_equal 3.0, log2(8)
+  end
+  
+  # Test min and max methods
+  
+  def test_03_minmax
+    assert_equal 10, min(10,20)
+    assert_equal 10, min(20,10)
+    assert_equal 20, max(10,20)
+    assert_equal 20, max(20,10)
+  end
+  
+  # This test just makes sure the time method runs -- no way to really test to
+  # see if the result is accurate
+  
+  def test_04_time
+    assert_not_nil time { min(10,20) }
+  end
+  
+  # Capture the listing of the 'less' method (from IterationLab); it should have
+  # three lines of Ruby code, with a 'def', 'return', and 'end'
+  
+  def test_05_listing
+    oldout = $stdout
+    newout = StringIO.new
+    $stdout = newout
+    Source.listing :less
+    $stdout = oldout
+    lines = newout.string.split("\n")
+    assert_equal 3, lines.length
+    assert_match /1:\s+def less/, lines[0]
+    assert_match /2:\s+return/, lines[1]
+    assert_match /3:\s+end/, lines[2]
+  end
+  
+  # This test sets a "counting probe" on the method named 'less' in the IterationLab
+  # module, and then counts how many times 'less' is called.  
 
+  def test_06_count
+    assert Source.clear
+    assert Source.probe :less, 2, :count
+    n = count { less(10,20) }
+    assert_equal 1, n
+  end
+  
+  # Same as above, except the probe prints a message to stdout.  Capture the message
+  # to make sure the probe mechanism works.
+  
+  def test_07_trace
+    oldout = $stdout
+    newout = StringIO.new
+    assert Source.probe :less, 2, "puts 'got it'"
+    $stdout = newout
+    res = trace { less(10,20) }
+    $stdout = oldout
+    assert res
+    assert_equal "got it", newout.string.chomp
+  end
+  
+  # Priority Queue test
+  
+  def test_08_priority_queue
+    pq = PriorityQueue.new
+    [5, 15, 10, 20, 0].each { |x| pq << x }
+    assert_equal 5, pq.length
+    assert_equal 0, pq[0]
+    assert_equal 20, pq[-1]
+    assert_equal 0, pq.shift
+    assert_equal 4, pq.length
+    assert_raise(NoMethodError) { pq[0] = 100 }
+  end
+  
+  # 'ord' method -- maps upper and lower case letters to 0..25, others return
+  # self (i.e. ASCII code)
+  
+  def test_09_ord
+    assert_equal 0, ?A.ord
+    assert_equal 25, ?Z.ord
+    assert_equal 0, ?a.ord
+    assert_equal 25, ?z.ord
+    assert_equal ?:.ord, ?:
+  end
+  
 end

data/test/sieve_test.rb

@@ -15,7 +15,6 @@ class TestSieve < Test::Unit::TestCase
   def test_01_first_25
     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)
   end
 
 	# Check length of list generated by sieve with expected number of primes (also from Wikipedia).

data/test/tsp_test.rb

@@ -0,0 +1,140 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include TSPLab
+
+class TestTSP < Test::Unit::TestCase
+
+  # load a test map used by the tests
+  
+  @@map = Map.new(:test7)
+
+  def test_00_banner
+    print "\nTSPLab"
+  end
+  
+  # test the factorial method
+  
+  def test_01_fact
+    assert_equal 120, factorial(5)
+    assert_equal 1, factorial(1)
+    assert_equal 1, factorial(0)
+  end  
+  
+  # ntours(n) should compute (n-1)! / 2
+  
+  def test_02_ntours
+    assert_equal 362880, factorial(9)
+    assert_equal 181440, ntours(10)   
+  end
+  
+  # generate all permutations of a 3-letter string in lexicographic order
+  
+  def test_03_each_permutation
+    a = "ABC".each_permutation
+    assert_equal ["ABC", "ACB", "BAC", "BCA", "CAB", "CBA"], a
+  end
+  
+  # check properties of the test map
+  
+  def test_04_make_map
+    assert_equal 7, @@map.size
+    assert_equal [:A, :B, :C, :D, :E, :F, :G], @@map.labels
+    assert_equal [192, 212], @@map.coords(:A)
+    assert_equal [433, 133], @@map.coords(:G)
+  end
+  
+  # check stored distances
+  
+  def test_05_distances
+    assert_equal 151.54, @@map[ :A, :B ]
+    assert_equal 151.54, @@map[ :B, :A ]
+    assert_equal 144.51, @@map[ :F, :G ]
+    assert_nil @@map[:x, :y]
+  end
+  
+  # make a short 3-city tour with the first 3 cities
+  
+  def test_06_make_tour
+    t = @@map.make_tour [:A, :B, :C]
+    assert_equal [:A, :B, :C], t.path
+    assert_equal (@@map[:A,:B] + @@map[:B,:C] + @@map[:C,:A]), t.cost
+    assert_equal 1, Tour.count
+  end
+    
+  # exhaustive search for best tour -- record the best tour, and check to
+  # to make sure each tour generated (by checking the count of the number made)
+  
+  def test_07_exhaustive
+    @@best = @@map.make_tour(:random)
+    Tour.reset
+    @@map.each_tour { |t| @@best = t if t.cost < @@best.cost }
+    assert_in_delta 1185.43, @@best.cost, 0.001
+    assert_equal ntours(@@map.size), Tour.count
+  end
+  
+  # point mutation test -- middle of the tour
+  
+  def test_08_mutate_middle
+    t = @@map.make_tour([ :A, :B, :C, :D, :E, :F, :G ])
+    tc = t.cost
+    t.mutate!(2)
+    assert_equal [:A, :B, :D, :C, :E, :F, :G], t.path
+    assert_equal t.cost, tc - @@map[:B,:C] - @@map[:D,:E] + @@map[:B,:D] + @@map[:C,:E]
+    t.mutate!(2)
+    assert_equal [:A, :B, :C, :D, :E, :F, :G], t.path
+    assert_equal tc, t.cost
+  end
+  
+  # point mutation test -- wraparound
+  
+  def test_09_mutate_wrap
+    t = @@map.make_tour([ :A, :B, :C, :D, :E, :F, :G ])
+    tc = t.cost
+    t.mutate!(6)
+    assert_equal [:G, :B, :C, :D, :E, :F, :A], t.path
+    assert_equal t.cost, tc - @@map[:F,:G] - @@map[:A,:B] + @@map[:F,:A] + @@map[:G,:B]
+    t.mutate!(6)
+    assert_equal [:A, :B, :C, :D, :E, :F, :G], t.path
+    assert_equal tc, t.cost
+  end
+  
+  # crossover test -- copy cities 2..4 from first tour, then get rest from other tour.
+  
+  def test_10_cross
+    t0 = @@map.make_tour([ :A, :B, :C, :D, :E, :F, :G ])
+    t1 = @@map.make_tour([ :G, :F, :E, :D, :C, :B, :A ])
+    t0.cross!(t1, 2, 3)
+    assert_equal [:C, :D, :E, :G, :F, :B, :A], t0.path
+    t0.cross!(t1, 0, 1)
+    assert_equal [:C, :G, :F, :E, :D, :B, :A], t0.path
+    t0.cross!(t1, 6, 1)
+    assert_equal [:A, :G, :F, :E, :D, :C, :B], t0.path
+  end
+  
+  # random search -- check to make sure 100 tours are created when rsearch is told
+  # to look at 100 random samples
+  
+  def test_11_rsearch
+    Tour.reset
+    rsearch(@@map, 100)
+    assert_equal 100, Tour.count
+  end
+  
+  # evolutionary search -- instead of trying to test components (init_population, 
+  # select_survivors, rebuild population) this test just checks to see if esearch
+  # finds the best tour.  Since there are only 7 cites (360 tours) running for 
+  # 25 generations with a population size of 50 should be more than enough to find
+  # the optimal tour (saved by the exhaustive search in a previous test).  The search
+  # should make around 625 tours; checking for a count between 525 and 725 should be safe.
+  
+  def test_12_esearch
+    popsize = 50
+    ngen = 25
+    Tour.reset
+    t = esearch(@@map, ngen, :popsize => popsize, :distribution => :mixed)
+    assert_in_delta @@best.cost, t.cost, 100*Float::EPSILON
+    assert_in_delta (popsize*ngen/2), Tour.count, 100
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubylabs
 version: !ruby/object:Gem::Version 
-  version: 0.7.5
+  version: 0.8.0
 platform: ruby
 authors: 
 - conery
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-12 00:00:00 -08:00
+date: 2010-05-17 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -45,9 +45,10 @@ files:
 - data/arrays/wordlist.txt
 - data/eliza/doctor.txt
 - data/huffman/aafreq.txt
-- data/huffman/hacodes.txt
 - data/huffman/hafreq.txt
 - data/huffman/hvfreq.txt
+- data/huffman/testcodes.txt
+- data/huffman/testwords.txt
 - data/mars/chang1.txt
 - data/mars/dwarf.txt
 - data/mars/ferret.txt
@@ -61,18 +62,25 @@ files:
 - data/mars/test_hello.txt
 - data/mars/test_mult.txt
 - data/mars/test_threads.txt
+- data/spheres/fdemo.txt
+- data/spheres/fdemo2.txt
 - data/spheres/fourbody.txt
+- data/spheres/melon.txt
 - data/spheres/solarsystem.txt
-- data/spheres/urey.txt
+- data/tsp/ireland.txt
 - data/tsp/pac10.txt
 - data/tsp/test.txt
+- data/tsp/test10.txt
+- data/tsp/test7.txt
 - lib/bitlab.rb
+- lib/demos.rb
 - lib/elizalab.rb
 - lib/encryptionlab.rb
 - lib/hashlab.rb
 - lib/introlab.rb
 - lib/iterationlab.rb
 - lib/marslab.rb
+- lib/permute.rb
 - lib/randomlab.rb
 - lib/recursionlab.rb
 - lib/rubylabs.rb
@@ -111,6 +119,7 @@ test_files:
 - test/bit_test.rb
 - test/eliza_test.rb
 - test/encryption_test.rb
+- test/hash_test.rb
 - test/iteration_test.rb
 - test/mars_test.rb
 - test/random_test.rb
@@ -119,3 +128,4 @@ test_files:
 - test/sieve_test.rb
 - test/sphere_test.rb
 - test/test_helper.rb
+- test/tsp_test.rb

data/data/huffman/hacodes.txt

@@ -1,35 +0,0 @@
-# The binary numbers are Hawaiian words, encoded with a Huffman code based on the
-# letter frequencies in hafreq.txt.  The word next to a code is the English translation
-# of the Hawaiian word -- after decoding a string of bits look for the word in a 
-# Hawaiian-English dictionary to see if the decoding is correct.
-
-011010	rain
-001010	sugarcane
-0011111	carving
-110011010	night
-0011000110	duck
-1100001010	chicken
-1001110110	swordfish
-111001101111	large
-001010111010	leeward
-110000100010110	island
-1100001010111010	ocean
-0001110101111101	octopus
-0000101110101111	porch
-1110110111101101	goose
-0010110110000110	teacher
-100000111101111111	royalty
-00110000110001101111	beach
-11000100001100000010	thankyou
-11000100011011101111	wind
-0001010100000010000110	friend
-0011000110000111111000110	morning
-0001100110011101000001111	happy
-110001000110000111110011111	year
-00010100111010001111111001110	hospitality
-1100010000011110001111111101111	visitor
-11000100010110100001111111101101 mother
-00011000001000110000111110011111	pineapple
-110001101111011010001011011101101	imp
-0011011110011011000100001111111101101	daughter
-000101101100001100001011011000011011100110001011011100110001011010110011011010011110	triggerfish