Module: TraceVisualization::Repetitions::Incrementation

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

Create repetition



68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/trace_visualization/repetitions/incrementation.rb', line 68

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

Create fake repetition



84
85
86
 
# File 'lib/trace_visualization/repetitions/incrementation.rb', line 84

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

.process(context, options = {}) ⇒ Object

Process



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
59
60
61
62
63
64
65
 
# File 'lib/trace_visualization/repetitions/incrementation.rb', line 8

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