stamina-core 0.5.0

data/lib/stamina-core/stamina/automaton/complement.rb

@@ -0,0 +1,26 @@
+module Stamina
+  class Automaton
+
+    #
+    # Returns the complement automaton.
+    #
+    # A complement automaton is simply a complete automaton with all state
+    # labels flipped.
+    #
+    def complement
+      dup.complement!
+    end
+
+    #
+    # Complements this automaton
+    #
+    def complement!
+      complete!
+      each_state do |s|
+        s[:accepting] = !s.accepting?
+      end
+      self
+    end
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/complete.rb

@@ -0,0 +1,36 @@
+module Stamina
+  class Automaton
+
+    #
+    # Checks if this automaton is complete
+    #
+    def complete?
+      alph = alphabet
+      states.find{|s| !(alphabet - s.out_symbols).empty?}.nil?
+    end
+
+    #
+    # Returns a completed copy of this automaton
+    #
+    def complete
+      self.dup.complete!
+    end
+
+    #
+    # Completes this automaton.
+    #
+    def complete!(sink_data = {:initial => false, :accepting => false, :error => false})
+      alph = alphabet
+      sink = add_state(sink_data)
+      each_state do |s|
+        out_symbols = s.out_symbols
+        (alph-out_symbols).each do |symbol|
+          connect(s, sink, symbol)
+        end
+      end
+      drop_state(sink) if sink.adjacent_states == [sink]
+      self
+    end
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/compose.rb

@@ -0,0 +1,111 @@
+module Stamina
+  class Automaton
+    class Compose
+
+      # Automata under composition
+      attr_reader :automata
+
+      def initialize(automata)
+        @automata = automata.collect{|a|
+          a.deterministic? ? a : a.determinize
+        }
+      end
+
+      def marks(compound, initial = false)
+        {:initial   => initial,
+         :accepting => compound.all?{|s| s.accepting?},
+         :error     => compound.any?{|s| s.error?}
+        }
+      end
+
+      def main
+        # Map every symbol to concerned automata
+        symbols = Hash.new{|h,k| h[k] = []}
+
+        # The compound initial state
+        init = []
+
+        # Build the symbol table and prepare the initial state
+        automata.each_with_index do |fa,i|
+          fa.alphabet.each{|l| symbols[l][i] = fa}
+          init << fa.initial_state
+        end
+
+        # Compound automaton and states already seen
+        compound_fa = Automaton.new
+        map = {init => compound_fa.add_state(marks(init, true))}
+
+        # States to be visited
+        to_visit = [init]
+
+        until to_visit.empty?
+          source = to_visit.pop
+          symbols.each_pair do |symbol, automata|
+            catch(:avoid) do
+              # build the target state
+              target = source.zip(automata).collect{|ss,a|
+                if a.nil?
+                  # this automaton does no synchronize on symbol
+                  ss
+                elsif tt = ss.dfa_delta(symbol)
+                  # it synchronizes and target has been found
+                  tt
+                else
+                  # it synchronizes but target has not been found
+                  throw :avoid
+                end
+              }
+              unless map.has_key?(target)
+                map[target] = compound_fa.add_state(marks(target))
+                to_visit << target
+              end
+              compound_fa.connect(map[source],map[target],symbol)
+            end
+          end
+        end # to_visit.empty?
+
+        compound_fa
+      end
+
+      def self.execute(automata)
+        Compose.new(automata).main
+      end
+
+    end # class Compose
+
+    def compose(*automata)
+      Automaton::Compose.execute([self] + automata)
+    end
+
+  end # class Automaton
+end # module Stamina
+
+#      class CompoundState
+#        include Enumerable
+#        attr_reader   :states
+#
+#        def initialize(states)
+#          @states = states
+#        end
+#
+#        def hash
+#          states.hash
+#        end
+#
+#        def ==(other)
+#          other.states == states
+#        end
+#        alias :eql? :other
+#
+#        def marks(initial = false)
+#          {:initial   => initial,
+#           :accepting => states.all?{|s| s.accepting?},
+#           :error     => states.any?{|s| s.error?}
+#          }
+#        end
+#
+#        def each
+#          states.each &Proc.new
+#        end
+#
+#      end

data/lib/stamina-core/stamina/automaton/determinize.rb

@@ -0,0 +1,104 @@
+module Stamina
+  class Automaton
+    class Determinize
+
+      class CompoundState
+
+        attr_reader :fa
+        attr_reader :states
+        attr_reader :initial
+
+        def initialize(fa, states, initial = false)
+          @fa = fa
+          @states = states.sort
+          @initial = initial
+        end
+
+        def empty?
+          states.empty?
+        end
+
+        def marks
+          @marks ||= begin
+            marks = {}
+            marks[:initial] = initial
+            marks[:accepting] = states.any?{|s| s.accepting?}
+            marks[:error] = states.any?{|s| s.error?}
+            marks
+          end
+        end
+
+        def delta(symbol)
+          CompoundState.new(fa, fa.delta(states, symbol))
+        end
+
+        def hash
+          @states.hash
+        end
+
+        def ==(other)
+          other.is_a?(CompoundState) &&
+          (other.fa == self.fa) &&
+          (other.states == self.states)
+        end
+        alias :eql? :==
+
+      end # class CompoundState
+
+      attr_reader :fa
+      attr_reader :options
+
+      def initialize(fa, options)
+        @fa = fa
+        @options = options
+      end
+
+      def main
+        # the alphabet
+        alph = fa.alphabet
+
+        # the minimized automaton
+        minimized = Automaton.new
+
+        # - map between compound states and minimized states
+        # - states to visit
+        map = {}
+        to_visit = []
+
+        # initial state and mark as to visit
+        init = CompoundState.new(fa, fa.initial_states, true)
+        map[init] = minimized.add_state(init.marks)
+        to_visit  = [init]
+
+        until to_visit.empty?
+          current = to_visit.pop
+          alph.each do |symbol|
+            found = current.delta(symbol)
+            next if found.empty?
+            unless map.has_key?(found)
+              map[found] = minimized.add_state(found.marks)
+              to_visit << found
+            end
+            minimized.connect(map[current], map[found], symbol)
+          end
+        end
+
+        minimized
+      end
+
+      def self.execute(fa, options = {})
+        Determinize.new(fa, options).main
+      end
+
+    end # class Determinize
+
+    #
+    # Determinizes this automaton by removing explicit non-determinism as well
+    # as all espilon moves.
+    #
+    def determinize
+      Determinize.execute(self)
+    end
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/equivalence.rb

@@ -0,0 +1,57 @@
+module Stamina
+  class Automaton
+
+    #
+    # Checks if this automaton is equivalent to another one.
+    #
+    # Automata must be both minimal and complete to guarantee that this method
+    # works.
+    #
+    def equivalent?(other, equiv = nil, key = :equiv_state)
+      equiv ||= Proc.new{|s1,s2| (s1 && s2) &&
+                                 (s1.accepting? == s2.accepting?) &&
+                                 (s1.error? == s2.error?) &&
+                                 (s1.initial? == s2.initial?) }
+
+      # Both must already have basic attributes in common
+      return false unless state_count==other.state_count
+      return false unless edge_count==other.edge_count
+      return false unless alphabet==other.alphabet
+      return false unless equiv[initial_state, other.initial_state]
+
+      # We instantiate the decoration algorithm for checking equivalence on this
+      # automaton:
+      #   * decoration is the index of the equivalent state in other automaton
+      #   * d0 is thus 'other.initial_state.index'
+      #   * suppremum is identity and fails when the equivalent state is not unique
+      #   * propagation checks transition function delta
+      #
+      algo = Stamina::Utils::Decorate.new(key)
+      algo.set_suppremum do |d0, d1|
+        if (d0.nil? or d1.nil?)
+           (d0 || d1)
+        elsif d0==d1
+          d0
+        else
+          raise Stamina::Abord
+        end
+      end
+      algo.set_propagate do |d,e|
+        reached = other.ith_state(d).dfa_step(e.symbol)
+        raise Stamina::Abord if reached.nil?
+        raise Stamina::Abord unless equiv[e.target, reached]
+        reached.index
+      end
+
+      # Run the algorithm now
+      begin
+        algo.execute(self, nil, other.initial_state.index)
+        return true
+      rescue Stamina::Abord
+        return false
+      end
+    end
+    alias :<=> :equivalent?
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/hide.rb

@@ -0,0 +1,41 @@
+module Stamina
+  class Automaton
+
+    #
+    # Returns a copy of self where all symbols in `alph` have been
+    # replaced by nil.
+    #
+    def hide(alph)
+      dup.hide!(alph)
+    end
+
+    #
+    # Replaces all symbols in `alph` by nil in this automaton.
+    #
+    def hide!(alph)
+      new_alph = alphabet.to_a - alph.to_a
+      h = Set.new(new_alph.to_a)
+      each_edge do |edge|
+        edge.symbol = nil unless h.include?(edge.symbol)
+      end
+      self.alphabet = new_alph
+      self
+    end
+
+    #
+    # Returns a copy of self where all symbols not in `alph` have been
+    # replaced by nil.
+    #
+    def keep(alph)
+      dup.keep!(alph)
+    end
+
+    #
+    # Replaces all symbols not in `alph` by nil in this automaton.
+    #
+    def keep!(alph)
+      hide!(self.alphabet.to_a - alph.to_a)
+    end
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina-core/stamina/automaton/metrics.rb

@@ -0,0 +1,77 @@
+module Stamina
+  class Automaton
+    #
+    # Provides useful metric methods on automata.
+    #
+    # This module is automatically included by Automaton and is not intended
+    # to be used directly.
+    #
+    module Metrics
+
+      #
+      # Returns the number of letters of the alphabet.
+      #
+      def alphabet_size
+        alphabet.size
+      end
+
+      #
+      # Returns the average degree of states, that is,
+      # <code>edge_count/state_count</code>
+      #
+      def avg_degree
+        edge_count.to_f/state_count.to_f
+      end
+      alias :avg_out_degree :avg_degree
+      alias :avg_in_degree :avg_degree
+
+      #
+      # Number of accepting states over all states
+      #
+      def accepting_ratio
+        states.select{|s|s.accepting?}.size.to_f/state_count.to_f
+      end
+
+      #
+      # Number of error states over all states
+      #
+      def error_ratio
+        states.select{|s|s.error?}.size.to_f/state_count.to_f
+      end
+
+      #
+      # Computes the depth of the automaton.
+      #
+      # The depth of an automaton is defined as the length of the longest shortest
+      # path from the initial state to a state.
+      #
+      # This method has a side effect on state marks, as it keeps the depth of
+      # each state as a mark under _key_, which defaults to :depth.
+      #
+      def depth(key = :depth)
+        algo = Stamina::Utils::Decorate.new(key)
+        algo.set_suppremum do |d0,d1|
+          # Here, unreached state has the max value (i.e. nil is +INF)
+          # and we look at the minimum depth for each state
+          if d0.nil?
+            d1
+          elsif d1.nil?
+            d0
+          else
+            (d0 <= d1 ? d0 : d1)
+          end
+        end
+        algo.set_propagate {|d,e| d+1 }
+        algo.execute(self, nil, 0)
+        deepest = states.max do |s0,s1|
+          # Here, we do not take unreachable states into account
+          # so that -1 is taken when nil is encountered
+          (s0[:depth] || -1) <=> (s1[:depth] || -1)
+        end
+        deepest[:depth]
+      end
+
+    end # module Metrics
+    include Metrics
+  end # class Automaton
+end # module Stamina