trace_visualization 0.0.3 → 0.0.5

data/lib/trace_visualization/repetitions/concatenation.rb

@@ -0,0 +1,136 @@
+require 'trace_visualization'
+
+module TraceVisualization
+  module Repetitions
+    module Concatenation
+
+      def self.process(context, options = {})
+        Utils.set_default_options(options, { :positions_min_size => 3, :k => 3 })
+        k = options[:k]
+        
+        result = []
+  
+        useful_cnt = 0
+
+        pairs_cnt = {}
+        context.repetitions_by_line.each do |item|
+          for i in 0 ... item.size
+            for j in i + 1 ... item.size
+              left, right = item[i][0], item[j][0]
+              delta = k - left.k - right.k
+
+              next if not concat_condition(left, right, delta, options[:positions_min_size])
+
+              key = (left.id << 32) + right.id
+              val = (pairs_cnt[key] || 0) + 1
+              pairs_cnt[key] = val
+              next if val != options[:positions_min_size]
+
+              lps, rps = process_common_positions(left, right, delta, context)
+      
+              if lps.size >= options[:positions_min_size]
+                result << create_repetition(left, right, delta, lps, rps)
+              end
+      
+              useful_cnt += 1        
+            end
+          end
+        end
+  
+        options[:counter] << [k, useful_cnt] if options[:counter]
+  
+        process_new_repetitions(result, context)
+  
+        context.repetitions.concat(result)
+      end
+
+      def self.process_new_repetitions(new_repetitions, context)
+        context.init_repetitions_by_line(new_repetitions)
+      end
+
+      def self.process_full_search(rs, k, context, options = {})
+        opts = {
+          :positions_min_size => 3
+        }.merge options
+  
+        result = []
+  
+        useful_cnt = 0
+
+        for left in rs
+          for right in rs
+            delta = k - left.k - right.k
+            next if not concat_condition(left, right, delta, options[:positions_min_size])
+      
+            # @@processed_path.add(key(left, right, delta))  
+      
+            lps, rps = process_common_positions(left, right, delta, context)
+      
+            if lps.size >= options[:positions_min_size]
+              result << create_repetition(left, right, delta, lps, rps)
+            end
+      
+            useful_cnt += 1
+          end
+        end
+
+        puts "Total: #{rs.size ** 2} #{useful_cnt} #{result.size}"
+  
+        rs.concat(result)
+      end
+
+      # Condition for potential concatenation
+      def self.concat_condition(left, right, delta, positions_min_size)
+        delta >= 0 && left.id != right.id && 
+          left.positions_size  >= positions_min_size && 
+          right.positions_size >= positions_min_size
+      end
+
+      # *Attention* Position arrays are modified in place which can lead to side 
+      # effects. Don't send left == right!
+      def self.process_common_positions(left, right, delta, context)
+        lr_pos = left.left_positions
+        lr_pos.collect! { |pos| pos + left.length + delta }
+
+        rr_pos = right.left_positions
+  
+        cpr = lr_pos & rr_pos
+        cpl = cpr.collect { |pos| pos - left.length - delta }
+  
+        idx = 0
+        while idx < cpr.size
+          xxx = context.mapping[cpl[idx] + left.length ... cpr[idx]]
+          xxx = xxx.join if xxx.instance_of? Array
+          if xxx.scan(TraceVisualization::FORBIDDEN_CHARS).size != 0
+            cpr.delete_at(idx)
+            cpl.delete_at(idx)
+          else
+            idx += 1
+          end
+        end
+
+        lr_pos.collect! { |lpos| lpos - left.length - delta }
+      
+        [cpl, cpr]
+      end
+
+      # Create repetition
+      # @param left [TraceVisualization::Repetition] left parent
+      # @param right [TraceVisualization::Repetition] right parent
+      # @param delta
+      # @param lps
+      # @param rps
+      def self.create_repetition(left, right, delta, lps, rps)
+        r = left.class.new(left.length + right.length + delta, lps, rps)
+
+        r.k          = left.k + right.k + delta
+        r.pcount     = left.pcount + right.pcount
+        r.left       = left
+        r.right      = right
+        r.strict_ids = left.strict_ids + right.strict_ids
+
+        r
+      end
+    end
+  end
+end

data/lib/trace_visualization/repetitions/context.rb

@@ -0,0 +1,70 @@
+require 'trace_visualization/utils'
+
+module TraceVisualization
+  module Repetitions
+    class Context
+      attr_accessor :mapping, :repetitions, :repetitions_by_line, :hashes
+      
+      def initialize mapping
+        @mapping = mapping
+        @repetitions_by_line = Array.new(@mapping.lines.size) { [] }
+        @hashes = []
+      end
+      
+      def repetitions=(repetitions)
+        @repetitions = repetitions
+        init_repetitions_by_line(repetitions)
+      end
+      
+      def lines
+        @mapping.lines
+      end
+      
+      def init_repetitions_by_line(new_repetitions)
+        for r in new_repetitions
+          r_pos = r.left_positions
+          r.lines.clear
+          i, j = 0, 0
+      
+          while (i < @mapping.lines.size && j < r_pos.size)
+            a, b = @mapping.lines[i], (i + 1 < @mapping.lines.size ? @mapping.lines[i + 1] : 2**32)
+        
+            if a <= r_pos[j] && r_pos[j] < b
+              @repetitions_by_line[i] << [r, r_pos[j]]
+              r.lines << i
+          
+              j += 1
+            else
+              i += 1
+            end        
+          end
+        end
+
+        @repetitions_by_line.each { |item| item.sort! { |a, b| a[1] <=> b[1] } }
+      end
+      
+      def delete_repetition(repetition)
+        repetition.lines.each do |line|
+          @repetitions_by_line[line].delete_if { |item| item[0].id == repetition.id }
+        end
+      end
+      
+      def merge_repetitions(x, y)
+        x.left_positions.concat(y.left_positions).uniq!.sort!
+        
+        if x.right_positions
+          x.right_positions.concat(y.right_positions).uniq!.sort!
+        end
+        
+        y.lines.each do |line|
+          for i in 0 ... @repetitions_by_line[line].size
+            if @repetitions_by_line[line][i][0].id == y.id
+              @repetitions_by_line[line][i][0] = x
+              x.lines << line unless x.lines.index line
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trace_visualization/repetitions/filter.rb

@@ -0,0 +1,153 @@
+require 'trace_visualization/utils'
+require 'trace_visualization/repetitions/concatenation'
+
+module TraceVisualization
+  module Repetitions
+    module Filter
+
+      # Filter for strict repetitions
+      def self.strict_repetitions_filter(str, context, options = {})
+        Utils.set_default_options(options, { :positions_min_size => 3 })
+    
+        repetitions_filter(str, context, options)
+        split(str, context)
+        merge(context)
+      end
+  
+      # Filter repetitions
+      def self.repetitions_filter(str, context, options = {})
+        Utils.set_default_options(options, { :positions_min_size => 3 })
+    
+        context.repetitions.delete_if do |repetition| 
+          flag = repetition.positions_size < options[:positions_min_size] 
+      
+          context.delete_repetition(repetition) if flag
+      
+          flag
+        end
+    
+        fix_boundaries(str, context.repetitions)
+        delete_duplicates(context)
+      end
+  
+      # Filter repetitions: Boundaries
+      # * Change repetitions with '\n' at the beginning or end  
+      def self.fix_boundaries(str, rs)
+        rs.each do |r|
+          if str[r.get_left_pos(0)].to_str == "\n" && r.length > 1
+            for i in 0 ... r.positions_size
+              r.set_left_pos(i, r.get_left_pos(i) + 1)
+            end
+            r.length -= 1
+          end
+      
+          if str[r.get_left_pos(0) + r.length - 1].to_str == "\n"
+            r.length -= 1
+          end
+        end    
+      end
+  
+      # Filter repetitions: Split
+      # * Split repetitions with '\n' at the center 
+      # * Delete duplicate after split (one repeat a subset of the other)
+      #
+      # *NB* It has meaning only for the strict repetitions, approximate 
+      # repetitions doesn't consist '\n'
+      def self.split(str, context)
+        splitted = []
+        context.repetitions.delete_if do |r|
+          pos = nil
+          
+          for i in r.get_left_pos(0) ... r.get_left_pos(0) + r.length
+            if str[i].to_str == "\n"
+              pos = i
+              break
+            end
+          end
+          
+          if pos != nil
+            # right part of split
+            if r.length - pos - 1 >= 2
+              length = r.length - pos - 1
+              positions = (0 ... r.positions_size).collect { |i| r.get_left_pos(i) + pos + 1}
+          
+              nr = r.class.new(length, positions)
+          
+              splitted << nr
+            end
+        
+            # left part of split
+            if pos >= 2
+              r.length = pos
+              splitted << r
+            end
+          end
+      
+          context.delete_repetition(r) if pos != nil
+      
+          (pos != nil)
+        end
+    
+        splitted.delete_if do |r|
+          flag = false
+
+          context.repetitions.each do |x|
+            flag = ((x.left_positions & r.left_positions).size == r.left_positions.size && x.length >= r.length)
+            break if flag
+          end
+
+          flag
+        end
+
+        Concatenation.process_new_repetitions(splitted, context)
+    
+        context.repetitions.concat(splitted)
+      end
+  
+      # Filter repetitions: delete duplicate
+      def self.delete_duplicates(context)
+        i = 0
+        while i < context.repetitions.size
+          j = i + 1
+          while j < context.repetitions.size
+            if context.repetitions[i] == context.repetitions[j]
+              context.delete_repetition(context.repetitions[j])
+              context.repetitions.delete_at(j)
+            else
+              j += 1
+            end        
+          end
+          i += 1
+        end
+      end
+      
+      # Merge repetitions with common positions
+      def self.merge(context)
+        i = 0
+        while i < context.repetitions.size
+          j = 0
+          while j < context.repetitions.size
+            
+            if i != j
+              x, y = context.repetitions[i], context.repetitions[j]
+              if x.length == y.length && x.k == y.k
+                common_positions = x.left_positions & y.left_positions
+                if common_positions.size == y.left_positions.size
+                  context.delete_repetition(y)
+                  context.repetitions.delete_at(j) 
+                elsif common_positions.size > 0
+                  context.merge_repetitions(x, y)
+                  context.repetitions.delete_at(j)
+                end
+              end
+            end
+            
+            j += 1
+          end
+          i += 1
+        end
+      end
+
+    end # Filter
+  end # Repetitions
+end # TraceVisualization

data/lib/trace_visualization/repetitions/incrementation.rb

@@ -0,0 +1,89 @@
+require 'trace_visualization'
+
+module TraceVisualization
+  module Repetitions
+    module Incrementation
+      
+      # Process
+      def self.process(context, options = {})
+        Utils.set_default_options(options, { 
+          :k => 1, :common_positions_size => 2
+        })
+
+        k = options[:k]
+        repetitions = context.repetitions
+        
+        result = []
+
+        for core in repetitions
+          next if core.k != 0
+      
+          # Positions for Right Incrementation
+          positions_ri = []
+      
+          # Positions for Left Incrementation
+          positions_li = []
+      
+          for r in repetitions
+            next if r == core || core.length + k != r.length
+        
+            clps, rlps = core.left_positions, r.left_positions
+        
+            common_positions_ri = clps & rlps
+            common_positions_li = clps.collect { |p| p - k } & rlps
+                              
+            positions_ri |= common_positions_ri if common_positions_ri.size >= options[:common_positions_size]
+            positions_li |= common_positions_li if common_positions_li.size >= options[:common_positions_size]
+          end
+      
+          if positions_ri.size > 1
+            left_positions  = positions_ri.sort
+            right_positions = left_positions.collect { |pos| pos + core.length + k }
+        
+            hash = TraceVisualization::Utils.rhash(left_positions, right_positions)
+        
+            unless context.hashes.include? hash
+              context.hashes << hash
+              result << create_repetition(core, k, left_positions, right_positions, "right")
+            end
+          end
+      
+          if positions_li.size > 1
+            left_positions  = positions_li.sort
+            right_positions = left_positions.collect { |pos| pos + k}
+        
+            hash = TraceVisualization::Utils.rhash(left_positions, right_positions)
+        
+            unless context.hashes.include? hash
+              context.hashes << hash
+              result << create_repetition(core, k, left_positions, right_positions, "left")
+            end
+          end
+        end
+
+        context.repetitions.concat(result)
+      end
+
+      # Create repetition
+      def self.create_repetition(core, k, left_positions, right_positions, type)
+        repetition = core.class.new(core.length + k, left_positions, right_positions)
+        repetition.k = k
+
+        fake = fake_repetition(core.class, left_positions, right_positions, type)
+
+        if type == "left"
+          repetition.left, repetition.right = fake, core
+        else
+          repetition.left, repetition.right = core, fake
+        end
+
+        repetition
+      end
+
+      # Create fake repetition
+      def self.fake_repetition(cls, left_positions, right_positions, type)
+        cls.new(0, type == "left" ? left_positions : right_positions)
+      end
+    end
+  end
+end