stamina-core 0.5.3 → 0.5.4

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+# O.5.4 / 2012-03-06
+
+* InputString and Sample have been moved from stamina-induction to stamina-core as ADL
+  and Walking rely on them.
+* Walking methods `parses?`, `accepts?` and `rejects?` are now aliased as `parse?`,
+  `accept?` and `reject?`, respectively.
+* Automaton#to_dot now accepts a boolean argument to bypass sorting its states.
+
 # 0.5.3 / 2012-02-25
 
 * Resolve accuracy between github tags and rubygems

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

@@ -1214,7 +1214,7 @@ module Stamina
     #
     #   {:label => "#{edge.symbol}"}
     #
-    def to_dot(&rewriter)
+    def to_dot(sort_states = true, &rewriter)
       unless rewriter
         to_dot do |elm, kind|
           case kind
@@ -1236,9 +1236,14 @@ module Stamina
         buffer = "digraph G {\n"
         attrs = attributes2dot(rewriter.call(self, :automaton))
         buffer << "  graph [#{attrs}];\n"
-        self.depth
-        states.sort{|s1,s2| s1[:depth] <=> s2[:depth]}.each do |s|
-          s.remove_mark(:depth)
+        ss = if sort_states
+          self.depth
+          states.sort{|s1,s2| s1[:depth] <=> s2[:depth]}
+        else
+          self.states
+        end
+        ss.each do |s|
+          s.remove_mark(:depth) if sort_states
           attrs = attributes2dot(rewriter.call(s, :state))
           buffer << "  #{s.index} [#{attrs}];\n"
         end

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

@@ -290,6 +290,7 @@ module Stamina
       def parses?(input, from=nil)
         not(reached(input,from).empty?)
       end
+      alias :parse? :parses?
 
       #
       # Checks if the automaton accepts an input string. Returns true if at least
@@ -298,6 +299,7 @@ module Stamina
       def accepts?(input, from=nil)
         not reached(input,from).select{|s| s.accepting? and not s.error?}.empty?
       end
+      alias :accept? :accepts?
 
       #
       # Checks if the automaton rejects an input string. Returns true if no
@@ -306,6 +308,7 @@ module Stamina
       def rejects?(input, from=nil)
         not(accepts?(input, from))
       end
+      alias :reject? :rejects?
 
       # Returns '1' if the string is accepted by the automaton,
       # '0' otherwise.

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

@@ -5,6 +5,8 @@ require_relative 'markable'
 require_relative 'adl'
 require_relative 'automaton'
 require_relative 'utils'
+require_relative 'input_string'
+require_relative 'sample'
 require_relative 'dsl'
 require_relative 'engine'
 require_relative 'command'

data/lib/stamina-core/stamina/input_string.rb

@@ -0,0 +1,123 @@
+module Stamina
+  #
+  # An input string is a sequence of input symbols (symbols being letters appearing
+  # on automaton edges) labeled as positive, negative or unlabeled (provided for test
+  # samples and query strings).
+  #
+  # This class include the Enumerable module, that allows reasoning about
+  # ordered symbols.
+  #
+  # == Detailed API
+  class InputString
+    include Enumerable
+
+    #
+    # Creates an input string from symbols and positive or negative labeling.
+    #
+    # Arguments:
+    # - symbols: When an array is provided, it is duplicated by default to be kept
+    #   internally. Set dup to false to avoid duplicating it (in both cases, the
+    #   internal array will be freezed). When a String is provided, symbols array
+    #   is created using <tt>symbols.split(' ')</tt> and then freezed. _dup_ is
+    #   ignored in the case.
+    # - The positive argument may be true (positive string), false (negative one)
+    #   or nil (unlabeled).
+    #
+    # Raises:
+    # - ArgumentError if symbols is not an Array nor a String.
+    #
+    def initialize(symbols, positive, dup=true)
+      raise(ArgumentError,
+            "Input string expects an Array or a String: #{symbols} received",
+            caller) unless Array===symbols or String===symbols
+      @symbols = case symbols
+                   when String
+                     symbols.split(' ').freeze
+                   when Array
+                     (dup ? symbols.dup : symbols).freeze
+                 end
+      @positive = positive
+    end
+
+    #
+    # Checks if this input string is empty (aka lambda, i.e. contains no symbol).
+    #
+    def empty?() @symbols.empty? end
+    alias :lambda? :empty?
+
+    #
+    # Returns the string size, i.e. number of its symbols.
+    #
+    def size() @symbols.size end
+
+    #
+    # Returns the exact label of this string, being true (positive string)
+    # false (negative string) or nil (unlabeled)
+    #
+    def label() @positive end
+
+    #
+    # Returns true if this input string is positively labeled, false otherwise.
+    #
+    def positive?() @positive==true end
+
+    #
+    # Returns true if this input string is negatively labeled, false otherwise.
+    #
+    def negative?() @positive==false end
+
+    #
+    # Returns true if this input string unlabeled.
+    #
+    def unlabeled?() @positive.nil? end
+
+    # Copies and returns the same string, but switch the positive flag. This
+    # method returns self if it is unlabeled.
+    def negate
+      return self if unlabeled?
+      InputString.new(@symbols, !@positive, false)
+    end
+
+    #
+    # Returns an array with symbols of this string. Returned array may not be
+    # modified (it is freezed).
+    #
+    def symbols() @symbols end
+
+    #
+    # Yields the block with each string symbol, in order. Has no effect without
+    # block.
+    #
+    def each() @symbols.each {|s| yield s if block_given? } end
+
+    #
+    # Checks equality with another InputString. Returns true if strings have same
+    # sequence of symbols and same labeling, false otherwise. Returns nil if _o_
+    # is not an InputString.
+    #
+    def ==(o)
+      return nil unless InputString===o
+      label == o.label and @symbols == o.symbols
+    end
+    alias :eql? :==
+
+    #
+    # Computes a hash code for this string.
+    #
+    def hash
+      @symbols.hash + 37*positive?.hash
+    end
+
+    #
+    # Prints this string in ADL.
+    #
+    def to_adl
+      str = (unlabeled? ? '?' : (positive? ? '+ ' : '- '))
+      str << @symbols.join(' ')
+      str
+    end
+    alias :to_s :to_adl
+    alias :inspect :to_adl
+
+  end # class InputString
+end # module Stamina

data/lib/stamina-core/stamina/sample.rb

@@ -0,0 +1,309 @@
+module Stamina
+
+  #
+  # A sample as an ordered collection of InputString labeled as positive or negative.
+  #
+  # == Tips and tricks
+  # - loading samples from disk is easy thanks to ADL !
+  #
+  # == Detailed API
+  class Sample
+    include Enumerable
+
+    # Number of strings in the sample
+    attr_reader :size
+
+    # Number of positive strings in the sample
+    attr_reader :positive_count
+
+    # Number of negative strings in the sample
+    attr_reader :negative_count
+
+    #
+    # Creates an empty sample and appends it with args, by calling Sample#<< on
+    # each of them.
+    #
+    def self.[](*args) Sample.new << args end
+
+    #
+    # Creates an empty sample.
+    #
+    def initialize(strings = nil)
+      @strings = []
+      @size, @positive_count, @negative_count = 0, 0, 0
+      strings.each{|s| self << s } unless strings.nil?
+    end
+
+    #
+    # Coerces `arg` to a Sample instance.
+    #
+    def self.coerce(arg)
+      if arg.is_a?(Sample)
+        arg
+      elsif arg.is_a?(String)
+        parse(arg)
+      else
+        raise ArgumentError, "Invalid argument #{arg} for `Sample`"
+      end
+    end
+
+    #
+    # Parses an ADL input
+    #
+    def self.parse(adl)
+      ADL::parse_sample(adl)
+    end
+
+    #
+    # Returns true if this sample does not contain any string,
+    # false otherwise.
+    #
+    def empty?()
+      @size==0
+    end
+
+    #
+    # Adds a string to the sample. The _str_ argument may be an InputString instance,
+    # a String (parsed using ADL), a Sample instance (all strings are added) or an
+    # Array (recurses on each element).
+    #
+    # Raises an InconsistencyError if the same string already exists with the
+    # opposite label. Raises an ArgumentError if the _str_ argument is not recognized.
+    #
+    def <<(str)
+      case str
+        when InputString
+          #raise(InconsistencyError, "Inconsistent sample on #{str}", caller) if self.include?(str.negate)
+          @size += 1
+          str.positive? ? (@positive_count += 1) : (@negative_count += 1)
+          @strings << str
+        when String
+          self << ADL::parse_string(str)
+        when Sample
+          str.each {|s| self << s}
+        when Array
+          str.each {|s| self << s}
+        else
+          raise(ArgumentError, "#{str} is not a valid argument.", caller)
+      end
+      self
+    end
+
+    #
+    # Returns true if a given string is included in the sample, false otherwise.
+    # This method allows same flexibility as << for the _str_ argument.
+    #
+    def include?(str)
+      case str
+        when InputString
+          @strings.include?(str)
+        when String
+          include?(ADL::parse_string(str))
+        when Array
+          str.each {|s| return false unless include?(s)}
+          true
+        when Sample
+          str.each {|s| return false unless include?(s)}
+          true
+        else
+          raise(ArgumentError, "#{str} is not a valid argument.", caller)
+      end
+    end
+
+    #
+    # Returns a new sample as the union of both `self` and `other`
+    #
+    def +(other)
+      s = Sample.new
+      each{|x| s << x}
+      other.each{|x| s << x}
+      s
+    end
+
+    #
+    # Compares with another sample _other_, which is required to be a Sample
+    # instance. Returns true if the two samples contains the same strings (including
+    # labels), false otherwise.
+    #
+    def ==(other)
+      include?(other) and other.include?(self)
+    end
+    alias :eql? :==
+
+    #
+    # Computes an hash code for this sample.
+    #
+    def hash
+      self.inject(37){|memo,str| memo + 17*str.hash}
+    end
+
+    #
+    # Yields the block with each string. This method has no effect if no
+    # block is given.
+    #
+    def each
+      return unless block_given?
+      @strings.each {|str| yield str}
+    end
+
+    #
+    # Yields the block with each positive string. This method has no effect if no
+    # block is given.
+    #
+    def each_positive
+      return unless block_given?
+      each {|str| yield str if str.positive?}
+    end
+
+    #
+    # Returns an enumerator on positive strings.
+    #
+    def positive_enumerator
+		  if RUBY_VERSION >= "1.9"
+        Enumerator.new(self, :each_positive)
+      else
+        Enumerable::Enumerator.new(self, :each_positive)
+			end
+    end
+
+    #
+    # Yields the block with each negative string. This method has no effect if no
+    # block is given.
+    #
+    def each_negative
+      each {|str| yield str if str.negative?}
+    end
+
+    #
+    # Returns an enumerator on negative strings.
+    #
+    def negative_enumerator
+		  if RUBY_VERSION >= "1.9"
+        Enumerator.new(self, :each_negative)
+      else
+        Enumerable::Enumerator.new(self, :each_negative)
+			end
+    end
+
+    #
+    # Checks if the sample is correctly classified by a given classifier
+    # (expected to include the Stamina::Classfier module).
+    # Unlabeled strings are simply ignored.
+    #
+    def correctly_classified_by?(classifier)
+      classifier.correctly_classify?(self)
+    end
+
+    #
+    # Computes and returns the binary signature of the sample. The signature
+    # is a String having one character for each string in the sample. A '1'
+    # is used for positive strings, '0' for negative ones and '?' for unlabeled.
+    #
+    def signature
+      signature = ''
+      each do |str|
+        signature << (str.unlabeled? ? '?' : str.positive? ? '1' : '0')
+      end
+      signature
+    end
+
+    #
+    # Takes only a given proportion of this sample and returns it as a new Sample.
+    #
+    def take(proportion = 0.5)
+      taken = Stamina::Sample.new
+      each_positive{|s| taken << s if Kernel.rand < proportion}
+      each_negative{|s| taken << s if Kernel.rand < proportion}
+      taken
+    end
+
+    #
+    # Prints an ADL description of this sample on the buffer.
+    #
+    def to_adl(buffer="")
+      self.inject(buffer) {|memo,str| memo << "\n" << str.to_adl}
+    end
+    alias :to_s :to_adl
+    alias :inspect :to_adl
+
+    #
+    # Converts a Sample to an (augmented) prefix tree acceptor. This method ensures
+    # that the states of the PTA are in lexical order, according to the <code><=></code>
+    # operator defined on symbols. States reached by negative strings are tagged as
+    # non accepting and error.
+    #
+    def self.to_pta(sample)
+      thepta = Automaton.new do |pta|
+        initial_state = add_state(:initial => true, :accepting => false)
+
+        # Fill the PTA with each string
+        sample.each do |str|
+          # split string using the dfa
+          parsed, reached, remaining = pta.dfa_split(str, initial_state)
+
+          # remaining symbols are not empty -> build the PTA
+          unless remaining.empty?
+            remaining.each do |symbol|
+              newone = pta.add_state(:initial => false, :accepting => false, :error => false)
+              pta.connect(reached, newone, symbol)
+              reached = newone
+            end
+          end
+
+          # flag state
+          str.positive? ? reached.accepting! : reached.error!
+
+          # check consistency, should not arrive as Sample does not allow
+          # inconsistencies. Should appear only if _sample_ is not a Sample
+          # instance but some other enumerable.
+          raise(InconsistencyError, "Inconsistent sample on #{str}", caller)\
+            if (reached.error? and reached.accepting?)
+        end
+
+        # Reindex states by applying BFS
+        to_index, index = [initial_state], 0
+        until to_index.empty?
+          state = to_index.shift
+          state[:__index__] = index
+          state.out_edges.sort{|e,f| e.symbol<=>f.symbol}.each{|e| to_index << e.target}
+          index += 1
+        end
+      end
+
+      # Now we rebuild a fresh one with states in order.
+      # This look more efficient that reordering states of the PTA
+      Automaton.new do |ordered|
+        ordered.add_n_states(thepta.state_count)
+        thepta.each_state do |pta_state|
+          source = ordered.ith_state(pta_state[:__index__])
+          source.initial!   if pta_state.initial?
+          source.accepting! if pta_state.accepting?
+          source.error!     if pta_state.error?
+          pta_state.out_edges.each do |e|
+            target = ordered.ith_state(e.target[:__index__])
+            ordered.connect(source, target, e.symbol)
+          end
+        end
+      end
+
+    end
+
+    # Converts this sample to a PTA
+    def to_pta
+      Sample.to_pta(self)
+    end
+    alias :to_fa  :to_pta
+    alias :to_dfa :to_pta
+
+    # Converts this sample to a canonical dfa
+    def to_cdfa
+      to_pta.to_cdfa
+    end
+
+    # Converts this sample to a dot output
+    def to_dot
+      to_pta.to_dot
+    end
+
+  end # class Sample
+end # module Stamina

data/lib/stamina-core/stamina/version.rb

@@ -3,7 +3,7 @@ module Stamina
 
     MAJOR = 0
     MINOR = 5
-    TINY  = 3
+    TINY  = 4
 
     def self.to_s
       [ MAJOR, MINOR, TINY ].join('.')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stamina-core
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-25 00:00:00.000000000Z
+date: 2012-03-06 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: quickl
-  requirement: &85539780 !ruby/object:Gem::Requirement
+  requirement: &70340660206260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: 0.4.3
   type: :runtime
   prerelease: false
-  version_requirements: *85539780
+  version_requirements: *70340660206260
 description: ! "Stamina is an automaton and regular inference toolkit initially developped
   for the \nbaseline of the Stamina Competition (stamina.chefbe.net)."
 email:
@@ -32,36 +32,38 @@ extra_rdoc_files: []
 files:
 - LICENCE.md
 - CHANGELOG.md
-- lib/stamina-core/stamina/dsl/automata.rb
-- lib/stamina-core/stamina/dsl/core.rb
-- lib/stamina-core/stamina/command/help.rb
-- lib/stamina-core/stamina/command/run.rb
-- lib/stamina-core/stamina/command/robustness.rb
-- lib/stamina-core/stamina/command/adl2dot.rb
-- lib/stamina-core/stamina/automaton.rb
 - lib/stamina-core/stamina/adl.rb
-- lib/stamina-core/stamina/utils.rb
-- lib/stamina-core/stamina/dsl.rb
-- lib/stamina-core/stamina/engine/context.rb
-- lib/stamina-core/stamina/automaton/determinize.rb
-- lib/stamina-core/stamina/automaton/minimize.rb
-- lib/stamina-core/stamina/automaton/walking.rb
-- lib/stamina-core/stamina/automaton/strip.rb
-- lib/stamina-core/stamina/automaton/compose.rb
-- lib/stamina-core/stamina/automaton/minimize/hopcroft.rb
-- lib/stamina-core/stamina/automaton/minimize/pitchies.rb
 - lib/stamina-core/stamina/automaton/complement.rb
-- lib/stamina-core/stamina/automaton/hide.rb
+- lib/stamina-core/stamina/automaton/complete.rb
+- lib/stamina-core/stamina/automaton/compose.rb
+- lib/stamina-core/stamina/automaton/determinize.rb
 - lib/stamina-core/stamina/automaton/equivalence.rb
+- lib/stamina-core/stamina/automaton/hide.rb
 - lib/stamina-core/stamina/automaton/metrics.rb
-- lib/stamina-core/stamina/automaton/complete.rb
-- lib/stamina-core/stamina/utils/decorate.rb
-- lib/stamina-core/stamina/errors.rb
-- lib/stamina-core/stamina/markable.rb
-- lib/stamina-core/stamina/ext/math.rb
+- lib/stamina-core/stamina/automaton/minimize/hopcroft.rb
+- lib/stamina-core/stamina/automaton/minimize/pitchies.rb
+- lib/stamina-core/stamina/automaton/minimize.rb
+- lib/stamina-core/stamina/automaton/strip.rb
+- lib/stamina-core/stamina/automaton/walking.rb
+- lib/stamina-core/stamina/automaton.rb
+- lib/stamina-core/stamina/command/adl2dot.rb
+- lib/stamina-core/stamina/command/help.rb
+- lib/stamina-core/stamina/command/robustness.rb
+- lib/stamina-core/stamina/command/run.rb
+- lib/stamina-core/stamina/command.rb
 - lib/stamina-core/stamina/core.rb
+- lib/stamina-core/stamina/dsl/automata.rb
+- lib/stamina-core/stamina/dsl/core.rb
+- lib/stamina-core/stamina/dsl.rb
+- lib/stamina-core/stamina/engine/context.rb
 - lib/stamina-core/stamina/engine.rb
-- lib/stamina-core/stamina/command.rb
+- lib/stamina-core/stamina/errors.rb
+- lib/stamina-core/stamina/ext/math.rb
+- lib/stamina-core/stamina/input_string.rb
+- lib/stamina-core/stamina/markable.rb
+- lib/stamina-core/stamina/sample.rb
+- lib/stamina-core/stamina/utils/decorate.rb
+- lib/stamina-core/stamina/utils.rb
 - lib/stamina-core/stamina/version.rb
 - lib/stamina-core/stamina-core.rb
 homepage: https://github.com/blambeau/stamina
@@ -84,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Automaton and Regular Inference Toolkit