stamina 0.3.0

data/lib/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/markable.rb

@@ -0,0 +1,42 @@
+module Stamina
+  #
+  # Allows any object to be markable with user-data.
+  #
+  # This module is expected to be included by classes that want to implement the
+  # Markable design pattern. Moreover, if the instances of the including class
+  # respond to <tt>state_changed</tt>, this method is automatically invoked when
+  # marks change. This method is used by <tt>automaton</tt> in order to make it
+  # possible to track changes and check modified automata for consistency.
+  #
+  # == Detailed API
+  module Markable
+
+    # 
+    # Returns user-value associated to _key_, nil if no such key in user-data.
+    #
+    def [](key) @data[key] end
+
+    # 
+    # Associates _value_ to _key_ in user-data. Overrides previous value if 
+    # present.
+    #
+    def []=(key,value)
+      oldvalue = @data[key]
+      @data[key] = value
+      state_changed(:loaded_pair, [key,oldvalue,value]) if self.respond_to? :state_changed
+    end
+
+    # Removes a mark
+    def remove_mark(key)
+      oldvalue = @data[key]
+      @data.delete(key)
+      state_changed(:loaded_pair, [key,oldvalue,nil]) if self.respond_to? :state_changed
+    end
+
+    # Extracts the copy of attributes which can subsequently be modified.
+    def data
+      @data.nil? ? {} : @data.dup
+    end
+
+  end # module Markable
+end # module Stamina

data/lib/stamina/sample.rb

@@ -0,0 +1,190 @@
+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 = []
+      @size, @positive_count, @negative_count = 0, 0, 0
+    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
+    
+    #
+    # 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
+    
+    # 
+    # 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
+    
+  end # class Sample
+
+end # module Stamina

data/lib/stamina/version.rb

@@ -0,0 +1,14 @@
+module Stamina
+  module Version
+  
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 0
+  
+    def self.to_s
+      [ MAJOR, MINOR, TINY ].join('.')
+    end
+  
+  end 
+  VERSION = Version.to_s
+end

data/stamina.gemspec

@@ -0,0 +1,190 @@
+# We require your library, mainly to have access to the VERSION number. 
+# Feel free to set $version manually.
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require "stamina/version"
+$version = Stamina::Version.to_s
+
+#
+# This is your Gem specification. Default values are provided so that your library
+# should be correctly packaged given what you have described in the .noespec file.
+#
+Gem::Specification.new do |s|
+  
+  ################################################################### ABOUT YOUR GEM
+  
+  # Gem name (required) 
+  s.name = "stamina"
+  
+  # Gem version (required)
+  s.version = $version
+  
+  # A short summary of this gem
+  #
+  # This is displayed in `gem list -d`.
+  s.summary = "Automaton and Regular Inference Toolkit"
+
+  # A long description of this gem (required)
+  #
+  # The description should be more detailed than the summary.  For example,
+  # you might wish to copy the entire README into the description.
+  s.description = "Stamina is an automaton and regular inference toolkit initially developped for the baseline \nof the Stamina Competition (stamina.chefbe.net)."
+  
+  # The URL of this gem home page (optional)
+  s.homepage = "http://stamina.chefbe.net/"
+
+  # Gem publication date (required but auto)
+  #
+  # Today is automatically used by default, uncomment only if
+  # you know what you do!
+  #
+  # s.date = Time.now.strftime('%Y-%m-%d')
+  
+  # The license(s) for the library.  Each license must be a short name, no
+  # more than 64 characters.
+  #
+  # s.licences = %w{}
+
+  # The rubyforge project this gem lives under (optional)
+  #
+  # s.rubyforge_project = nil
+
+  ################################################################### ABOUT THE AUTHORS
+  
+  # The list of author names who wrote this gem.
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  # 
+  s.authors = ["Bernard Lambeau"]
+  
+  # Contact emails for this gem
+  #
+  # If you are providing multiple authors and multiple emails they should be
+  # in the same order.
+  #
+  # NOTE: Somewhat strangly this attribute is always singular! 
+  #       Don't replace by s.emails = ...
+  s.email  = ["blambeau@gmail.com"]
+
+  ################################################################### PATHS, FILES, BINARIES
+  
+  # Paths in the gem to add to $LOAD_PATH when this gem is 
+  # activated (required).
+  #
+  # The default 'lib' is typically sufficient.
+  s.require_paths = ["lib"]
+  
+  # Files included in this gem.
+  #
+  # By default, we take all files included in the Manifest.txt file on root
+  # of the project. Entries of the manifest are interpreted as Dir[...] 
+  # patterns so that lazy people may use wilcards like lib/**/*
+  #
+  here = File.expand_path(File.dirname(__FILE__))
+  s.files = File.readlines(File.join(here, 'Manifest.txt')).
+                 inject([]){|files, pattern| files + Dir[File.join(here, pattern.strip)]}.
+                 collect{|x| x[(1+here.size)..-1]}
+
+  # Test files included in this gem.
+  #
+  s.test_files = Dir["test/**/*"] + Dir["spec/**/*"]
+
+  # The path in the gem for executable scripts (optional)
+  #
+  s.bindir = "bin"
+
+  # Executables included in the gem.
+  #
+  s.executables = (Dir["bin/*"]).collect{|f| File.basename(f)}
+
+  ################################################################### REQUIREMENTS & INSTALL
+  # Remember the gem version requirements operators and schemes:
+  #   =  Equals version
+  #   != Not equal to version
+  #   >  Greater than version
+  #   <  Less than version
+  #   >= Greater than or equal to
+  #   <= Less than or equal to
+  #   ~> Approximately greater than
+  #
+  # Don't forget to have a look at http://lmgtfy.com/?q=Ruby+Versioning+Policies 
+  # for setting your gem version.
+  #
+  # For your requirements to other gems, remember that
+  #   ">= 2.2.0"              (optimistic:  specify minimal version)
+  #   ">= 2.2.0", "< 3.0"     (pessimistic: not greater than the next major)
+  #   "~> 2.2"                (shortcut for ">= 2.2.0", "< 3.0")
+  #   "~> 2.2.0"              (shortcut for ">= 2.2.0", "< 2.3.0")
+  #
+
+  #
+  # One call to add_dependency('gem_name', 'gem version requirement') for each
+  # runtime dependency. These gems will be installed with your gem. 
+  # One call to add_development_dependency('gem_name', 'gem version requirement')
+  # for each development dependency. These gems are required for developers
+  #
+  s.add_development_dependency("rake", "~> 0.8.7")
+  s.add_development_dependency("bundler", "~> 1.0")
+  s.add_development_dependency("rspec", "~> 2.4.0")
+  s.add_development_dependency("yard", "~> 0.6.4")
+  s.add_development_dependency("bluecloth", "~> 2.0.9")
+  s.add_development_dependency("wlang", "~> 0.10.1")
+  
+
+  # The version of ruby required by this gem
+  #
+  # Uncomment and set this if your gem requires specific ruby versions.
+  #
+  # s.required_ruby_version = ">= 0"
+
+  # The RubyGems version required by this gem
+  #
+  # s.required_rubygems_version = ">= 0"
+
+  # The platform this gem runs on.  See Gem::Platform for details.
+  #
+  # s.platform = nil
+
+  # Extensions to build when installing the gem.  
+  #
+  # Valid types of extensions are extconf.rb files, configure scripts 
+  # and rakefiles or mkrf_conf files.
+  #
+  s.extensions = []
+  
+  # External (to RubyGems) requirements that must be met for this gem to work. 
+  # It’s simply information for the user.
+  #
+  s.requirements = nil
+  
+  # A message that gets displayed after the gem is installed
+  #
+  # Uncomment and set this if you want to say something to the user
+  # after gem installation
+  #
+  s.post_install_message = nil
+
+  ################################################################### SECURITY
+
+  # The key used to sign this gem.  See Gem::Security for details.
+  #
+  # s.signing_key = nil
+
+  # The certificate chain used to sign this gem.  See Gem::Security for
+  # details.
+  #
+  # s.cert_chain = []
+  
+  ################################################################### RDOC
+
+  # An ARGV style array of options to RDoc
+  #
+  # See 'rdoc --help' about this
+  #
+  s.rdoc_options = []
+
+  # Extra files to add to RDoc such as README
+  #
+  s.extra_rdoc_files = Dir["README.md"] + Dir["CHANGELOG.md"] + Dir["LICENCE.md"]
+
+end