rubylabs 0.5.4

data/lib/tsplab.rb

@@ -0,0 +1,416 @@
+=begin rdoc
+
+== Traveling Salesman Lab
+
+=end
+
+=begin
+  TODO test predigree counts
+  TODO add "phylogeny" links -- keep refs to parent(s)
+  TODO test: selection only, no mutations
+  TODO test: random draws only, no selection
+  TODO plot space: get all 180K costs, order lexicographically, plot (smoothed)
+=end
+
+require 'set'
+
+=begin rdoc
+
+Objects of the CityList class store city names and distances between pairs of
+cities.  The instance variables are a hash associating a key with a
+city name and a matrix of distances.  The matrix is a hash of
+hashes, indexed by city, where distances are driving times in
+minutes.
+
+=end
+
+# Public methods:
+#   new(f) initializes an object using names and distances in file f
+#   size() returns number of cities
+#   keys() returns an array of keys
+#   values() returns an array of city names
+#   [x] returns the name of the city with key x
+#   distance(x,y) returns the distance between cities with keys x and y
+
+
+class CityList
+  
+=begin rdoc
+The lines in the input file passed to the constructor come from a
+program that uses Google Maps to look up dirving times, so there are
+3 distance fields: days, hours, minutes.  The input record format is
+city 1, city 2, days, hours, minutes, all separated by tabs.  Each
+city is assigned a one-letter key.  
+=end
+
+  def initialize(fn)
+    raise "CityList.new: must specify city file" unless fn != nil
+
+    @key = ?A
+    @cities = Hash.new          # initially a map from name string to one-letter key
+    @matrix = Hash.new
+
+    File.open(fn).each do |line|
+      next if line.chomp.length == 0
+      rec = line.split(/\t/)
+      i = getKey(rec[0])
+      j = getKey(rec[1])
+      dist = ((24 * getValue(rec[2]) + getValue(rec[3])) * 60) + getValue(rec[4])
+      assign(i,j,dist)
+      assign(j,i,dist)
+    end
+
+    @cities = @cities.invert    # from now on a map from key to name string
+
+    errs = 0
+    (?A..@key-1).each do |i|
+      (i+1..@key-1).each do |j|
+        unless @matrix[i][j] && @matrix[j][i]
+          errs += 1
+          puts "CityList.new: missing distance between #{@cities[i]} and #{@cities[j]}"
+        end
+      end
+    end
+    raise "CityList.new: errors in input file" if errs > 0
+
+  end
+
+  def inspect()
+    n = @matrix.length
+    return "List of #{n} cities"
+  end
+  
+  def size()
+    return @key - ?A
+  end
+
+  def keys()
+    return @cities.keys.sort.map{|x| x.chr}
+  end
+
+  def values()
+    return @cities.keys.sort.collect{|x| @cities[x]}
+  end
+
+  def [](x)
+    x = x[0] if x.class == String
+    raise "unknown key: #{x}" unless x >= ?A && x < @key
+    return @cities[x]
+  end
+
+  def distance(x,y)
+    x = x[0] if x.class == String
+    y = y[0] if y.class == String
+    raise "unknowns key: #{x}" unless x >= ?A && x < @key
+    raise "unknown key: #{y}" unless y >= ?A && y < @key
+    return @matrix[x][y]
+  end
+
+  # private methods -- return the key for a city (make a new one if necessary),
+  # get a time value from an input line, save a distance
+
+  private
+
+  def getKey(s)
+    if @cities[s] == nil
+      @cities[s] = @key
+      @key += 1
+    end
+    return @cities[s]
+  end
+
+  def getValue(s)
+    a = s.scan(/(\d+)/)
+    if a.length == 1
+      return a[0][0].to_i
+    else
+      return 0
+    end
+  end
+
+  def assign(i,j,v)
+    if @matrix[i] == nil
+      @matrix[i] = Hash.new
+    end
+    @matrix[i][j] = v
+  end
+
+end
+
+class String
+  
+=begin rdoc
+  Call <tt>s.permute</tt> to scramble the characters in string +s+.
+=end
+
+  def permute
+    for i in 0..length-2
+      r = rand(length-i) + i  		# i <= r < length
+      self[i],self[r] = self[r],self[i]
+    end
+    self
+  end
+  
+  
+=begin rdoc
+  Call <tt>s.rotate</tt> to "rotate" the characters in string +s+, i.e. detach
+  the last character in +s+ and reinsert it at the front.
+=end
+
+  def rotate(n)
+    if n > 0
+      tail = self[n..-1]
+      self[n..-1] = ""
+      self.insert(0,tail)
+    end
+    self
+  end
+
+end
+
+=begin rdoc
+
+Each Tour object is a string where each letter represents a city, along with a cost
+defined by a CityList matrix that must be specified when the tour is created.  If
+an initial string is given verify it contains only valid keys.  If no initial
+string is given make a tour with a random permutation of all city keys.
+
+The +nm+ and +nx+ attributes keep track of a tour's "pedigree."  The counters are 
+inherited from a parent, and incremented whenever a mutation or crossover is applied.
+
+=end
+
+
+class Tour 
+  attr_reader :id, :path, :cost, :matrix, :nm, :nx
+
+  @@id = 0
+
+  def initialize(m, s = nil, nm = 0, nx = 0)
+    if s == nil
+      @path = m.keys.to_s.permute
+    else
+      skeys = Set.new(m.keys)
+      used = Set.new
+      s.each_byte do |x|
+        raise "Tour.new: invalid character in tour: #{x}" unless skeys.member?(x.chr)
+        raise "Tour.new: duplicate character in tour: #{x.chr}" if used.member?(x)
+        used.add(x)
+      end
+      @path = s.clone
+    end
+    @cost = pathcost(m,@path)
+    @matrix = m                 # need matrix to update cost after mutation...
+    @id = @@id
+    @nm = nm
+    @nx = nx
+    @@id += 1
+  end
+
+	# An alterntaive constructor -- either copy a single parent and add
+	# a point mutation, or cross two parents
+	
+	def Tour.reproduce(x, y = nil, trace = nil)
+		if y.nil? || y == :trace
+      i = rand(x.path.length)
+      j = (i+1) % x.path.length
+  	  trace = :trace if y == :trace       # handle calls like reproduce(x, :trace)
+			x.clone.mutate(i, j, trace)
+		else
+      i = rand(x.path.length)
+      loop { j = rand(x.path.length); break if j != i }
+      i, j = j, i if i > j
+			x.clone.cross(y, i, j, trace)
+		end
+	end
+
+  def to_s()
+    return "\##{@id}: #{@path} / #{@cost}"
+  end
+
+  def inspect
+    return to_s
+  end
+
+  # Reset the id to 0 (e.g. to count number of objects)
+
+  def Tour.reset
+    @@id = 0
+  end
+
+  def Tour.count
+    @@id
+  end
+
+  # A copy of a tour needs its own new id and copy of the path and pedigree
+
+  def clone
+    return Tour.new(@matrix, @path, @nm, @nx)
+  end
+ 
+  # Exchange mutation (called EM by Larranaga et al).  Simply swaps two
+  # cities at the specified locations.
+  
+  def mutate(i, j, trace = nil)
+    puts "mutate: #{i} <-> #{j}" if ! trace.nil?
+    @path[i], @path[j] = @path[j], @path[i]
+    @cost = pathcost(@matrix,@path)
+    @nm += 1
+    self
+  end
+  
+  # Order cross-over (called OX1 by Larranaga et al).  Save a chunk of the 
+  # current tour, then copy the remaining cities in the order they occur in 
+  # tour t.
+  
+  def cross(t, i, j, trace = nil)
+    puts "cross: copy #{i}..#{j}" if ! trace.nil?
+    @path = @path[i..j]
+    t.path.each_byte do |c|
+      @path << c unless @path.include?(c)
+    end
+    @cost = pathcost(@matrix,@path)
+    @nx += 1 + t.nx
+    @nm += t.nm
+    self
+  end
+
+  # private methods -- compute the cost of a path, given a matrix; apply
+  # mutations (point mutations, cross-overs)
+
+  private
+
+  def pathcost(m,s)
+    sum = m.distance(s[0],s[-1]) 	# link from end to start
+    for i in 0..s.length-2
+      sum += m.distance(s[i],s[i+1])
+    end
+    return sum
+  end
+
+end
+
+# Make a population of size n -- n instances of tours made from a set
+# of cities 
+
+def initPopulation(n,m)
+  a = Array.new
+
+  n.times do
+    a.push(Tour.new(m))
+  end
+  
+  a.sort! { |x,y| x.cost <=> y.cost }
+
+  return a
+end
+
+# Evolve a population.  Sort by fitness, then remove individuals with
+# a probability based on their ranking (the ith individual survives
+# with p = (n-i)/n).  Then Build back up to the original population
+# size via copies with mutations or crossovers.  An optional second
+# argument is a collection of parameters that can override various
+# options (e.g. the probability of survival).
+
+def evolve(p, param={})
+  debug = param[:trace] ? true : false
+  pcross = param[:pcross] ? param[:pcross] : 0.25
+	plotci = param[:plotci]
+
+  p.sort! { |x,y| x.cost <=> y.cost }
+  i = 0
+  n = p.length
+
+	if plotci
+		m = 0.0
+		p.each { |t| m += t.cost }
+		m = m / p.length
+		printf "%.2f %.2f %.2f\n", m, p[0].cost, p[-1].cost
+	end
+
+  # phase 1 -- delete random tours
+
+  while i < p.length
+    pk = (n-i).to_f / n
+    if rand < pk
+      puts "keep #{p[i]}" if debug
+      i += 1                    # keep this tour, skip to next one
+    else
+      puts "zap #{p[i]}" if debug
+      p.delete_at(i)            # zap this one; keep i at same value
+    end
+  end
+
+  # phase 2 -- build back up to n tours; prev is the index of the last
+  # tour from the previous generation (candidates for cloning/crossing)
+
+  best = p[0]
+  prev = p.length
+
+  while p.length < n
+    mom = p[rand(prev)]
+    if rand < pcross
+      dad = p[rand(prev)]
+	    kid = Tour.reproduce(mom,dad)
+      puts "#{mom} x #{dad} => #{kid}" if debug
+    else
+	    kid = Tour.reproduce(mom)
+      puts "#{mom} => #{kid}" if debug
+    end
+    p.push(kid)
+    best = kid if kid.cost < best.cost
+  end
+
+  return best
+
+end
+
+# High level interface -- make a population for a set of cities, then
+# call evolve() until the best tour doesn't change after some number of
+# iterations (also passed as a parameter).  Print the tour when done.
+
+def bestTour(matrix, param={})
+  popsize = param[:popsize] ? param[:popsize] : 10
+  maxgen = param[:maxgen] ? param[:maxgen] : 25
+  maxstatic = param[:maxstatic] ? param[:maxstatic] : maxgen/2
+  
+  p = initPopulation(popsize,matrix)
+  best = p[0]
+  nstatic = 0
+  ngen = 0
+  
+  if param[:verbose]
+    puts "popsize: #{popsize}"
+    puts "maxgen: #{maxgen}"
+    puts "maxstatic: #{maxstatic}"
+    puts "pcross: #{param[:pcross]}"
+  end
+
+  while ngen < maxgen && nstatic < maxstatic
+    puts "best tour: #{p[0]}" if param[:verbose]
+    evolve(p, param)
+    if p[0].cost < best.cost
+      best = p[0]
+      nstatic = 0
+    else
+      nstatic += 1
+    end
+    ngen += 1
+  end
+
+  # puts "#{ngen} generations (#{nstatic} at best value)"
+  puts "#{ngen} generations"
+  
+  if param[:verbose]
+    puts "best cost: #{best.cost}"
+    puts "pedigree:  #{best.nx} cross #{best.nm} mutate"
+    puts "best tour:"
+    best.path.each_byte do |x|
+      puts "  " + matrix[x]
+    end
+  end
+
+  return best
+end
+
+

data/lib/viewer.rb

@@ -0,0 +1,65 @@
+
+=begin rdoc
+  
+== Viewer
+
+A module for displaying graphical views of objects created in lab projects.  A view
+is a simple drawing canvas with no controls -- objects are drawn when students evaluate
+expressions in an IRB session.
+
+The communication between IRB and the canvas is mediated by a Linda tuple-space.  When 
+this module is included in an IRB session it launches a Ruby program named 'bb.rb', which
+implements a Rinda tuplespace, and then launches a viewer program that will extract
+tuples that describe objects and draw representations of those objects.  There are 
+different viewers for each lab, e.g. nbview.rb is the N-body project viewer that draws 
+circles to show the positions of planets.  
+
+This organization is pretty cumbersome, but it appears to be the best/only way to control
+a graphical interface from an IRB session.  Ideally IRB could create a canvas from a GUI
+library like Tk or Wx, but the problem is that these libraries only update their widgets
+from a top-level event loop.  In Ruby 1.8, without native threads, the event loop doesn't
+give control back to IRB.  Launching a Wx-based viewer as a separate application and 
+communicating with it via Linda is working, but is not very responsive.  For one-way
+communication it seems to be adequate.
+
+The code assumes the module is loaded by a require statement in a lab method that is called
+to initialize a view for that lab.  Since the code is loaded by a require the module is
+loaded only once.  Statements in the main body of the module set up the bulletin board
+and do other one-time intializations.
+
+=end
+
+require 'drb/drb'
+require 'rinda/tuplespace'
+
+module RubyLabs
+	
+module Viewer
+
+# Code to execute when the module is loaded (assumed to happen only once):
+
+raise "for interactive use only" unless defined? IRB
+
+DRb.start_service       # ? was after launch of bb.rb
+
+@@uri = "druby://localhost:53783"
+@@bindir = File.join(File.dirname(__FILE__), '..', 'bin')
+@@bb = IO.popen("#{@@bindir}/bb.rb")
+@@ts = Rinda::TupleSpaceProxy.new(DRbObject.new(nil, @@uri))  
+
+at_exit do
+  Process.kill(9, @@bb.pid)
+  Process.kill(9, @@viewer.pid)
+end
+
+def write_tuple(tag, args)
+  puts "RubyLabs::Viewer::write_tuple #{tag} #{args} #{@@uri}"
+end
+
+def launch_viewer(name)
+  @@viewer = IO.popen("#{@@bindir}/#{name} #{@@uri}")
+end
+
+end # Viewer
+
+end # RubyLabs

data/test/bit_test.rb

@@ -0,0 +1,175 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include BitLab
+
+class TestBits < Test::Unit::TestCase
+
+  # 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
+    assert_equal c0.value, 10
+    assert_equal c0.base, :binary
+    
+    c1 = 10.code(6)
+    assert_equal c1.to_s, "001010"
+    assert_equal c1.length, 6
+    assert_equal c1.value, 10
+    assert_equal c1.base, :binary
+
+    c2 = 10.code(:hex)
+    assert_equal c2.to_s, "A"
+    assert_equal c2.length, 4
+    assert_equal c2.value, 10
+    assert_equal c2.base, :hex
+    
+    c3 = 10.code(:hex, 2)
+    assert_equal c3.to_s, "0A"
+    assert_equal c3.length, 8
+    assert_equal c3.value, 10
+    assert_equal c3.base, :hex
+  end
+  
+  # Parity bit tests
+  
+  def test_02_parity
+    print "\n  parity"
+    
+    a = ?A.code(8)
+    assert_equal a.chr, "A"
+    assert a.even_parity?
+    assert_equal a.parity_bit, 0
+
+    a.add_parity_bit
+    assert_equal a.length, 9
+    assert a.even_parity?
+    
+    c = ?C.code(8)
+    assert_equal c.chr, "C"
+    assert ! c.even_parity?
+    assert_equal c.parity_bit, 1
+
+    c.add_parity_bit
+    assert_equal c.length, 9
+    assert c.even_parity?
+    
+    c.flip(7)
+    assert_equal c.to_s, "010000101"
+    assert ! c.even_parity?
+  end
+
+  # 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"
+    
+    a = RandomArray.new(:cars, 5)
+    assert_equal a.length, 5
+    
+    c = make_codes(a)
+    assert_equal c.length, 5
+    
+    codes = c.values.sort
+    assert_equal codes[0].length, 3
+    assert_equal codes[0].value, 0
+    assert_equal codes[-1].value, 4
+  end
+  
+  # Make some Message objects
+  
+  def test_04_messages
+    print "\n  messages"
+    
+    s = "hello"
+
+    msg1 = encode(s, :ascii)
+    assert_equal msg1.length, 8 * s.length
+    
+    msg2 = encode(s, :parity)
+    assert_equal msg2.length, 9 * s.length
+    
+    bang = ?!.code(8)
+    msg1 << bang
+    assert_equal decode(msg1, :ascii), s + "!"
+    
+    bang.add_parity_bit
+    msg2 << bang
+    assert_equal decode(msg2, :parity), s + "!"
+    
+    msg3 = msg1.copy
+    assert_not_equal msg3.object_id, msg1.object_id
+    msg3 << bang
+    assert msg3.length > msg1.length
+  end
+  
+  # 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
+    assert_nil n0.left 
+    assert_nil n0.right
+    assert n0.leaf?
+
+    n1 = Node.new("B", 0.4)
+    n2 = Node.combine(n0, n1)
+    assert_nil n2.char
+    assert_equal n2.freq, n0.freq + n1.freq
+    assert_equal n2.left, n0
+    assert_equal n2.right, n1
+    assert ! n2.leaf?
+  end
+  
+  # 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)
+    
+    pq = PriorityQueue.new
+    [n0,n1,n2].each { |x| pq << x }
+    
+    assert_equal pq.length, 3
+    assert_equal pq.first, n0
+    assert_equal pq.last, n1
+    
+    pq << Node.combine(pq.shift, pq.shift)
+    assert_equal pq.length, 2
+    assert_equal pq.first, n1
+    assert_equal pq.last.freq, n0.freq + n2.freq
+    assert ! pq.last.leaf?
+  end
+  
+  # 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")
+    
+    tree = build_tree(freq)
+    assert_equal tree.freq, 1.0
+    
+    codes = assign_codes(tree)
+    assert_equal codes["A"].to_s, "10"
+    assert_equal codes["W"].to_s, "110010"
+    
+    msg = encode("ALOHA", tree)
+    
+    assert_equal msg.to_s, "100000010000110"
+    assert_equal decode(msg, tree), "ALOHA"    
+  end
+  
+end

data/test/encryption_test.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include EncryptionLab
+
+class TestEncryption < Test::Unit::TestCase
+
+	# 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"
+    assert_equal caesar("ABCDEFGHIJKLMNOPQRSTUVWXYZ", 13), "NOPQRSTUVWXYZABCDEFGHIJKLM"
+    assert_equal caesar("Et tu, Brute?"), "Hw wx, Euxwh?"
+    assert_equal caesar("Et tu, Brute?", 13), "Rg gh, Oehgr?"
+  end
+
+end

data/test/iteration_test.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'test_helper'
+
+include IterationLab
+
+class TestIterativeAlgoritms < Test::Unit::TestCase
+  
+  # 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")
+    assert contains?(a, "fum")
+    assert !contains?(a, "foo")
+  end
+
+	# 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")
+    assert_equal 3, search(a, "fum")
+    assert_nil search(a, "foo")
+  end
+
+	# 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
+    end
+	end
+	
+end