stamina 0.3.1 → 0.4.0

data/lib/stamina/automaton/metrics.rb

@@ -52,6 +52,8 @@ module Stamina
       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?
@@ -62,7 +64,12 @@ module Stamina
         end
         algo.set_propagate {|d,e| d+1 }
         algo.execute(self, nil, 0)
-        states.max{|s0,s1| s0[:depth] <=> s1[:depth]}[:depth]
+        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

data/lib/stamina/automaton/minimize.rb

@@ -0,0 +1,25 @@
+module Stamina
+  class Automaton
+    
+    #
+    # Checks if this automaton is minimal.
+    #
+    def minimal?
+      self.minimize <=> self.complete
+    end
+      
+    #
+    # Returns a minimized version of this automaton.
+    #
+    # This method should only be called on deterministic automata.
+    #
+    def minimize(options = {})
+      Minimize::Hopcroft.execute(self, options)
+    end
+
+
+  end # class Automaton
+end # module Stamina
+require 'stamina/automaton/minimize/hopcroft'
+require 'stamina/automaton/minimize/pitchies'
+

data/lib/stamina/automaton/minimize/hopcroft.rb

@@ -0,0 +1,116 @@
+module Stamina
+  class Automaton
+    module Minimize
+      class Hopcroft
+
+        # Creates an algorithm instance
+        def initialize(automaton, options)
+          raise ArgumentError, "Deterministic automaton expected", caller unless automaton.deterministic?
+          @automaton = automaton
+        end
+        
+        # Compute a Hash {symbol => state_group} from a group of states
+        def reverse_delta(group)
+          h = Hash.new{|h,k| h[k]=Set.new}
+          group.each do |state|
+            state.in_edges.each do |edge|
+              h[edge.symbol] << edge.source
+            end
+          end
+          h
+        end
+        
+        # Computes a minimal dfa from the grouping information
+        def compute_minimal_dfa(groups)
+          indexes = []
+          Automaton.new do |fa|
+
+            # create one state for each group
+            groups.each_with_index do |group,index|
+              group.each{|s| indexes[s.index] = index}
+              data = group.inject(nil) do |memo,s|
+                if memo.nil?
+                  s.data
+                else
+                  {:initial   => memo[:initial]   || s.initial?,
+                   :accepting => memo[:accepting] || s.accepting?,
+                   :error     => memo[:error]     || s.error?}
+                end
+              end
+              fa.add_state(data)
+            end
+
+            # connect transitions now
+            groups.each_with_index do |group,index|
+              group.each do |s|
+                s_index = indexes[s.index]
+                s.out_edges.each do |edge|
+                  symbol, t_index = edge.symbol, indexes[edge.target.index]
+                  unless fa.ith_state(s_index).dfa_step(symbol)
+                    fa.connect(s_index, t_index, symbol)
+                  end
+                end
+              end
+            end
+
+          end
+        end
+        
+        # Computes the initial partition
+        def initial_partition
+          p = [Set.new, Set.new]
+          @automaton.states.each do |s|
+            (s.accepting? ? p[0] : p[1]) << s
+          end
+          p.reject{|g| g.empty?}
+        end
+        
+        # Main method of the algorithm
+        def main
+          # Partition states a first time according to accepting/non accepting
+          @partition = initial_partition # P in pseudo code
+          @worklist = @partition.dup     # W in pseudo code
+          
+          # Until a block needs to be refined
+          until @worklist.empty?
+            refined = @worklist.pop
+            
+            # We compute the reverse delta on the group and look at the groups
+            rdelta = reverse_delta(refined)
+            rdelta.each_pair do |symbol, sources| # sources is la in pseudo code
+              
+              # Find blocks to be refined
+              @partition.dup.each_with_index do |block, index| # block is R in pseudo code
+                next if block.subset?(sources)
+                intersection = block & sources    # R1 in pseudo code
+                next if intersection.empty?
+                difference = block - intersection # R2 in pseudo code
+                
+                # replace R in P with R1 and R2
+                @partition[index] = intersection
+                @partition << difference
+                
+                # Adds the new blocks as to be refined
+                if @worklist.include?(block)
+                  @worklist.delete(block)
+                  @worklist << intersection << difference
+                else
+                  @worklist << (intersection.size <= difference.size ? intersection : difference)
+                end
+              end # @partition.each
+              
+            end # rdelta.each_pair
+          end # until @worklist.empty?
+          
+          compute_minimal_dfa(@partition)
+        end # def main
+        
+        # Execute the minimizer
+        def self.execute(automaton, options={})
+          Hopcroft.new(automaton.strip.complete!, options).main
+        end
+      
+      end # class Hopcroft
+    end # module Minimize
+  end # class Automaton
+end # module Stamina

data/lib/stamina/automaton/minimize/pitchies.rb

@@ -0,0 +1,64 @@
+module Stamina
+  class Automaton
+    module Minimize
+      class Pitchies
+
+        # Creates an algorithm instance
+        def initialize(automaton, options)
+          raise ArgumentError, "Deterministic automaton expected", caller unless automaton.deterministic?
+          @automaton = automaton
+        end
+        
+        def minimized_dfa(oldfa, nb_states, partition)
+          Automaton.new(false) do |newfa| 
+            # Add the number of states, with default marks
+            newfa.add_n_states(nb_states, {:initial => false, :accepting => false, :error => false})
+
+            # Refine the marks using the source dfa as reference
+            partition.each_with_index do |block, state_index| 
+              source = oldfa.ith_state(state_index)
+              target = newfa.ith_state(block)
+              target.initial!   if source.initial?
+              target.accepting! if source.accepting?
+              target.error!     if source.error?
+            end
+
+            # Now, create the transitions
+            partition.each_with_index do |block, state_index|
+              source = oldfa.ith_state(state_index)
+              target = newfa.ith_state(block)
+              source.out_edges.each do |edge|
+                where = partition[edge.target.index]
+                if target.dfa_step(edge.symbol) == nil
+                  newfa.connect(target, where, edge.symbol)
+                end
+              end
+            end
+          end
+        end
+
+        def main
+          alph, states = @automaton.alphabet, @automaton.states
+          old_nb_states = -1
+          partition = states.collect{|s| s.accepting? ? 1 : 0}
+          until (nb_states = partition.uniq.size) == old_nb_states
+            old_nb_states = nb_states
+            alph.each do |symbol|
+              reached = states.collect{|s| partition[s.dfa_step(symbol).index]}
+              rehash = Hash.new{|h,k| h[k] = h.size}
+              partition = partition.zip(reached).collect{|pair| rehash[pair]}
+            end
+          end
+          minimized_dfa(@automaton, nb_states, partition)
+        end
+
+        # Execute the minimizer
+        def self.execute(automaton, options={})
+          Pitchies.new(automaton.strip.complete!, options).main
+        end
+      
+      end # class Pitchies
+    end # module Minimize
+  end # class Automaton
+end # module Stamina
+

data/lib/stamina/automaton/strip.rb

@@ -0,0 +1,16 @@
+module Stamina
+  class Automaton
+
+    # Removes unreachable states from the initial ones
+    def strip!
+      depth(:reachable)
+      drop_states(*states.select{|s| s[:reachable].nil?})
+    end
+
+    # Returns a copy of this automaton with unreachable states removed
+    def strip
+      dup.strip!
+    end
+
+  end # class Automaton
+end # module Stamina

data/lib/stamina/automaton/walking.rb

@@ -167,9 +167,13 @@ module Stamina
       # _symbol_. Returns nil (or an empty array, according to the same conventions) 
       # if no such state exists.
       #
-      def dfa_delta(from, symbol) 
-        delta = walking_to_from(from).collect{|s| s.dfa_delta(symbol)}.flatten.uniq
-        walking_to_dfa_result(delta, from)
+      def dfa_delta(from, symbol)
+        if from.is_a?(Automaton::State)
+          from.dfa_delta(symbol)
+        else
+          delta = walking_to_from(from).collect{|s| s.dfa_delta(symbol)}.flatten.uniq
+          walking_to_dfa_result(delta, from)
+        end
       end
     
       #
@@ -219,24 +223,47 @@ module Stamina
 
       # Same as split, respecting dfa conventions.
       def dfa_split(input, from=nil)
-        # the three elements of the triplet
-        parsed = []
-        reached = walking_to_from(from)
-        remaining = walking_to_modifiable_symbols(input)
-    
-        # walk now
-        until remaining.empty?
-          symb = remaining[0]
-          next_reached = dfa_delta(reached, symb)
-      
-          # stop it if no reached state
-          break if next_reached.nil? or next_reached.empty? 
+        from = initial_state if from.nil?
+        from = ith_state(from) if from.is_a?(Integer)
+        if from.is_a?(Automaton::State)
+          # the three elements of the triplet
+          parsed = []
+          reached = from
+          remaining = walking_to_modifiable_symbols(input)
+          
+          # walk now
+          until remaining.empty?
+            symb = remaining[0]
+            next_reached = reached.dfa_delta(symb)
+        
+            # stop it if no reached state
+            break if next_reached.nil?
+        
+            # otherwise, update triplet
+            parsed << remaining.shift
+            reached = next_reached
+          end
+          [parsed, reached, remaining]
+        else
+          # the three elements of the triplet
+          parsed = []
+          reached = walking_to_from(from)
+          remaining = walking_to_modifiable_symbols(input)
       
-          # otherwise, update triplet
-          parsed << remaining.shift
-          reached = next_reached
+          # walk now
+          until remaining.empty?
+            symb = remaining[0]
+            next_reached = dfa_delta(reached, symb)
+        
+            # stop it if no reached state
+            break if next_reached.nil? or next_reached.empty? 
+        
+            # otherwise, update triplet
+            parsed << remaining.shift
+            reached = next_reached
+          end
+          [parsed, walking_to_dfa_result(reached, from), remaining]
         end
-        [parsed, walking_to_dfa_result(reached, from), remaining]
       end
   
       #

data/lib/stamina/command.rb

@@ -0,0 +1,45 @@
+require 'stamina'
+module Stamina
+  #
+  # Stamina - A Ruby Automaton & Induction Toolkit
+  #
+  # SYNOPSIS
+  #   #{program_name} [--version] [--help] COMMAND [cmd opts] ARGS...
+  #
+  # OPTIONS
+  # #{summarized_options}
+  #
+  # COMMANDS
+  # #{summarized_subcommands}
+  #
+  # See '#{program_name} help COMMAND' for more information on a specific command.
+  #
+  class Command < ::Quickl::Delegator(__FILE__, __LINE__)
+
+    # Install options
+    options do |opt|
+      
+      # Show the help and exit
+      opt.on_tail("--help", "Show help") do
+        raise Quickl::Help
+      end
+
+      # Show version and exit
+      opt.on_tail("--version", "Show version") do
+        raise Quickl::Exit, "#{program_name} #{VERSION} (c) 2010-2011, Bernard Lambeau"
+      end
+
+    end
+
+  end # class Command
+end # module Stamina
+require 'stamina/command/robustness'
+require 'stamina/command/help'
+require 'stamina/command/adl2dot'
+require 'stamina/command/metrics'
+require 'stamina/command/classify'
+require 'stamina/command/score'
+require 'stamina/command/abbadingo_dfa'
+require 'stamina/command/abbadingo_samples'
+require 'stamina/command/infer'
+

data/lib/stamina/command/abbadingo_dfa.rb

@@ -0,0 +1,81 @@
+module Stamina
+  class Command
+    # 
+    # Generates a DFA following Abbadingo's protocol
+    #
+    # SYNOPSIS
+    #   #{program_name} #{command_name}
+    #
+    # OPTIONS
+    # #{summarized_options}
+    #
+    class AbbadingoDfa < Quickl::Command(__FILE__, __LINE__)
+      include Robustness 
+
+      # Size of the target automaton
+      attr_accessor :size
+
+      # Tolerance on the size
+      attr_accessor :size_tolerance
+
+      # Tolerance on the automaton depth
+      attr_accessor :depth_tolerance
+
+      # Where to flush the dfa
+      attr_accessor :output_file
+
+      # Install options
+      options do |opt|
+      
+        @size = 64
+        opt.on("--size=X", Integer, "Sets the size of the automaton to generate") do |x|
+          @size = x
+        end
+
+        @size_tolerance = nil
+        opt.on("--size-tolerance[=X]", Integer, "Sets the tolerance on automaton size (in number of states)") do |x|
+          @size_tolerance = x
+        end
+
+        @depth_tolerance = 0
+        opt.on("--depth-tolerance[=X]", Integer, "Sets the tolerance on expected automaton depth (in length, 0 by default)") do |x|
+          @depth_tolerance = x
+        end
+
+        @output_file = nil
+        opt.on("-o", "--output=OUTPUT",
+               "Flush DFA in output file") do |value|
+          @output_file = assert_writable_file(value)
+        end
+
+      end # options
+
+      def accept?(dfa)
+        (size_tolerance.nil?  || (size - dfa.state_count).abs <= size_tolerance) &&
+        (depth_tolerance.nil? || ((2*Math.log2(size)-2) - dfa.depth).abs <= depth_tolerance)
+      end
+
+      # Command execution
+      def execute(args)
+        require 'stamina/abbadingo'
+
+        # generate it
+        randomizer = Stamina::Abbadingo::RandomDFA.new(size)
+        begin
+          dfa = randomizer.execute
+        end until accept?(dfa)
+
+        # flush it
+        if output_file 
+          File.open(output_file, 'w') do |file|
+            Stamina::ADL.print_automaton(dfa, file)
+          end
+        else
+          Stamina::ADL.print_automaton(dfa, $stdout)
+        end
+      end
+      
+    end # class AbbadingoDFA
+  end # class Command
+end # module Stamina
+