Module: TraceVisualization::RepetitionsIncrementation

Defined in:
lib/trace_visualization/repetitions_incrementation.rb

Class Method Summary collapse

Class Method Details

.create_repetition(core, k, left_positions, right_positions, type) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/trace_visualization/repetitions_incrementation.rb', line 61

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

.fake_repetition(cls, left_positions, right_positions, type) ⇒ Object 



77
78
79
 
# File 'lib/trace_visualization/repetitions_incrementation.rb', line 77

def self.fake_repetition(cls, left_positions, right_positions, type)
  cls.new(0, type == "left" ? left_positions : right_positions)
end

.incrementation(str, repetitions, hashes, k) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/trace_visualization/repetitions_incrementation.rb', line 7

def self.incrementation(str, repetitions, hashes, k)
  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 = core.left_positions
      rlps = 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 > 2
      positions_li |= common_positions_li if common_positions_li.size > 2        
    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)
    
      if (not hashes.include? hash)
        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)
    
      if (not hashes.include? hash)
        hashes << hash
        result << create_repetition(core, k, left_positions, right_positions, "left")
      end
    end
  end

  repetitions.concat(result)
end