stamina-induction 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-induction/stamina/induction.rb

@@ -1,5 +1,3 @@
-require_relative 'sample'
-require_relative 'input_string'
 require_relative 'classifier'
 require_relative 'scoring'
 require_relative 'induction/union_find'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: stamina-induction
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.5.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,22 +9,22 @@ 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: stamina-core
-  requirement: &72834540 !ruby/object:Gem::Requirement
+  requirement: &70263208819720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: 0.5.4
   type: :runtime
   prerelease: false
-  version_requirements: *72834540
+  version_requirements: *70263208819720
 - !ruby/object:Gem::Dependency
   name: citrus
-  requirement: &72834300 !ruby/object:Gem::Requirement
+  requirement: &70263208835580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,7 @@ dependencies:
         version: '2.4'
   type: :runtime
   prerelease: false
-  version_requirements: *72834300
+  version_requirements: *70263208835580
 description: Stamina-induction plugs induction algorithm to the stamina toolkit.
 email:
 - blambeau@gmail.com
@@ -42,41 +42,39 @@ extra_rdoc_files: []
 files:
 - LICENCE.md
 - CHANGELOG.md
-- lib/stamina-induction/stamina/dsl/induction.rb
-- lib/stamina-induction/stamina/dsl/reg_lang.rb
-- lib/stamina-induction/stamina/command/classify.rb
-- lib/stamina-induction/stamina/command/score.rb
+- lib/stamina-induction/stamina/abbadingo/random_dfa.rb
+- lib/stamina-induction/stamina/abbadingo/random_sample.rb
+- lib/stamina-induction/stamina/abbadingo.rb
+- lib/stamina-induction/stamina/classifier.rb
 - lib/stamina-induction/stamina/command/abbadingo_dfa.rb
-- lib/stamina-induction/stamina/command/infer.rb
 - lib/stamina-induction/stamina/command/abbadingo_samples.rb
+- lib/stamina-induction/stamina/command/classify.rb
+- lib/stamina-induction/stamina/command/infer.rb
 - lib/stamina-induction/stamina/command/metrics.rb
-- lib/stamina-induction/stamina/reg_lang/parser/plus.rb
-- lib/stamina-induction/stamina/reg_lang/parser/parenthesized.rb
-- lib/stamina-induction/stamina/reg_lang/parser/question.rb
+- lib/stamina-induction/stamina/command/score.rb
+- lib/stamina-induction/stamina/command.rb
+- lib/stamina-induction/stamina/dsl/induction.rb
+- lib/stamina-induction/stamina/dsl/reg_lang.rb
+- lib/stamina-induction/stamina/dsl.rb
+- lib/stamina-induction/stamina/induction/blue_fringe.rb
+- lib/stamina-induction/stamina/induction/commons.rb
+- lib/stamina-induction/stamina/induction/rpni.rb
+- lib/stamina-induction/stamina/induction/union_find.rb
+- lib/stamina-induction/stamina/induction.rb
+- lib/stamina-induction/stamina/reg_lang/canonical_info.rb
 - lib/stamina-induction/stamina/reg_lang/parser/alternative.rb
 - lib/stamina-induction/stamina/reg_lang/parser/node.rb
-- lib/stamina-induction/stamina/reg_lang/parser/symbol.rb
-- lib/stamina-induction/stamina/reg_lang/parser/sequence.rb
+- lib/stamina-induction/stamina/reg_lang/parser/parenthesized.rb
 - lib/stamina-induction/stamina/reg_lang/parser/parser.citrus
+- lib/stamina-induction/stamina/reg_lang/parser/plus.rb
+- lib/stamina-induction/stamina/reg_lang/parser/question.rb
 - lib/stamina-induction/stamina/reg_lang/parser/regexp.rb
+- lib/stamina-induction/stamina/reg_lang/parser/sequence.rb
 - lib/stamina-induction/stamina/reg_lang/parser/star.rb
-- lib/stamina-induction/stamina/reg_lang/canonical_info.rb
+- lib/stamina-induction/stamina/reg_lang/parser/symbol.rb
 - lib/stamina-induction/stamina/reg_lang/parser.rb
-- lib/stamina-induction/stamina/induction.rb
-- lib/stamina-induction/stamina/classifier.rb
-- lib/stamina-induction/stamina/abbadingo.rb
-- lib/stamina-induction/stamina/dsl.rb
-- lib/stamina-induction/stamina/sample.rb
-- lib/stamina-induction/stamina/input_string.rb
-- lib/stamina-induction/stamina/induction/rpni.rb
-- lib/stamina-induction/stamina/induction/blue_fringe.rb
-- lib/stamina-induction/stamina/induction/union_find.rb
-- lib/stamina-induction/stamina/induction/commons.rb
 - lib/stamina-induction/stamina/reg_lang.rb
-- lib/stamina-induction/stamina/abbadingo/random_dfa.rb
-- lib/stamina-induction/stamina/abbadingo/random_sample.rb
 - lib/stamina-induction/stamina/scoring.rb
-- lib/stamina-induction/stamina/command.rb
 - lib/stamina-induction/stamina-induction.rb
 homepage: https://github.com/blambeau/stamina
 licenses: []
@@ -98,7 +96,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: Induction algorithms for the Stamina toolkit

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

@@ -1,123 +0,0 @@
-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-induction/stamina/sample.rb

@@ -1,309 +0,0 @@
-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