stamina 0.4.0 → 0.5.0

data/test/stamina/automaton/classifier_test.rb

@@ -1,259 +0,0 @@
-require 'test/unit'
-require 'stamina/adl'
-require 'stamina/stamina_test'
-module Stamina
-  class Automaton
-    # Tests Classifier module, as to be installed on Automaton.
-    class ClassifierTest < StaminaTest
-  
-      # Tests Classify#correctly_classified_by? is correct on valid sample against
-      # small_dfa example
-      def test_valid_sample_correctly_satified_by_small_dfa
-        assert_equal(true, @small_dfa.correctly_classify?(Sample.new))
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal '01100001100', sample.signature
-        assert_equal(true, @small_dfa.correctly_classify?(sample))
-        assert_equal sample.signature, @small_dfa.signature(sample)
-      end
-
-      # Tests Classify#correctly_classified_by? is correct on invalid sample against
-      # small_dfa example
-      def test_invalid_sample_correctly_classified_by_small_dfa
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          # this one is reversed
-          + b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal(false, @small_dfa.correctly_classify?(sample))
-        assert_equal '01100001100', @small_dfa.signature(sample)
-
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          # this one is changed
-          + z
-          - b z
-        SAMPLE
-        assert_equal(false, @small_dfa.correctly_classify?(sample))
-        assert_equal '01100001100', @small_dfa.signature(sample)
-
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          # this one is changed
-          - b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        assert_equal(false, @small_dfa.correctly_classify?(sample))
-        assert_equal '01100001100', @small_dfa.signature(sample)
-      end
-    
-      # Tests Classify#correctly_classify? is correct on valid sample against
-      # small_nfa example
-      def test_valid_sample_correctly_satified_by_small_nfa
-        assert_equal(true, @small_nfa.correctly_classify?(Sample.new))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          - a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(true, @small_nfa.correctly_classify?(sample))
-        assert_equal sample.signature, @small_nfa.signature(sample)
-      end
-  
-      # Tests Classify#correctly_classify? is correct on invalid sample against
-      # small_nfa example
-      def test_invalid_sample_correctly_satified_by_small_nfa
-        sample = ADL::parse_sample <<-SAMPLE
-          # this one is changed
-          -
-          + a
-          - a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, @small_nfa.correctly_classify?(sample))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          - a a
-          + a a b
-          # this one is changed
-          - a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, @small_nfa.correctly_classify?(sample))
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + a
-          # this one is changed
-          + a a
-          + a a b
-          + a b
-          + a b c a
-          - a b c
-          + a b b b b b b 
-          - a z
-          - z
-        SAMPLE
-        assert_equal(false, @small_nfa.correctly_classify?(sample))
-      end
-  
-      def test_scoring_on_valid_sample
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          + b
-          + b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          + b c a b
-          + b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        measures = @small_dfa.scoring(sample)
-        assert_equal(sample.positive_count, measures.true_positive)
-        assert_equal(0, measures.false_positive)
-        assert_equal(sample.negative_count, measures.true_negative)
-        assert_equal(0, measures.false_negative)
-        assert_equal(1.0, measures.precision)  
-        assert_equal(1.0, measures.recall)  
-        assert_equal(1.0, measures.sensitivity)  
-        assert_equal(1.0, measures.specificity)  
-        assert_equal(1.0, measures.accuracy)
-      end
-
-      def test_scoring_on_invalid_sample
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          - b
-          - b c
-          + b c a
-          + b c a c
-          + b c a c a
-          + b c a a
-          - b c a b
-          - b c a b c a c b
-          + z
-          + b z
-        SAMPLE
-        measures = @small_dfa.scoring(sample)
-        assert_equal(0.0, measures.true_positive)
-        assert_equal(sample.negative_count, measures.false_positive)
-        assert_equal(0.0, measures.true_negative)
-        assert_equal(sample.positive_count, measures.false_negative)
-        assert_equal(0.0, measures.precision)  
-        assert_equal(0.0, measures.recall)  
-        assert_equal(0.0, measures.sensitivity)  
-        assert_equal(0.0, measures.specificity)  
-        assert_equal(0.0, measures.accuracy)
-      end
-
-      def test_scoring_with_positive_only
-        sample = ADL::parse_sample <<-SAMPLE
-          +
-          + b
-          + b c
-          + b c a
-          + b c a c
-          + b c a c a
-          + b c a a
-          + b c a b
-          + b c a b c a c b
-          + z
-          + b z
-        SAMPLE
-        measures = @small_dfa.scoring(sample)
-        assert_equal(4.0, measures.true_positive)
-        assert_equal(sample.size-sample.positive_count, measures.false_positive)
-        assert_equal(0, measures.true_negative)
-        assert_equal(sample.size-4.0, measures.false_negative)
-        assert_equal(1.0, measures.precision)  
-        assert_equal(4.0/sample.size, measures.recall)  
-        assert_equal(4.0/sample.size, measures.sensitivity)  
-        #assert_equal(0.0/0.0, measures.specificity)  
-        assert_equal(4.0/sample.size, measures.accuracy)
-      end
-      
-      def test_scoring_with_negative_only
-        sample = ADL::parse_sample <<-SAMPLE
-          -
-          - b
-          - b c
-          - b c a
-          - b c a c
-          - b c a c a
-          - b c a a
-          - b c a b
-          - b c a b c a c b
-          - z
-          - b z
-        SAMPLE
-        measures = @small_dfa.scoring(sample)
-        assert_equal(0.0, measures.true_positive)
-        assert_equal(4.0, measures.false_positive)
-        assert_equal(sample.size-4.0, measures.true_negative)
-        assert_equal(0.0, measures.false_negative)
-        assert_equal(0.0, measures.precision)  
-        #assert_equal(0.0, measures.recall)  
-        #assert_equal(0.0, measures.sensitivity)  
-        assert_equal((sample.size-4.0)/sample.size, measures.specificity)  
-        assert_equal((sample.size-4.0)/sample.size, measures.accuracy)
-      end
-
-    end # class ClassifierTest
-  end # class Automaton
-end # module Stamina

data/test/stamina/automaton/complete_test.rb

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

@@ -1,120 +0,0 @@
-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/metrics_test.rb

@@ -1,36 +0,0 @@
-require 'test/unit'
-require 'stamina/adl'
-require 'stamina/stamina_test'
-module Stamina
-  class Automaton
-    class MetricsTest < StaminaTest
-
-      def test_alphabet_size
-        assert_equal 3, @small_dfa.alphabet_size
-      end
-
-      def test_avg_degree
-        assert_equal 6.to_f/4, @small_dfa.avg_degree
-      end
-
-      def test_avg_out_degree
-        assert_equal 6.to_f/4, @small_dfa.avg_out_degree
-      end
-
-      def test_avg_in_degree
-        assert_equal 6.to_f/4, @small_dfa.avg_in_degree
-      end
-
-      def test_accepting_ratio
-        assert_equal 0.5, @small_dfa.accepting_ratio
-      end
-
-      def test_depth
-        assert_equal 3, @small_dfa.depth
-        assert_equal 2, @small_nfa.depth
-      end
-
-    end
-  end
-end
-