editalign 1.0.0

data/README

@@ -0,0 +1,65 @@
+= Edit Alignment Module
+
+The module implements a dynamic programming string alignment algorithm
+that produces both alignments and edit distances between source and
+destination arrays or strings.
+
+An alignment between the arrays is represented as a sequence of
+insert, delete, and substitute operations that transform individual
+source items into destination items.  For example, the following is an
+alignment between the letters in the words 'captained' and 'caspian':
+
+  c  a  -  p  t  a  i  n  e  d
+  c  a  s  p  i  a  -  n  -  -
+
+Here an 's' was inserted, an 'i' was substituted for a 't', and an
+'i', an 'e', and a 'd' were deleted.
+
+The module exports an Alignment class which assigns numeric costs to
+each of these operations and finds the alignment that incurs the
+minimum cost or edit distance.  The Alignment class uses Dijkstra's
+algorithm to efficiently find edit distances for partially-aligned
+arrays.  See the EditAlign::DijkstraSearch class for details.
+
+   irb(main):001:0> require 'editalign'
+   => true
+   irb(main):002:0> a = EditAlign::Alignment.new('captained', 'caspian')
+   => <Alignment: 5>
+   irb(main):003:0> a.edit_distance
+   => 5
+   irb(main):004:0> a.edit_operations
+   => [nil, nil, :insert, nil, :substitute, nil, :delete, nil, :delete, :delete]
+   irb(main):005:0> a.source_alignment
+   => ["c", "a", nil, "p", "t", "a", "i", "n", "e", "d"]
+   irb(main):006:0> a.dest_alignment
+   => ["c", "a", "s", "p", "i", "a", nil, "n", nil, nil]
+   irb(main):007:0> puts a
+   ca-ptained
+   caspia-n--
+     I S D DD
+   5
+   => nil
+
+= History
+
+* 1-0-0 ... First version
+
+= See Also
+
+* The Levenshtein[http://po-ru.com/projects/levenshtein/] module generates a  Levenshtein edit distance doing an exhaustive search.
+
+= Acknowledgments
+
+Thanks to Jeremy G. Kahn for suggesting a diagonal-hugging search
+strategy and optimizations to the one implemented here.
+
+= Copyright
+
+Copyright 2006, William Patrick McNeill
+
+This program is distributed under the GNU General Public License.
+
+= Author
+
+W.P. McNeill mailto:billmcn@u.washington.edu
+

data/examples/align-strings

@@ -0,0 +1,72 @@
+#!/bin/env ruby
+
+#--
+# Copyright 2006 William Patrick McNeill
+#
+# This file is part of Editalign.
+#
+# Editalign is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Editalign is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#++
+
+# Print the character alignment between two strings passed in on the
+# command line.
+
+require 'getoptlong'
+require 'editalign'
+
+class ExhaustiveSellersAlignment < EditAlign::SellersAlignment
+  include EditAlign::ExhaustiveSearch
+end
+
+# Process command line options.
+opts = GetoptLong.new(["--match", "-m", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--nomatch", "-n", GetoptLong::REQUIRED_ARGUMENT],
+                      ["--insert", "-i",GetoptLong::REQUIRED_ARGUMENT],
+                      ["--delete", "-d",  GetoptLong::REQUIRED_ARGUMENT],
+                      ["--exhaustive", "-e", GetoptLong::NO_ARGUMENT]
+                      )
+
+match = 0
+mismatch = 1
+insert = 1
+delete = 1
+exhaustive = false
+opts.each do |opt, arg|
+  case opt
+  when "--match"
+    match = arg.to_f
+  when "--nomatch"
+    mismatch = arg.to_f
+  when "--insert"
+    insert = arg.to_f
+  when "--delete"
+    delete = arg.to_f
+  when "--exhaustive"
+    exhaustive = true
+  end
+end
+
+source = ARGV[0]
+dest = ARGV[1]
+
+# Do alignments and print results.
+alignments = [EditAlign::SellersAlignment]
+alignments << ExhaustiveSellersAlignment if exhaustive
+
+alignments.each do |align_class|
+  a = align_class.new(source, dest, match, mismatch, insert, delete)
+  puts a, a.to_grid
+end

data/examples/stress-test

@@ -0,0 +1,165 @@
+#!/bin/env ruby
+
+#--
+# Copyright 2006 William Patrick McNeill
+#
+# This file is part of Editalign.
+#
+# Editalign is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Editalign is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#++
+
+require "getoptlong"
+require "editalign"
+
+class PureRubyEditAlign < EditAlign::Alignment
+  def priority_queue_factory
+    require "priority_queue/ruby_priority_queue"     
+    RubyPriorityQueue.new
+  end
+end
+
+class IntegerPriorityEditAlign < EditAlign::Alignment
+  def priority_factory(cost, cell)
+    cost
+  end
+end
+
+
+# Process this script's command line options.
+#
+# There are three required arguments.
+#
+# * The number of alignments to perform
+# * The length of the strings to align
+# * The number of edits
+#
+# There are two optional switches.
+#
+# * verbose ... prints strings and edit distances
+# * pure-ruby ... uses the pure Ruby priority queue instead of the C extension
+# * int-cost ... uses integer costs
+def parse_command_line
+  opts = GetoptLong.new(["--verbose", "-v", GetoptLong::NO_ARGUMENT],
+                        ["--pure-ruby", "-p", GetoptLong::NO_ARGUMENT],
+                        ["--int-cost", "-i", GetoptLong::NO_ARGUMENT])
+  verbose = false
+  pure_ruby = false
+  int_cost = false
+  opts.each do |opt, arg|
+    case opt
+    when "--verbose"
+      verbose = true
+    when "--pure-ruby"
+      pure_ruby = true
+    when "--int-cost"
+      int_cost = true
+    end
+  end
+
+  trials = Integer(ARGV[0])
+  length = Integer(ARGV[1])
+  edits = Integer(ARGV[2])
+
+  if pure_ruby
+    klass = PureRubyEditAlign
+  elsif int_cost
+    klass = IntegerPriorityEditAlign
+  else
+    klass = EditAlign::Alignment
+  end
+
+  [trials, length, edits, klass, verbose]
+end
+
+# Run a number of alignments of the same size.
+def run_stress_test(trials, length, edits, klass, verbose)
+  (1..trials).each do |i|  
+    puts "Trial #{i}" if verbose
+
+    # Generate a destination string with random differences from the
+    # source string.
+    source, dest = create_strings(length, edits)
+
+    # Align the altered string with the one read from the file.
+    alignment = klass.new(source, dest)
+    print "#{alignment}\n\n" if verbose
+  end
+end
+
+# Create two unaligned strings.
+def create_strings(length, edits)
+  # The alphabet used for inserts and substitutions.
+  alphabet = ('A'..'Z').collect
+
+  # Source contains a repeating lowercase alphabet length characters
+  # long.
+  last = length - 1
+  source = (0..last).map {|x| (97 + x % 26).chr}
+
+  # There can only be as many edits as there are characters.
+  edits = length if edits > length
+
+  # Create a roughly even number of substitutions, inserts, and
+  # deletes.
+  n_subs = 0
+  n_ins = 0
+  n_dels = 0
+  (1..edits).each do
+    case rand(3)
+    when 0
+      n_subs += 1
+    when 1
+      n_ins += 1
+    when 2
+      n_dels += 1
+    end
+  end
+
+  # Distribute edit operations randomly throughout the string.
+  unchanged_pos = (0..last).collect
+  edit_op = [nil] * length
+
+  [:substitute, :insert, :delete].zip([n_subs, n_ins, n_dels]) do |op, n|
+    (1..n).each do
+      i = rand(unchanged_pos.length)
+      edit_op[unchanged_pos[i]] = op
+      unchanged_pos.delete_at(i)
+    end
+  end
+
+  # Use the random edit operations to create a destination string.
+  dest = ''
+  edit_op.each_index do |i|
+    case edit_op[i]
+    when nil
+      dest += source[i]
+    when :substitute
+      dest += alphabet[rand(alphabet.length)]
+    when :insert
+      dest += alphabet[rand(alphabet.length)] + source[i]
+    when :delete
+      # Do nothing
+    end
+  end
+
+  [source, dest]
+end
+
+
+if __FILE__ == $0
+  trials, length, edits, klass, verbose = parse_command_line
+  run_stress_test(trials, length, edits, klass, verbose)
+end

data/lib/editalign.rb

@@ -0,0 +1,516 @@
+# Copyright 2006 William Patrick McNeill
+#
+# Editalign is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Editalign is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+# EditAlign is the namespace that contains all edit alignment
+# functions.
+module EditAlign
+
+  # This module employs Dijkstra's algorithm to find the lowest-cost
+  # sequence of edit operations that will transform the source array
+  # into the destination array.  The alignment grid is treated as a
+  # directed acyclic graph where each cell in the grid is a vertex.
+  # Edges in the graph correspond to substitution, deletion and
+  # insertion operations.  The edge weights come from the weighting
+  # methods #substitute, #insert, and #delete.
+  #
+  # Generally speaking, the strategy is to search the diagonal of the
+  # alignment grid before the corners.  For partially-aligned arrays,
+  # this strategy can result in fewer calls to the weighting
+  # functions.
+  module DijkstraSearch
+
+    # Cells to be searched in the Dijkstra priority queue are ordered
+    # by SearchPriority.  SearchPriority orders cells first by cost,
+    # and then if the costs are equal by smallest number of hops to
+    # the end cell.  All things being equal, the latter comparison
+    # makes the algorithm search cells near the diagonal first.  This
+    # can help in instances where the beginings of the arrays are
+    # unaligned but the ends are aligned.
+    class SearchPriority
+
+      # The cost to reach the current cell
+      attr_reader :cost
+
+      # The minimum path length to the final cell
+      attr_reader :dist
+
+      include Comparable
+
+      # Specify the cost to reach a cell, the cell, and the final
+      # cell.
+      def initialize(cost, cell, end_cell)
+        @cost = cost
+        @dist = [end_cell.source - cell.source, end_cell.dest - cell.dest].max
+      end
+
+      # Order by cost and then by distance to the end cell.
+      def <=>(other)
+        comp = (cost <=> other.cost)
+        comp = (dist <=> other.dist) if comp == 0
+        comp
+      end
+
+      # Interactive stringification
+      def inspect
+        "Pri(#{cost}, #{dist})"
+      end
+    end
+
+    # Search the alignment grid filling in <em>@cost</em> and
+    # <em>@backtrace</em>.
+    def find_lowest_cost_alignment
+      agenda = priority_queue_factory
+
+      agenda[@start] = priority_factory(0, @start)
+      @backtrace = {}
+
+      until agenda.empty?
+        cell, priority = agenda.delete_min
+        cost = @cost[cell]
+        break if cost >= @cost[@end] 
+        outgoing(cell) do |next_cell, next_cost|
+          next_cost += @cost[cell]
+          next unless next_cost < @cost[next_cell]
+          @cost[next_cell] = next_cost
+          @backtrace[next_cell] = cell
+          agenda[next_cell] = priority_factory(next_cost, next_cell) \
+          unless next_cost >= @cost[@end]
+        end
+      end
+    end
+
+    # An enumeration of all the cells adjacent to the specified cell
+    # and the costs of transitioning to them.  Adjacent cells are
+    # reached by performing substitute, delete, and insertion
+    # operations.
+    def outgoing(cell) # :yields: cell, cost
+      # Substitute
+      if cell.source < @source.length-1 and cell.dest < @dest.length-1
+        next_cell = Alignment::Cell.new(cell.source+1, cell.dest+1)
+        if @cost[next_cell] > @cost[cell]
+          cost = substitute(@source[next_cell.source], @dest[next_cell.dest])
+          yield next_cell, cost
+        end
+      end
+      # Delete
+      if cell.source < @source.length-1
+        next_cell = Alignment::Cell.new(cell.source+1, cell.dest)
+        if @cost[next_cell] > @cost[cell]
+          cost = delete(@source[next_cell.source])
+          yield next_cell, cost
+        end
+      end
+      # Insert
+      if cell.dest < @dest.length-1
+        next_cell = Alignment::Cell.new(cell.source, cell.dest+1)
+        if @cost[next_cell] > @cost[cell]
+          cost = insert(@dest[next_cell.dest])
+          yield next_cell, cost
+        end
+      end
+    end
+
+    # Create the priority queue used by the search.  By default
+    # EditAlign uses the C extension version of the
+    # priority_queue[http://rubyforge.org/projects/priority-queue/]
+    # library.  If you wish to use a different priority queue
+    # implementation you may overload this function in a derived
+    # class.
+    def priority_queue_factory
+     require "priority_queue"
+     PriorityQueue.new
+
+      # Uncomment the following lines to use the pure-Ruby
+      # implementation of priority_queue.
+#        require "priority_queue/ruby_priority_queue"     
+#        RubyPriorityQueue.new
+    end
+
+    # Create a new search priority for the queue.  The priority must
+    # define the <em><=></em> operator.  Cells with lower priority
+    # value will be searched first.  If you wish to use a different
+    # prioritization scheme you may overload this function in a
+    # derived class.
+    def priority_factory(cost, cell)
+      SearchPriority.new(cost, cell, @end)
+    end
+
+    private :outgoing
+    protected :find_lowest_cost_alignment, :priority_queue_factory
+    protected :priority_factory
+  end
+
+
+  # This module employs an exhaustive search to find the lowest-cost
+  # sequence of edit operations that will transform the source array
+  # into the destination array.  It finds the lowest cost alignment by
+  # filling in every cell in the costs table.
+  #
+  # This algorithm will return the same results as Dijkstra's
+  # algorithm though it is less efficient for nearly-aligned strings.
+  # Nevertheless, this search algorithm is commonly cited when
+  # describing alignments, and so is implemented here for the sake of
+  # documentation and for comparison with the Dijkstra.
+  module ExhaustiveSearch
+
+    # An incoming cell and its associated cost.
+    IncomingCost = Struct.new("IncomingCost", :cell, :cost)
+
+    # Search the alignment grid filling in @cost and @backtrace.
+    def find_lowest_cost_alignment
+      @backtrace = {}
+      
+      #  Fill in the top row of the table.
+      (1..@source.length).each do |source|
+        @cost[Alignment::Cell.new(source, 0)] = \
+        @cost[Alignment::Cell.new(source-1, 0)] + delete(@source[source])
+      end
+      # Fill in the first column of the table.
+      (1..@dest.length).each do |dest|
+        @cost[Alignment::Cell.new(0, dest)] = \
+        @cost[Alignment::Cell.new(0, dest-1)] + insert(@dest[dest])
+      end
+      # Fill in all the remaining cells in the table.
+      (1..@source.length).each do |source|
+        (1..@dest.length).each do |dest|
+          incoming = []
+          c = Alignment::Cell.new(source-1, dest)
+          incoming << IncomingCost.new(c, @cost[c] + delete(@source[source]))
+          c = Alignment::Cell.new(source, dest-1)
+          incoming << IncomingCost.new(c, @cost[c] + insert(@dest[dest]))
+          c = Alignment::Cell.new(source-1, dest-1)
+          incoming << \
+          IncomingCost.new(c, @cost[c] + substitute(@source[source],
+                                                    @dest[dest]))
+          best = incoming.min {|a,b| a.cost <=> b.cost}
+          @cost[Alignment::Cell.new(source, dest)] = best.cost
+          @backtrace[Alignment::Cell.new(source, dest)] =  best.cell
+        end
+      end
+    end
+
+    protected :find_lowest_cost_alignment
+  end
+
+
+  # The Alignment class is given a source and destination array at
+  # construction time.  It does a dynamic programming alignment
+  # between them and makes the results of that alignment available
+  # through instance methods.
+  #
+  # If there are multiple alignments with equal edit distances
+  # Alignment will find one of them.  Which one is undefined.
+  #
+  # Alignment works by constructing a matrix with dimensions equal to
+  # the length of the source and destination arrays.  Moving
+  # horizontally and vertically in the matrix represents insertion and
+  # deletion operations, respectively, while moving diagonally
+  # represents substitution.  Each cell of the matrix contains the
+  # minimum cost it takes to reach that cell.  The algorithm fills in
+  # cells in the matrix until it reaches the furthest corner.
+  #
+  # The search is done using Dijkstra's algorithm as implemented in
+  # the DijkstraSearch.  A different search algorithm may be specified
+  # by including a mixin that redefines the
+  # #find_lowest_cost_alignment function.
+  #
+  # This class uses Levenshtein weighting scheme. Levenshtein assigns
+  # a cost of 1 to insertions and deletions.  It assigns a cost of 1
+  # to substitutions when the items are different and 0 when they are
+  # the same.  Different weighting schemes may be specified by
+  # overloading the #insert, #delete, and #substitute functions.  The
+  # costs must be non-negative numbers.
+  class Alignment
+    include DijkstraSearch
+
+    # A location in the alignment grid.
+    Cell = Struct.new("Cell", :source, :dest)
+
+    # The caller specifies a source and destination array.  The object
+    # performs the alignment at construction time.
+    #
+    # Optionally either <em>source</em> or <em>dest</em> may be
+    # strings, in which they will be treated as arrays of characters.
+    def initialize(source, dest)
+      # Convert strings into arrays.
+      source = source.unpack('U*').collect {|c| c.chr} if source.class == String
+      dest = dest.unpack('U*').collect {|c| c.chr} if dest.class == String
+
+      # Prepend empty elements to the source and destination arrays to
+      # handle insertions and deletions at the front of the alignment.
+      @source = source.unshift(nil)
+      @dest = dest.unshift(nil)
+
+      # The start and end cells of the search.
+      @start = Cell.new(0, 0)
+      @end = Cell.new(@source.length-1, @dest.length-1)
+
+      # The lowest known cost to reach a cell.  Unexplored cells have
+      # an infinite cost.
+      @cost = Hash.new{1.0/0.0}
+      @cost[@start] = 0
+
+      # Fill in the @cost matrix including @cost[@end] and create a
+      # lowest-cost sequence of cells in @backtrace.
+      find_lowest_cost_alignment
+    end
+
+    # The minimum edit distance
+    def edit_distance
+      @cost[@end]
+    end
+
+    # The lowest-cost list of edit operations.  This is a list of
+    # <em>:substitute</em>, <em>:insert</em>, <em>:delete</em> symbols
+    # for operatations that changed an array element and
+    # <em>marker</em> for operations that did not.
+    def edit_operations(marker = nil)
+      ops = []
+      edit_sequence do |cell, operation|
+        if operation == :substitute
+          ops << \
+          (@source[cell.source] == @dest[cell.dest] ? marker: :substitute)
+        else
+          ops << operation
+        end
+      end
+      ops
+    end
+
+    # The source items with <em>marker</em> inserted where an
+    # insertion took place.
+    def source_alignment(marker = nil)
+      source = []
+      edit_sequence do |cell, operation|
+        source << (operation == :insert ? marker:@source[cell.source])
+      end
+      source
+    end
+
+    # The destination items with <em>marker</em> inserted where a
+    # deletion took place.
+    def dest_alignment(marker = nil)
+      dest = []
+      edit_sequence do |cell, operation|
+        dest << (operation == :delete ? marker:@dest[cell.dest])
+      end
+      dest
+    end
+
+    # Enumerate the minimum-cost sequence of edit operations.
+    def edit_sequence # :yields: cell, {:substitute, :insert, :delete}
+      # The first time this function is called, walk backwards through
+      # the backtrace to create the @path instance variable.
+      if not @path
+        @path = [@end]
+        while cell = @backtrace[@path[0]]
+          @path.unshift(cell)
+        end
+      end
+      # Walk forwards through the path.
+      prev_cell = @start
+      @path[1..-1].each do |cell|
+        delta_source = cell.source - prev_cell.source
+        delta_dest = cell.dest - prev_cell.dest
+        if delta_source == 1 and delta_dest == 1
+          yield cell, :substitute
+        elsif delta_source == 1
+          yield cell, :delete
+        elsif delta_dest == 1
+          yield cell, :insert
+        else
+          raise "Invalid path link #{prev_cell}->#{cell}"
+        end
+        prev_cell = cell
+      end
+    end
+
+    # Interactive stringification
+    def inspect
+      "<Alignment: #{edit_distance}>"
+    end
+
+    # The cost of substituting <em>source_item</em> with
+    # <em>dest_item</em>.
+    def substitute(source_item, dest_item)
+      source_item == dest_item ? 0:1
+    end
+
+    # The cost of deleting <em>source_item</em>.
+    def delete(source_item)
+      1
+    end
+    
+    # The cost of inserting <em>dest_item</em>.
+    def insert(dest_item)
+      1
+    end
+
+    # The string representation of the alignment consists of four lines:
+    #
+    # 1. The source array
+    # 2. The destination array
+    # 3. An annotation line with S, I, D or nothing for aligned elements.
+    # 4. The edit distance
+    def to_s
+      # Create the source and destination lines.
+      s_line = source_alignment('-')
+      d_line = dest_alignment('-')
+      # Create short pneumonics for the edit operations.
+      ops = edit_operations.map do |op|
+        case op
+        when nil
+          c = " "
+        when :substitute
+          c = "S"
+        when :insert
+          c = "I"
+        when :delete
+          c = "D"
+        end
+      end
+      # Find the longest element in all the lines.
+      longest = [s_line, d_line, ops].map{|l| l.map{|e| e.length}.max}.max
+      # Center each array element over a field of that width.
+      lines = [s_line, d_line, ops].map do |list|
+        list.map{|c| c.center(longest)}.join
+      end
+      (lines + [edit_distance]).join("\n")
+    end
+
+    # This prints a grid of all the costs.  Cells that were not
+    # visited because they could not contribute to the lowest-cost
+    # path are marked with an asterisk.  Cells that are in the lowest
+    # cost path are highlighted with square brackets.
+    #
+    #    irb(main):001:0> require 'editalign'
+    #    => true
+    #    irb(main):002:0> a = EditAlign::Alignment.new('captained', 'caspian')
+    #    => <Alignment: 5>
+    #    irb(main):003:0> puts a
+    #                 -         c         a         p         t         a         i         n         e         d  
+    #    -         [0.00]     1.00      2.00      3.00      4.00      5.00        *         *         *         *  
+    #    c          1.00     [0.00]     1.00      2.00      3.00      4.00      5.00        *         *         *  
+    #    a          2.00      1.00     [0.00]     1.00      2.00      3.00      4.00      5.00        *         *  
+    #    s          3.00      2.00     [1.00]     1.00      2.00      3.00      4.00      5.00        *         *  
+    #    p          4.00      3.00      2.00     [1.00]     2.00      3.00      4.00      5.00        *         *  
+    #    i          5.00      4.00      3.00      2.00     [2.00]     3.00      3.00      4.00      5.00        *  
+    #    a            *       5.00      4.00      3.00      3.00     [2.00]    [3.00]     4.00      5.00        *  
+    #    n            *         *       5.00      4.00      4.00      3.00      3.00     [3.00]    [4.00]    [5.00]
+    #    => nil
+    def to_grid
+      # Make the columns wide enough to accommodate the widest header
+      # or value.
+      widest_header = @source.find_all{|x| x}.map{|x| x.length}.max
+      widest_cost = @cost.values.map{|c| (sprintf "%.2f", c).length + 2}.max
+      # The conditional handles empty alignments.
+      col_width = (widest_header and widest_cost) ? \
+      [widest_header, widest_cost].max: 1
+
+      # Create the header row.
+      header = [""] + @source.map{|x| x ? x: "-"}
+      header = header.map {|x| x.center(col_width)}
+
+      # Make note of which cells are on the lowest-cost path.
+      path_cells = {}
+      @path.each {|cell| path_cells[cell] = true} if @path
+
+      # Enumerate the destination, creating the cost rows.
+      table = [header]
+      (0..@dest.length-1).each do |dest|
+        x = @dest[dest]
+        x = "-" if not x
+        row = [sprintf("%-#{col_width}s", x)]
+        (0..@source.length-1).each do |source|
+          cell = Cell.new(source, dest)
+          c = @cost[cell]
+          if c == 1.0/0.0
+            # Center the * character in the column.
+            value = "*".center(col_width)
+          else
+            # Put brackets around cells in the best path.
+            value = sprintf path_cells[cell] ? "[%.2f]":" %.2f ", c
+            value = sprintf "%#{col_width}s", value
+          end
+          row << value
+        end
+        table << row
+      end
+      # Combine the rows into a single string table.
+      col_spc = " " * 4
+      table.map{|row| row.join(col_spc)}.join("\n")
+    end
+
+    private :edit_sequence
+    protected :substitute, :delete, :insert
+  end
+
+  # The Levenshtein alignment yields a cost of 1 for insertions,
+  # deletions, and item mismatch.  This class is a synonym for
+  # Alignment.
+  class LevenshteinAlignment < Alignment
+  end
+
+  # The Sellers alignment (aka the Needleman-Wunsch alignment) allows
+  # different constant costs to be specified for insertion, deletion,
+  # and substitute match and mismatch operations.
+  class SellersAlignment < Alignment
+
+    # The costs for insert, delete, and substitution match and
+    # mismatch are specified here.  The default values for these costs
+    # yields a Levenshtein alignment.
+    def initialize(source, dest, match = 0, mismatch = 1,
+                   insert = 1, delete = 1)
+      @match = match
+      @mismatch = mismatch
+      @insert = insert
+      @delete = delete
+      super(source, dest)
+    end
+
+    # The cost of substituting <em>source_item</em> with
+    # <em>dest_item</em>.
+    def substitute(source_item, dest_item)
+      source_item == dest_item ? @match:@mismatch
+    end
+
+    # The cost of deleting <em>source_item</em>.
+    def delete(source_item)
+      @delete
+    end
+    
+    # The cost of inserting <em>dest_item</em>.
+    def insert(dest_item)
+      @insert
+    end
+
+    protected :substitute, :delete, :insert
+  end
+
+  # The Wagner-Fischer alignment specifies the same cost for insertion
+  # and deletion operations, another for item match, and another for
+  # item mismatch.
+  class WagnerFischerAlignment < SellersAlignment
+
+    # The costs for insert/delete operations and character match and
+    # mismatch are specified here.  The default values for these costs
+    # yields a Levenshtein alignment.
+    def initialize(source, dest, match = 0, mismatch = 1, insert_delete = 1)
+      super(source, dest, match, mismatch, insert_delete, insert_delete)
+    end
+  end
+
+end

data/test/test_editalign.rb

@@ -0,0 +1,167 @@
+#!/bin/env ruby
+
+#--
+# Copyright 2006 William Patrick McNeill
+#
+# This file is part of Editalign.
+#
+# Editalign is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# Editalign is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with editalign; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#++
+
+# Test cases for the EditAlign module
+
+require 'test/unit'
+require 'editalign'
+
+
+class LevenshteinStringAlignments < Test::Unit::TestCase
+  def test_captained_caspian
+    a = EditAlign::Alignment.new("captained", "caspian")
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 5, a.edit_distance
+    assert_equal [nil, nil, :insert, nil, :substitute, nil, :delete, nil, :delete, :delete], a.edit_operations
+    assert_equal ["c", "a", nil, "p", "t", "a", "i", "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", "i", "a", nil, "n", nil, nil], a.dest_alignment
+  end
+end
+
+
+class SellersAlignments <  Test::Unit::TestCase
+  def test_captained_caspian
+    a = EditAlign::SellersAlignment.new("captained", "caspian")
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 5, a.edit_distance
+    assert_equal [nil, nil, :insert, nil, :substitute, nil, :delete, nil, :delete, :delete], a.edit_operations
+    assert_equal ["c", "a", nil, "p", "t", "a", "i", "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", "i", "a", nil, "n", nil, nil], a.dest_alignment
+  end
+
+  def test_captained_caspian_custom_weights
+    a = EditAlign::SellersAlignment.new("captained", "caspian", 0.1, 0.5, 0.8, 0.9)
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 4.1, a.edit_distance
+    assert_equal [nil,  nil, :substitute, :substitute, :delete, nil, :substitute, :delete, :substitute], a.edit_operations
+    assert_equal ["c", "a", "p", "t", "a", "i", "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", nil, "i", "a", nil, "n"], a.dest_alignment
+  end
+end
+
+
+class WagnerFischerAlignments <  Test::Unit::TestCase
+  def test_captained_caspian
+    a = EditAlign::WagnerFischerAlignment.new("captained", "caspian")
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 5, a.edit_distance
+    assert_equal [nil, nil, :insert, nil, :substitute, nil, :delete, nil, :delete, :delete], a.edit_operations
+    assert_equal ["c", "a", nil, "p", "t", "a", "i", "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", "i", "a", nil, "n", nil, nil], a.dest_alignment
+  end
+
+  def test_captained_caspian_high_substitution_cost
+    a = EditAlign::WagnerFischerAlignment.new("captained", "caspian", 0, 20, 1)
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 6, a.edit_distance
+    assert_equal [nil, nil, :insert, nil, :delete, :delete, nil, :insert, nil, :delete, :delete], a.edit_operations
+    assert_equal ["c", "a", nil, "p", "t", "a", "i", nil, "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", nil, nil, "i", "a", "n", nil, nil], a.dest_alignment
+  end
+end
+
+
+class ParameterOptions <  Test::Unit::TestCase
+  def test_array_init
+    a = EditAlign::Alignment.new(['c', 'a', 'p', 't', 'a', 'i', 'n', 'e', 'd'], ['c', 'a', 's', 'p', 'i', 'a', 'n'])
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 5, a.edit_distance
+    assert_equal [nil, nil, :insert, nil, :substitute, nil, :delete, nil, :delete, :delete], a.edit_operations
+    assert_equal ["c", "a", nil, "p", "t", "a", "i", "n", "e", "d"], a.source_alignment
+    assert_equal ["c", "a", "s", "p", "i", "a", nil, "n", nil, nil], a.dest_alignment
+  end
+
+  def test_marker
+    a = EditAlign::Alignment.new("captained", "caspian")
+    assert_equal ["X", "X", :insert, "X", :substitute, "X", :delete, "X", :delete, :delete], a.edit_operations("X")
+    assert_equal ["c", "a", "X", "p", "t", "a", "i", "n", "e", "d"], a.source_alignment('X')
+    assert_equal ["c", "a", "s", "p", "i", "a", "X", "n", "X", "X"], a.dest_alignment('X')
+  end
+end
+
+
+class BoundaryConditions < Test::Unit::TestCase
+  def test_empty_alignment
+    a = EditAlign::Alignment.new([], [])
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 0, a.edit_distance
+    assert_equal [], a.source_alignment
+    assert_equal [], a.dest_alignment
+    assert_equal [], a.edit_operations
+  end
+
+  def test_nonempty_empty_alignment
+    a = EditAlign::Alignment.new(['A', 'B', 'C'], [])
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 3, a.edit_distance
+    assert_equal [:delete, :delete, :delete], a.edit_operations
+    assert_equal ['A', 'B', 'C'], a.source_alignment
+    assert_equal [nil, nil, nil], a.dest_alignment
+  end
+
+  def test_empty_nonempty_alignment
+    a = EditAlign::Alignment.new([], ['A', 'B', 'C'])
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 3, a.edit_distance
+    assert_equal [:insert, :insert, :insert], a.edit_operations
+    assert_equal [nil, nil, nil], a.source_alignment
+    assert_equal ['A', 'B', 'C'], a.dest_alignment
+  end
+
+  def test_identical
+    a = EditAlign::Alignment.new(['A', 'B', 'C'], ['A', 'B', 'C'])
+    assert_kind_of EditAlign::Alignment, a
+    assert_equal 0, a.edit_distance
+    assert_equal [nil, nil, nil], a.edit_operations
+    assert_equal ['A', 'B', 'C'], a.source_alignment
+    assert_equal ['A', 'B', 'C'], a.dest_alignment
+  end
+end
+
+class Stringification < Test::Unit::TestCase
+  def test_captained_caspian
+    a = EditAlign::Alignment.new("captained", "caspian")
+    s = \
+"ca-ptained
+caspia-n--
+  I S D DD
+5"
+    assert_equal s, a.to_s
+  end
+end
+
+class CompareSearchAlgorithm < Test::Unit::TestCase
+
+  class ExhaustiveAlignment < EditAlign::SellersAlignment
+    include EditAlign::ExhaustiveSearch
+  end
+
+  def test_dijkstra_exhaustive
+    d = EditAlign::Alignment.new("captained", "caspian")
+    e = ExhaustiveAlignment.new("captained", "caspian")
+    assert_equal d.edit_distance, e.edit_distance
+    assert_equal d.edit_operations, e.edit_operations
+    assert_equal d.source_alignment, e.source_alignment
+    assert_equal d.dest_alignment, e.dest_alignment
+  end
+end

metadata

@@ -0,0 +1,62 @@
+!ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: editalign
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+date: 2006-05-30 00:00:00 -07:00
+summary: Edit alignments between arrays
+require_paths: 
+- lib
+email: billmcn@u.washington.edu
+homepage: http://staff.washington.edu/billmcn/index.shtml
+rubyforge_project: 
+description: This module performs edit alignments between arrays.  It returns alignments and edit distances.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- W.P. McNeill
+files: 
+- test/test_editalign.rb
+- lib/editalign.rb
+- examples/align-strings
+- examples/stress-test
+- README
+test_files: 
+- test/test_editalign.rb
+rdoc_options: 
+- --title
+- EditAlign -- Ruby Edit Alignment
+- --main
+- README
+- --line-numbers
+- --inline-source
+extra_rdoc_files: 
+- README
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: PriorityQueue
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: