suffix_tree 0.0.1

data/lib/visitor/node_count_visitor.rb

@@ -0,0 +1,16 @@
+class NodeCountVisitor
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def preVisit(node)
+    @count += 1
+    return true
+  end
+
+  def postVisit(node)
+    # do nothing
+  end
+end

data/lib/visitor/numbering_visitor.rb

@@ -0,0 +1,230 @@
+require_relative '../node'
+require_relative 'base_visitor'
+
+# monkey patching dfsNumber and numberNodesInSubtree
+module NodeExtensions
+  # set by first pass traversal with NumberingVisitor
+  attr_accessor :dfsNumber
+
+  # numberNodesInSubtree detects proper ancestor of two nodes, where ancestor is lca
+  # binaryTreeHeight is required for building runs
+  attr_accessor :numberNodesInSubtree, :binaryTreeHeight
+
+  # set by second pass traversal with IvVisitor, a run is the path with a single
+  # (lowest in tree) node with the greatest binaryTreeHeight.  runHead and runTail
+  # are the nodes that span the run.
+  attr_accessor :runHead, :runTail
+
+  # set by third pass with RunBitVisitor, sets bits for each ancestor run
+  attr_accessor :runBits
+end
+
+class Node
+  prepend NodeExtensions
+end
+
+class BitUtil
+  def initialize
+    @masks = [ 0xffff, 0xff ]
+    @rightTable = [ 0 ]
+    @leftTable = [ 0 ]
+
+    (1..255).each do |val|
+      @rightTable << rightOneBit(val)
+      @leftTable << leftOneBit(val)
+    end
+  end
+
+  def rightBit(n)
+    shiftCount, n = shiftToByteRight(n)
+    @rightTable[n & 0xff] + shiftCount
+  end
+
+  def leftBit(n)
+    shiftCount, n = shiftToByteLeft(n)
+    @leftTable[n & 0xff] + shiftCount
+  end
+
+  def bitGreaterThanOrEqualTo(startOffset, v1, v2)
+    map = (1 << (startOffset - 1))
+    while (startOffset < 64) do
+      if (((v1 & map) != 0) && ((v2 & map) != 0)) then
+        return startOffset
+      else
+        startOffset += 1
+        map = map << 1
+      end
+    end
+  end
+
+  def leftMostBitToRightOf(bitNumber, n)
+    mask = getMask(bitNumber + 1)
+    return leftBit(n & mask)
+  end
+
+  private
+
+  def getMask(bitNumber)
+    # assume 64 bit numbers
+    0xffffffffffffffff >> bitNumber
+  end
+
+  def shiftToByteRight(n)
+    shiftCount = 0
+    if ((n & 0xffffffff) == 0) then
+      n = n >> 32
+      shiftCount += 32
+    end
+    if ((n & 0xffff) == 0) then
+      n = n >> 16
+      shiftCount += 16
+    end
+    if ((n & 0xff) == 0) then
+      n = n >> 8
+      shiftCount += 8
+    end
+    return shiftCount, n
+  end
+
+  def shiftToByteLeft(n)
+    shiftCount = 0
+    if ((n & 0xffffffff00000000) != 0) then
+      n = n >> 32
+      shiftCount += 32
+    end
+    if ((n & 0xffff0000) != 0) then
+      n = n >> 16
+      shiftCount += 16
+    end
+    if ((n & 0xff00) != 0) then
+      n = n >> 8
+      shiftCount += 8
+    end
+    return shiftCount, n
+  end
+
+  def rightOneBit(n)
+    mask = 1
+    result = 1
+    while ((n & mask) == 0) do
+      mask = mask << 1
+      result += 1
+    end
+    return result
+  end
+
+  def leftOneBit(n)
+    mask = 1 << 7
+    result = 8
+    while ((n & mask) == 0) do
+      mask = mask >> 1
+      result -= 1
+    end
+    return result
+  end
+end
+
+# use BaseVisitor counters to set the values
+class NumberingVisitor < BaseVisitor
+  def initialize
+    @bitCalculator = BitUtil.new
+    super
+  end
+
+  def preVisit(node)
+    super(node)
+    node.dfsNumber = @preCounter
+    node.binaryTreeHeight = @bitCalculator.rightBit(@preCounter)
+    return true
+  end
+
+  def postVisit(node)
+    node.numberNodesInSubtree = @preCounter - node.dfsNumber + 1
+  end
+end
+
+# set the height of the complete binary tree node that each node maps to
+class RunDefiningVisitor
+  def preVisit(node)
+    # every node gets the runTail set correctly
+    # runHead is ONLY valid in the runTail node
+    node.runHead = node.runTail = node
+    parentDfsNumber = 0
+    parentDfsNumber = node.parent.dfsNumber if (node.parent != nil)
+    return true
+  end
+
+  def postVisit(node)
+    # the child with a greatest binaryTreeHeight larger than the current node's binaryTreeHeight
+    # is the runTail, the current node is the runHead (which we need to set in runTail)
+    if (node.children != nil) then
+      maxBinaryTreeHeight = node.binaryTreeHeight
+      maxBinaryTreeHeightNode = nil
+      node.children.values.each do |child|
+        if (child.runTail.binaryTreeHeight > maxBinaryTreeHeight) then
+          maxBinaryTreeHeight = child.runTail.binaryTreeHeight
+          maxBinaryTreeHeightNode = child
+        end
+      end
+      if (maxBinaryTreeHeightNode != nil) then
+        node.runTail = maxBinaryTreeHeightNode.runTail
+
+        # runHead is ONLY valid in the runTail node,
+        # the alternative is to traverse from runTail to node whenever runHead changes
+        # (or to do this only on final change)
+        node.runTail.runHead = node
+      end
+    end
+  end
+end
+
+class RunBitVisitor
+  def initialize(startNode)
+    startNode.runBits = 0
+  end
+
+  def preVisit(node)
+    if (node.parent != nil) then
+      node.runBits = node.parent.runBits
+    end
+    node.runBits = node.runBits | getBit(node.runTail.binaryTreeHeight)
+    return true
+  end
+
+  def postVisit(node)
+  end
+
+  private
+  def getBit(n)
+    1 << (n-1)
+  end
+end
+
+class LeafNodeCollector
+  attr_reader :suffixToLeaf
+
+  def initialize
+    @suffixToLeaf = {}
+  end
+
+  def preVisit(node)
+    if (node.children == nil) then
+      @suffixToLeaf[node.suffixOffset] = node
+    end
+    return true
+  end
+
+  def postVisit(node)
+  end
+end
+
+class LeastCommonAncestorPreprocessing
+  def initialize(startNode)
+    dfs = OrderedDFS.new(NumberingVisitor.new)
+    dfs.traverse(startNode)
+    dfs = OrderedDFS.new(RunDefiningVisitor.new)
+    dfs.traverse(startNode)
+    dfs = DFS.new(RunBitVisitor.new(startNode))
+    dfs.traverse(startNode)
+  end
+end

data/lib/visitor/suffix_offset_visitor.rb

@@ -0,0 +1,23 @@
+#
+#  Only makes sense from OrderedDFS
+#
+class SuffixOffsetVisitor
+
+  attr_reader :result
+
+  def initialize
+    @result = []
+  end
+
+  def preVisit(node)
+    if (node.isLeaf) then
+      @result << node.suffixOffset
+    end
+    return true
+  end
+
+  def postVisit(node)
+    # do nothing
+  end
+
+end

data/lib/visitor/tree_print_visitor.rb

@@ -0,0 +1,44 @@
+class TreePrintVisitor
+  ALL_LEVELS = -1
+
+  def initialize(dataSource, io, level=ALL_LEVELS)
+    @indentation = 0
+    @dataSource = dataSource
+    @io = io
+    @level = level
+  end
+
+  def nodeToStr(node)
+    if (node.isRoot) then
+      "ROOT"
+    else
+      "#{@dataSource.toString(node.incomingEdgeStartOffset, node.incomingEdgeEndOffset)}"
+    end
+  end
+
+  def preVisit(node)
+    @io.print "#{" "*@indentation}#{self.nodeToStr(node)}\n"
+    if (@level == ALL_LEVELS) || (@indentation < @level) then
+      @indentation += 1
+      return true
+    else
+      return false
+    end
+  end
+
+  def postVisit(node)
+    @indentation -= 1
+  end
+end
+
+class DfsTreePrintVisitor < TreePrintVisitor
+  def nodeToStr(node)
+    "#{node.dfsNumber} #{node.suffixOffset}, #{node.runTail.binaryTreeHeight}/#{node.runTail.dfsNumber} #{super}"
+  end
+end
+
+class BasicDfsTreePrintVisitor < TreePrintVisitor
+  def nodeToStr(node)
+    "#{node.dfsNumber} #{node.suffixOffset}, #{super}"
+  end
+end

data/lib/visitor/value_depth_visitor.rb

@@ -0,0 +1,34 @@
+require_relative '../node'
+
+class ValueDepthVisitor < BaseVisitor
+  def initialize
+    super
+  end
+
+  def preVisit(node)
+    if (node.isInternal) then
+      node.valueDepth = node.parent.valueDepth + node.incomingEdgeLength
+    elsif (node.isLeaf) then
+      node.valueDepth = Node::LEAF_DEPTH
+    end
+    return true
+  end
+end
+
+
+class DeepestValueDepthVisitor < BaseVisitor
+  attr_reader :deepestValueDepth, :deepestValueDepthNode
+
+  def initialize
+    @deepestValueDepthNode = nil
+    @deepestValueDepth = 0
+    super
+  end
+
+  def postVisit(node)
+    if (node.valueDepth > @deepestValueDepth) then
+      @deepestValueDepth = node.valueDepth
+      @deepestValueDepthNode = node
+    end
+  end
+end

data/spec/constant_lca_spec.rb

@@ -0,0 +1,27 @@
+require 'rspec'
+require_relative '../lib/data/string_data_source'
+require_relative '../lib/suffix_tree'
+require_relative '../lib/visitor/dfs'
+require_relative '../lib/visitor/numbering_visitor'
+
+describe 'Preprocesses suffix tree to allow constant time least-common-ancestor' do
+
+  let (:dataSource) { StringDataSource.new("mississippi$") }
+
+  it 'should find least-common-ancestor of any two leaf' do
+    st = SuffixTree.new
+    st.addDataSource(dataSource)
+    dfs = OrderedDFS.new(NumberingVisitor.new)
+    dfs.traverse(st.root)
+    dfs = OrderedDFS.new(RunDefiningVisitor.new)
+    dfs.traverse(st.root)
+    dfs = DFS.new(RunBitVisitor.new(st.root))
+    dfs.traverse(st.root)
+    leafNodeCollector = LeafNodeCollector.new
+    dfs = DFS.new(leafNodeCollector)
+    dfs.traverse(st.root)
+    leafNodeCollector.suffixToLeaf.keys.sort.each do |key|
+      print "#{key} #{leafNodeCollector.suffixToLeaf[key].dfsNumber}\n"
+    end
+  end
+end

data/spec/data_source_spec.rb

@@ -0,0 +1,51 @@
+require 'rspec'
+require_relative '../lib/data/file_data_source'
+require_relative '../lib/data/string_data_source'
+require_relative '../lib/data/word_data_source'
+
+describe 'reads data sources' do
+
+  describe 'WordDataSource' do
+    it "should read words" do
+      wordDataSource = WordDataSource.new(File.join('spec', 'fixtures', "singlePara.txt"))
+      expect(wordDataSource.valueAt(0)).to eq "i"
+      expect(wordDataSource.valueAt(1)).to eq "was"
+      expect(wordDataSource.valueAt(2)).to eq "born"
+      expect(wordDataSource.valueAt(8)).to eq "angora"
+      expect(wordDataSource.valueAt(16)).to eq "silky-haired"
+      expect(wordDataSource.valueAt(19)).to eq "goats"
+    end
+  end
+
+  describe "#extendWith on a StringDataSource" do
+    it "allows a data source to be extended with another" do
+      # this is used for making generalized suffix tree from multiple data sources
+      # we need ability to treat them as belonging to one large data source
+      sd1 = StringDataSource.new "abc"
+      sd2 = StringDataSource.new "def"
+      sd1.extendWith(sd2, 3)
+      expect(sd1.valueAt(0)).to eq "a"
+      expect(sd1.valueAt(1)).to eq "b"
+      expect(sd1.valueAt(2)).to eq "c"
+      val = sd1.valueAt(3)
+      expect(sd1.valueAt(3)).to eq "d"
+      expect(sd1.valueAt(4)).to eq "e"
+      expect(sd1.valueAt(5)).to eq "f"
+      expect(sd1.valueAt(6)).to eq nil
+    end
+  end
+
+  describe "#extendWith on a FileDataSource" do
+    it "allows file data sources to be extended" do
+      fd1 = FileDataSource.new(File.join('spec', 'fixtures', "mississippi.txt"))
+      fd2 = FileDataSource.new(File.join('spec', 'fixtures', "arizona.txt"))
+      fd1.extendWith(fd2, 11)
+      expect(fd1.valueAt(2)).to eq "s"
+      expect(fd1.valueAt(10)).to eq "i"
+      expect(fd1.valueAt(11)).to eq "a"
+      expect(fd1.valueAt(12)).to eq "r"
+      expect(fd1.valueAt(17)).to eq "a"
+      expect(fd1.valueAt(18)).to eq nil
+    end
+  end
+end

data/spec/fixtures/arizona.txt

@@ -0,0 +1 @@
+arizona