stamina 0.3.1 → 0.4.0

data/lib/stamina/scoring.rb

@@ -171,6 +171,43 @@ module Stamina
       end
       alias :hbcr :harmonic_balanced_classification_rate
       alias :harmonic_bcr :harmonic_balanced_classification_rate
+
+      MEASURES = [
+        :false_positive, :false_negative,
+        :true_positive, :true_negative,
+        :accuracy, :error_rate,
+        :precision, :recall, :f_measure,
+        :false_positive_rate, :false_negative_rate,
+        :true_positive_rate, :true_negative_rate,
+        :positive_predictive_value, :negative_predictive_value,
+        :sensitivity, :specificity,
+        :positive_likelihood, :negative_likelihood,
+        :balanced_classification_rate, :balanced_error_rate, :harmonic_bcr
+      ]
+
+      def to_h
+        h = {}
+        MEASURES.each do |m|
+          h[m] = self.send(m.to_sym)
+        end
+        h
+      end
+
+      def to_s
+        s = ""
+        MEASURES.each do |m|
+          vals = case val = self.send(m.to_sym)
+            when Integer
+              "%s" % val
+            when Float
+              "%.5f" % val
+            else
+              "%s" % val
+          end
+          s += "%30s: %10s\n" % [m.to_s, vals]
+        end
+        s
+      end
     
   end # module Scoring
 end # module Stamina

data/lib/stamina/version.rb

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

data/stamina.gemspec

@@ -129,7 +129,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency("yard", "~> 0.6.4")
   s.add_development_dependency("bluecloth", "~> 2.0.9")
   s.add_development_dependency("wlang", "~> 0.10.1")
-  
+  s.add_development_dependency("gnuplot", "~> 2.3.6")
+  s.add_dependency("quickl", "~> 0.2.0")
 
   # The version of ruby required by this gem
   #

data/stamina.noespec

@@ -9,7 +9,7 @@ variables:
   upper:
     Stamina
   version:
-    0.3.1
+    0.4.0
   summary: |-
     Automaton and Regular Inference Toolkit
   description: |-
@@ -22,14 +22,11 @@ variables:
     - http://stamina.chefbe.net/
     - http://github.com/blambeau/stamina
   dependencies: 
-    # Rake is required for developers, as usual
-    - {name: rake,      version: "~> 0.8.7", groups: [development]}
-    # Bundler is required for developers and is used by the Rakefile
-    - {name: bundler,   version: "~> 1.0",   groups: [development]}
-    # RSpec is required to run 'rake spec'. See tasks/spec.rake 
-    - {name: rspec,     version: "~> 2.4.0", groups: [development]}
-    # YARD and BlueCloth are required to run 'rake yard'. See tasks/yard.rake 
-    - {name: yard,      version: "~> 0.6.4", groups: [development]}
-    - {name: bluecloth, version: "~> 2.0.9", groups: [development]}
-    # wlang is required to run 'rake debug_mail'. See tasks/debug_mail.rake
-    - {name: wlang, version: "~> 0.10.1", groups: [development]}
+    - {name: quickl,    version: "~> 0.2.0",  groups: [runtime]}
+    - {name: rake,      version: "~> 0.8.7",  groups: [development]}
+    - {name: bundler,   version: "~> 1.0",    groups: [development]}
+    - {name: rspec,     version: "~> 2.4.0",  groups: [development]}
+    - {name: yard,      version: "~> 0.6.4",  groups: [development]}
+    - {name: bluecloth, version: "~> 2.0.9",  groups: [development]}
+    - {name: wlang,     version: "~> 0.10.1", groups: [development]}
+    - {name: gnuplot,   version: "~> 2.3.6",  groups: [development]}

data/test/stamina/abbadingo/random_dfa_test.rb

@@ -0,0 +1,16 @@
+require 'stamina/stamina_test'
+require 'stamina/abbadingo'
+module Stamina
+  module Abbadingo
+    class RandomDFATest < StaminaTest
+
+      def test_it_looks_ok_with_default_options
+        dfa = RandomDFA.new(32).execute
+        assert dfa.deterministic?
+        assert dfa.minimal?
+        assert dfa.complete?
+      end
+
+    end # class RandomDFATest
+  end # module Abbadingo
+end # module Stamina

data/test/stamina/abbadingo/random_sample_test.rb

@@ -0,0 +1,78 @@
+require 'stamina/stamina_test'
+require 'stamina/abbadingo'
+module Stamina
+  module Abbadingo
+    class RandomSampleTest < StaminaTest
+
+      def test_length_for
+        rs = RandomSample::StringEnumerator.new
+        assert_equal 0, rs.length_for(1) 
+        assert_equal 1, rs.length_for(2)
+        assert_equal 1, rs.length_for(3)
+        assert_equal 2, rs.length_for(4)
+        assert_equal 2, rs.length_for(5)
+        assert_equal 2, rs.length_for(6)
+        assert_equal 2, rs.length_for(7)
+        assert_equal 3, rs.length_for(8)
+      end
+
+      def test_string_for
+        rs = RandomSample::StringEnumerator.new
+        assert_equal [], rs.string_for(1)
+        assert_equal ["0"], rs.string_for(2)
+        assert_equal ["1"], rs.string_for(3)
+        assert_equal ["0", "0"], rs.string_for(4)
+        assert_equal ["1", "0"], rs.string_for(5)
+        assert_equal ["0", "1"], rs.string_for(6)
+        assert_equal ["1", "1"], rs.string_for(7)
+      end
+
+      def test_string_for_generates_all_diff
+        rs = RandomSample::StringEnumerator.new
+        h = {}
+        (1..100).each{|i| h[rs.string_for(i)] = true}
+        assert_equal 100, h.size
+      end
+
+      def test_string_for_respects_distribution
+        rs = RandomSample::StringEnumerator.new
+        lengths = Hash.new{|h,k| h[k] = 0}
+        (1..127).each{|i| lengths[rs.string_for(i).size] += 1}
+        assert_equal [0, 1, 2, 3, 4, 5, 6], lengths.keys.sort
+        prop = (0..6).collect{|i| lengths[i].to_f/128}
+        assert_equal [0.0078125, 0.015625, 0.03125, 0.0625, 0.125, 0.25, 0.5], prop
+      end
+
+      def test_enumerator
+        enum = RandomSample::StringEnumerator.new(10)
+        lengths = Hash.new{|h,k| h[k] = 0}
+        20000.times{lengths[enum.one.size] += 1}
+        assert (lengths.keys.sort - (0..10).to_a).empty?
+        prop = (0..10).collect{|i| lengths[i].to_f/20000}
+        assert((prop[-1] >= 0.45) && (prop[-1] <= 0.55))
+        assert((prop[-2] >= 0.2) && (prop[-2] <= 0.3))
+        assert((prop[-3] >= 0.1) && (prop[-3] <= 0.15))
+      end
+
+      def test_it_can_be_used_on_small_dfas
+        dfa = RandomDFA.new(16).execute
+        training, test = RandomSample.execute(dfa)
+
+        assert test.size > 0
+        assert training.size > 0
+
+        # check training sample
+        assert training.positive_count > 0 
+        assert training.negative_count > 0
+        assert dfa.correctly_classify?(training)
+
+        # check test sample
+        assert test.positive_count > 0 
+        assert test.negative_count > 0
+        assert dfa.correctly_classify?(test)
+       end
+
+
+    end # class RandomDFATest
+  end # module Abbadingo
+end # module Stamina

data/test/stamina/adl_test.rb

@@ -486,6 +486,31 @@ module Stamina
         EOF
       end
     end
+
+    def test_allows_error_states
+      dfa = ADL::parse_automaton <<-EOF
+        5 0
+        0 true true true
+        1 false false true
+        2 false false false
+        3 false true false
+        4 false true
+      EOF
+      assert dfa.ith_state(0).accepting? && dfa.ith_state(0).error?
+      assert !dfa.ith_state(1).accepting? && dfa.ith_state(1).error?
+      assert !dfa.ith_state(2).accepting? && !dfa.ith_state(2).error?
+      assert dfa.ith_state(3).accepting? && !dfa.ith_state(3).error?
+      assert !dfa.ith_state(4).error?
+    end
+
+    def test_flushes_error_states
+      dfa = ADL::parse_automaton <<-EOF
+        2 0
+        0 true false
+        1 false false true
+      EOF
+      assert_equal "1 false false true", dfa.to_adl.split("\n")[2].strip
+    end
+
   end # class ADLTest
-    
-end # module Stamina
+end # module Stamina

data/test/stamina/automaton/complete_test.rb

@@ -0,0 +1,58 @@
+require 'test/unit'
+require 'stamina/stamina_test'
+module Stamina
+  class Automaton
+    class CompleteTest < StaminaTest
+    
+      def test_on_not_complete
+        x, y, z = nil, nil, nil
+        dfa = Automaton.new(true) do |fa|
+          fa.alphabet = ["a", "b"]
+          x = fa.add_state(:initial => true,  :accepting => true)
+          y = fa.add_state(:initial => false, :accepting => false)
+          fa.connect(0,1,'a')
+          fa.connect(1,0,'b')
+        end
+
+        assert_equal false, dfa.complete?
+        dfa.complete!
+        assert_equal true, dfa.complete?
+
+        assert_equal 3, dfa.state_count
+        z = dfa.ith_state(2)
+        assert_equal z, dfa.dfa_delta(x, "b")
+        assert_equal y, dfa.dfa_delta(x, "a")
+        assert_equal z, dfa.dfa_delta(y, "a")
+        assert_equal x, dfa.dfa_delta(y, "b")
+      end
+
+      def test_on_complete
+        dfa = Automaton.new(true) do |fa|
+          fa.alphabet = ["a"]
+          fa.add_state(:initial => true,  :accepting => true)
+          fa.add_state(:initial => false, :accepting => false)
+          fa.connect(0,1,'a')
+          fa.connect(1,0,'a')
+        end
+        assert_equal true, dfa.complete?
+        dfa.complete!
+        assert_equal 2, dfa.state_count
+      end
+ 
+      def test_it_has_a_non_touching_impl
+        dfa = Automaton.new(true) do |fa|
+          fa.alphabet = ["a", "b"]
+          fa.add_state(:initial => true,  :accepting => true)
+          fa.add_state(:initial => false, :accepting => false)
+          fa.connect(0,1,'a')
+          fa.connect(1,0,'b')
+        end
+        c = dfa.complete
+        assert_equal 2, dfa.state_count
+        assert_equal 3, c.state_count
+      end
+
+    end # class CompleteTest
+  end # class Automaton
+end # module Stamina
+

data/test/stamina/automaton/equivalence_test.rb

@@ -0,0 +1,120 @@
+require 'test/unit'
+require 'stamina/stamina_test'
+module Stamina
+  class Automaton
+    class EquivalenceTest < StaminaTest
+
+      def test_equivalence_on_small_dfa
+        assert_equal true, @small_dfa <=> @small_dfa
+      end
+      
+      def test_equivalence_on_real_case
+        dfa1 = Stamina::ADL.parse_automaton <<-EOF
+          3 5
+          0 true false
+          1 false false
+          2 false true
+          0 1 a
+          1 1 a
+          1 2 b
+          2 2 b
+          0 2 b
+        EOF
+        dfa2 = Stamina::ADL.parse_automaton <<-EOF
+          3 5
+          0 false true
+          1 true false
+          2 false false
+          0 0 b
+          1 2 a
+          1 0 b
+          2 2 a
+          2 0 b
+        EOF
+        dfa3 = Stamina::ADL.parse_automaton <<-EOF
+          3 5
+          0 false false
+          1 false true
+          2 true false
+          0 0 a
+          0 1 b
+          1 1 b
+          2 0 a
+          2 1 b
+        EOF
+        assert_equal true, dfa1 <=> dfa2
+        assert_equal true, dfa2 <=> dfa1
+        assert_equal true, dfa1 <=> dfa3
+        assert_equal true, dfa3 <=> dfa1
+        assert_equal true, dfa2 <=> dfa3
+        assert_equal true, dfa3 <=> dfa2
+      end
+      
+      def test_equivalence_does_not_change_the_automata
+        dfa1 = Stamina::ADL.parse_automaton <<-EOF
+          1 1
+          0 true true
+          0 0 a
+        EOF
+        assert_not_nil dfa1.initial_state
+        assert_equal true, dfa1 <=> dfa1
+        assert_not_nil dfa1.initial_state
+      end
+      
+      def test_non_equivalent_dfa_are_recognized_1
+        dfa1 = Stamina::ADL.parse_automaton <<-EOF
+          3 5
+          0 true false
+          1 false false
+          2 false true
+          0 1 a
+          1 1 a
+          1 2 b
+          2 2 b
+          0 2 b
+        EOF
+        assert_equal false, @small_dfa <=> dfa1
+        assert_equal false, dfa1 <=> @small_dfa
+      end
+      
+      def test_non_equivalent_dfa_are_recognized_2
+        dfa1 = Stamina::ADL.parse_automaton <<-EOF
+          5 4
+          0 true false
+          1 false false
+          2 false false
+          3 false false
+          4 false false
+          0 1 a
+          1 2 a
+          2 3 a
+          3 4 a
+        EOF
+        dfa2 = Stamina::ADL.parse_automaton <<-EOF
+          1 1
+          0 true true
+          0 0 a
+        EOF
+        assert_equal false, dfa2 <=> dfa1
+        assert_not_nil dfa1.initial_state
+        assert_not_nil dfa2.initial_state
+        assert_equal false, dfa1 <=> dfa2
+      end
+      
+      def test_equivalence_takes_care_of_state_flags
+        dfa1 = Stamina::ADL.parse_automaton <<-EOF
+          1 0
+          0 true false
+        EOF
+        dfa2 = Stamina::ADL.parse_automaton <<-EOF
+          1 0
+          0 true true
+        EOF
+        assert_equal false, dfa1 <=> dfa2
+        assert_equal false, dfa2 <=> dfa1
+      end
+
+    end # class EquivalenceTest
+  end # class Automaton
+end # module Stamina
+

data/test/stamina/automaton/minimize/hopcroft_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path("../minimize_test", __FILE__)
+module Stamina
+  class Automaton
+    module Minimize
+      class HopcroftTest < MinimizeTest
+
+        def algo
+          Hopcroft
+        end
+
+      end # class HopcroftTest
+    end # module Minimize
+  end # class Automaton
+end # module Stamina
+

data/test/stamina/automaton/minimize/minimize_test.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require 'stamina/stamina_test'
+module Stamina
+  class Automaton
+    module Minimize
+      class MinimizeTest < StaminaTest
+
+        # To be overriden
+        def algo 
+          nil
+        end
+
+        def test_on_unknown_1
+          return unless algo
+          dfa = load_adl_automaton("unknown_1.adl", __FILE__)
+          min = load_adl_automaton("unknown_1.min.adl", __FILE__)
+          assert_equivalent(algo.execute(dfa), min)
+        end
+
+        # From slide 10 in http://www.clear.rice.edu/comp412/Lectures/L07DFAMin-1up.pdf
+        def test_on_rice_edu_10
+          return unless algo
+          dfa = load_adl_automaton("rice_edu_10.adl", __FILE__)
+          min = load_adl_automaton("rice_edu_10.min.adl", __FILE__)
+          assert_equivalent(algo.execute(dfa), min)
+        end
+
+        # From slide 13 in http://www.clear.rice.edu/comp412/Lectures/L07DFAMin-1up.pdf
+        def test_on_rice_edu_13
+          return unless algo
+          dfa = load_adl_automaton("rice_edu_13.adl", __FILE__)
+          min = load_adl_automaton("rice_edu_13.min.adl", __FILE__)
+          assert_equivalent(algo.execute(dfa), min)
+        end
+
+        def test_it_strips_when_needed
+          return unless algo
+          dfa = load_adl_automaton("should_strip_1.adl", __FILE__)
+          min = load_adl_automaton("should_strip_1.min.adl", __FILE__)
+          assert_equivalent(algo.execute(dfa), min)
+        end
+
+        def test_it_has_no_effect_on_already_minimal
+          return unless algo
+          dfa = load_adl_automaton("rice_edu_13.min.adl", __FILE__)
+          min = algo.execute(dfa)
+          assert_equal dfa.complete.state_count, min.complete.state_count
+          assert_equivalent(min, dfa)
+        end
+
+      end # class MinimizeTest
+    end # module Minimize
+  end # class Automaton
+end # module Stamina
+