Class: Stamina::TransitionSystem::Equivalence

Inherits:
Object
  • Object
show all
Defined in:
lib/stamina-core/stamina/transition_system/equivalence.rb

Direct Known Subclasses

Automaton::Equivalence

Defined Under Namespace

Classes: EquivThroughDeco

Instance Method Summary collapse

Instance Method Details

#call(ts1, ts2, &explain) ⇒ Object

Executes the equivalence algorithm on two transition systems ‘ts1` and `ts2`. Returns true if they are considered equivalent, false otherwise.



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 86

def call(ts1, ts2, &explain)
  @explain = explain
  catch(:fail) do
    equivalent_systems!(ts1, ts2)
    i1, i2 = ts1.initial_state, ts2.initial_state
    fail "No initial state on ts1" unless i1
    fail "No initial state on ts2" unless i2
    equivalent_states!(i1, i2)
    mapping = {}
    EquivThroughDeco.new(ts2, self).call(ts1, mapping)
    return !mapping.any?{|k,v| v.nil?}
  end
  return false
ensure
  @explain = nil
end

#equivalent_edges!(s, t) ⇒ Object 



32
33
34
35
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 32

def equivalent_edges!(s, t)
  fail "Non equivalent edges `#{s}` and `#{t}`" unless equivalent_edges?(s,t)
  true
end

#equivalent_edges?(e, f) ⇒ Boolean

Returns true if ‘e` and `f` must be considered equivalent, false otherwise.

Returns:

  • (Boolean) 


28
29
30
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 28

def equivalent_edges?(e, f)
  e.raw_data == f.raw_data
end

#equivalent_states!(s, t) ⇒ Object 



22
23
24
25
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 22

def equivalent_states!(s, t)
  fail "Non equivalent states `#{s}` and `#{t}`" unless equivalent_states?(s,t)
  true
end

#equivalent_states?(s, t) ⇒ Boolean

Returns true if ‘s` and `t` must be considered equivalent, false otherwise.

Returns:

  • (Boolean) 


18
19
20
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 18

def equivalent_states?(s, t)
  s.raw_data == t.raw_data
end

#equivalent_systems!(s, t) ⇒ Object 



12
13
14
15
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 12

def equivalent_systems!(s, t)
  fail "Non equivalent systems `#{s}` and `#{t}`" unless equivalent_systems?(s,t)
  true
end

#equivalent_systems?(s, t) ⇒ Boolean

Returns true if ‘s` and `t` must be considered equivalent, false otherwise.

Returns:

  • (Boolean) 


6
7
8
9
10
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 6

def equivalent_systems?(s, t)
  (s.state_count == t.state_count) &&
  (s.edge_count  == t.edge_count)  &&
  (s.raw_data    == t.raw_data)
end

#fail(message) ⇒ Object 



103
104
105
106
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 103

def fail(message)
  @explain.call(message) if @explain
  throw :fail
end

#find_edge_counterpart(reference_state, operand_edge) ⇒ Object

Finds the edge counterpart of ‘operand_edge` as an outgoing edge of `reference_state`. The default implementation takes an edge that shares the same symbol as operand_edge.



40
41
42
43
 
# File 'lib/stamina-core/stamina/transition_system/equivalence.rb', line 40

def find_edge_counterpart(reference_state, operand_edge)
  symbol = operand_edge.symbol
  reference_state.out_edges.find{|e| e.symbol==symbol}
end