rubylabs 0.6.4 → 0.7.0

data/lib/tsplab.rb

@@ -12,7 +12,11 @@
   TODO plot space: get all 180K costs, order lexicographically, plot (smoothed)
 =end
 
-require 'set'
+module RubyLabs
+  
+module TSPLab
+
+  require 'set'
 
 =begin rdoc
 
@@ -33,7 +37,7 @@ minutes.
 #   distance(x,y) returns the distance between cities with keys x and y
 
 
-class CityList
+  class CityList
   
 =begin rdoc
 The lines in the input file passed to the constructor come from a
@@ -43,130 +47,101 @@ 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
+    def initialize(matrix)
+      matrixfilename = matrix.to_s + ".txt"
+      matrixfilename = File.join(@@dataDirectory, matrixfilename)
+      raise "Matrix not found: #{matrixfilename}" unless File.exists?(matrixfilename)
+
+      @key = ?A
+      @cities = Hash.new          # initially a map from name string to one-letter key
+      @matrix = Hash.new
+
+      File.open(matrixfilename).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
+      @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]}"
+      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
-    end
-    raise "CityList.new: errors in input file" if errs > 0
+      raise "CityList.new: errors in input file" if errs > 0
 
-  end
+    end
 
-  def inspect()
-    n = @matrix.length
-    return "List of #{n} cities"
-  end
+    def inspect()
+      n = @matrix.length
+      return sprintf "TSPLab::CityList (%d x %d)", n, n-1
+    end
   
-  def size()
-    return @key - ?A
-  end
+    def size()
+      return @key - ?A
+    end
 
-  def keys()
-    return @cities.keys.sort.map{|x| x.chr}
-  end
+    def keys()
+      return @cities.keys.sort.map{|x| x.chr}
+    end
 
-  def values()
-    return @cities.keys.sort.collect{|x| @cities[x]}
-  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 [](x)
+      x = x[0] if x.class == String
+      return nil 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
+    def distance(x,y)
+      x = x[0] if x.class == String
+      y = y[0] if y.class == String
+      return nil unless x >= ?A && x < @key
+      return nil 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
+    private
 
-  def assign(i,j,v)
-    if @matrix[i] == nil
-      @matrix[i] = Hash.new
+    def getKey(s)
+      if @cities[s] == nil
+        @cities[s] = @key
+        @key += 1
+      end
+      return @cities[s]
     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]
+    def getValue(s)
+      a = s.scan(/(\d+)/)
+      if a.length == 1
+        return a[0][0].to_i
+      else
+        return 0
+      end
     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)
+    def assign(i,j,v)
+      if @matrix[i] == nil
+        @matrix[i] = Hash.new
+      end
+      @matrix[i][j] = v
     end
-    self
-  end
 
-end
+  end # class CityList
 
 =begin rdoc
 
@@ -181,129 +156,129 @@ inherited from a parent, and incremented whenever a mutation or crossover is app
 =end
 
 
-class Tour 
-  attr_reader :id, :path, :cost, :matrix, :nm, :nx
+  class Tour 
+    attr_reader :id, :path, :cost, :matrix, :nm, :nx
 
-  @@id = 0
+    @@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)
+    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
-      @path = s.clone
+      @cost = pathcost(m,@path)
+      @matrix = m                 # need matrix to update cost after mutation...
+      @id = @@id
+      @nm = nm
+      @nx = nx
+      @@id += 1
     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
+  	# 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 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
+    def inspect
+      return to_s
+    end
 
-  # Reset the id to 0 (e.g. to count number of objects)
+    # Reset the id to 0 (e.g. to count number of objects)
 
-  def Tour.reset
-    @@id = 0
-  end
+    def Tour.reset
+      @@id = 0
+    end
 
-  def Tour.count
-    @@id
-  end
+    def Tour.count
+      @@id
+    end
 
-  # A copy of a tour needs its own new id and copy of the path and pedigree
+    # 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
+    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.
+    # 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
+    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.
+    # 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)
+    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
-    @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 methods -- compute the cost of a path, given a matrix; apply
+    # mutations (point mutations, cross-overs)
 
-  private
+    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])
+    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
-    return sum
-  end
 
-end
+  end # class Tour
 
 # Make a population of size n -- n instances of tours made from a set
 # of cities 
 
-def initPopulation(n,m)
-  a = Array.new
+  def initPopulation(n,m)
+    a = Array.new
 
-  n.times do
-    a.push(Tour.new(m))
-  end
+    n.times do
+      a.push(Tour.new(m))
+    end
   
-  a.sort! { |x,y| x.cost <=> y.cost }
+    a.sort! { |x,y| x.cost <=> y.cost }
 
-  return a
-end
+    return a
+  end
 
 # Evolve a population.  Sort by fitness, then remove individuals with
 # a probability based on their ranking (the ith individual survives
@@ -312,105 +287,162 @@ end
 # 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
+  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
-  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
+    # 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
-    p.push(kid)
-    best = kid if kid.cost < best.cost
-  end
 
-  return best
+    return best
 
-end
+  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
+  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
   
-  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 "popsize: #{popsize}"
-    puts "maxgen: #{maxgen}"
-    puts "maxstatic: #{maxstatic}"
-    puts "pcross: #{param[:pcross]}"
+    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
 
-  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
+  def checkout(matrix, filename = nil)
+    matrixfilename = matrix.to_s + ".txt"
+    matrixfilename = File.join(@@dataDirectory, matrixfilename)
+    if !File.exists?(matrixfilename)
+      puts "Matrix not found: #{matrixfilename}"
+      return nil
     end
-    ngen += 1
+    outfilename = filename.nil? ? (matrix.to_s + ".txt") : filename
+    dest = File.open(outfilename, "w")
+	  File.open(matrixfilename).each do |line|
+	    dest.puts line.chomp
+	  end
+    dest.close
+    puts "Copy of #{matrix} saved in #{outfilename}"
   end
+  
+  # Values accessible to all the methods in the module
+  
+  @@dataDirectory = File.join(File.dirname(__FILE__), '..', 'data', 'tsp')
+
+end # module TSPLab
+
+end # module RubyLabs
+
+# Additions to the String class
 
-  # puts "#{ngen} generations (#{nstatic} at best value)"
-  puts "#{ngen} generations"
+class String
   
-  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]
+=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
 
-  return best
 end