fae 0.1.1 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OTQ4YmUyNTU0ODY2YjViODVkNjFkY2FmMzY4ZDM0NmVhZTUyMGFlYQ==
-  data.tar.gz: !binary |-
-    ZDVmMDY1NTE0ZTRiZTFlMzc2YzUyYTViYmI3NDAzYmUxZDM1OTg0MQ==
+SHA1:
+  metadata.gz: 0f109cfeb573be9efac846742d47aa671c7c1839
+  data.tar.gz: 04c261c86d6381f25b127c254687df95bb43a6be
 SHA512:
-  metadata.gz: !binary |-
-    OThiOTUyNTk5MDc2NzBkNzkyZjk3ZGM2M2VkNWJmOTkxNDEyZWI0MTZjNzkz
-    ZjFlMzIzMzk5YmRjNDkzOWMxMzM2ZWVmMjIwZGEyZjRjYTY1MGQxYzkwMWRi
-    MTY4NzdlOTQ3ZDAwZDVlMmEyMWYyZmM5ZTRmZGIzNzAxMmVkMmY=
-  data.tar.gz: !binary |-
-    MjA0NmJiZTFmYWQ3Njk0OTc0YzRlM2ZlM2YxNDljYjM2NGIyOTA0MDM4MzIy
-    OTA1OTNjMzhhNmZiNDI5NzRkYTA1OGNkYTYxY2YyMGM4NTU0YjhhMjNlYTQy
-    ZjEwZmZhYjE5NTIwNTM2OGQ1OWU5YzJiZTliMzIyNDA5NjQwNjg=
+  metadata.gz: 4a28786b8b6c65b38cf8660d7368749ccf283e211308e06698bc87bc85526fd523f2bea7741295f781c280a9a1078b66c1506752ea524a1f724304c6cbc002c5
+  data.tar.gz: c6369d569cfb2a877ccb3f6c90b37070184e53dd23228cadb292bd20becbb0d896eee936cef2f998e3767a60835f18c35e64e440c958ae6d8fde73e86864e2d1

data/README.md

@@ -2,7 +2,9 @@
 
 [![Gem Version](https://badge.fury.io/rb/fae.svg)](http://badge.fury.io/rb/fae)
 
-This is a small Ruby gem that evaluates a Finite Automata State Diagram for validity.
+This is a small Ruby gem that evaluates a Finite Automata State Diagram for validity, and can generate Finite Automata from set operations of two or more different Finite Automata.
+
+The gem currently only handles Deterministic Finite Automata.
 
 ## Dependencies
 
@@ -16,7 +18,7 @@ Install the gem by running the following command:
 gem install fae
 ```
 
-## Usage
+## Evaluation Usage
 
 The gem comes with an executable, `fae`, and can be run in two different modes, interactive or file.
 
@@ -138,6 +140,43 @@ If your state diagram is incorrect, the program will give you feedback about you
 
 This can help you figure out where your diagram is going wrong.
 
+## Generation Usage
+
+You can use the gem to generate the union, intersection, or difference of two state diagrams. See the following:
+
+```ruby
+fa_1 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings where the number of a's is odd")
+fa_2 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings that include the substring 'bb'")
+
+# These states were determined by drawing the state diagram.
+fa_1.add_states([
+  Fae::State.new('A', { :a => 'B', :b => 'A' }, false),
+  Fae::State.new('B', { :a => 'A', :b => 'B' }, true),
+])
+
+# These states were determined by drawing the state diagram.
+fa_2.add_states([
+  Fae::State.new('C', { :a => 'C', :b => 'D' }, false),
+  Fae::State.new('D', { :a => 'C', :b => 'E' }, false),
+  Fae::State.new('E', { :a => 'E', :b => 'E' }, true),
+])
+
+# Get the intersection, union, and difference of the two finite automata
+intersection = fa_1.intersection(fa_2)
+union        = fa_1.union(fa_2)
+difference   = fa_1.difference(fa_2)
+```
+
+You can then output the new finite automata to see the states, paths, and accepting states:
+
+```ruby
+puts intersection
+```
+
+![Example Intersection Output](https://raw.githubusercontent.com/caseyscarborough/fae/master/etc/example_intersection_output.png)
+
+See [`intersection_union_difference.rb`](https://github.com/caseyscarborough/fae/blob/master/examples/intersection_union_difference.rb) for an example of generating the diagram and evaluating them.
+
 ## Examples
 
 An example data file and direct API usage can be seen in the [examples directory](https://github.com/caseyscarborough/fae/tree/master/examples).

data/examples/intersection_union_difference.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+#
+# This script demonstrates the usage of the fae API and 
+# checks the state diagram for the intersection, union,
+# and difference of the following two languages:
+#
+# - The language of all strings with an odd number of a's
+# - The language of all strings that include the substring 'bb'
+#
+require_relative '../lib/fae'
+
+CHARACTERS = ['a', 'b']
+LANGUAGE = Fae::Language.new(CHARACTERS)
+
+def string_has_odd_number_of_the_letter_a?(string)
+  string.gsub('b', '').length % 2 == 1
+end
+
+def string_has_bb_substring?(string)
+  !string.match(/bb/).nil?
+end
+
+def valid_for_intersection?(string)
+  string_has_odd_number_of_the_letter_a?(string) && string_has_bb_substring?(string)
+end
+
+def valid_for_union?(string)
+  string_has_odd_number_of_the_letter_a?(string) || string_has_bb_substring?(string)
+end
+
+def valid_for_difference?(string)
+  string_has_odd_number_of_the_letter_a?(string) && !string_has_bb_substring?(string)
+end
+
+# Returns 100 random strings in the language, 50 of length 15 and 50 of length 5.
+def get_random_strings
+  generate_string = lambda do |num|
+    string = ""
+    num.times { string << CHARACTERS.sample }
+    string
+  end
+
+  strings = []
+  50.times { strings << generate_string.call(15) }
+  50.times { strings << generate_string.call(5) }
+  strings
+end
+
+fa_1 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings where the number of a's is odd")
+fa_2 = Fae::FiniteAutomata.new(LANGUAGE, "the language of all strings that include the substring 'bb'")
+
+# These states were determined by drawing the state diagram language 1.
+fa_1.add_states([
+  Fae::State.new('A', { :a => 'B', :b => 'A' }, false),
+  Fae::State.new('B', { :a => 'A', :b => 'B' }, true),
+])
+
+# These states were determined by drawing the state diagram for language 2.
+fa_2.add_states([
+  Fae::State.new('C', { :a => 'C', :b => 'D' }, false),
+  Fae::State.new('D', { :a => 'C', :b => 'E' }, false),
+  Fae::State.new('E', { :a => 'E', :b => 'E' }, true),
+])
+
+# Perform the intersection
+intersection = fa_1.intersection(fa_2)
+get_random_strings.each { |s| intersection.add_string(String.new(s, valid_for_intersection?(s))) }
+intersection.evaluate!
+
+# Perform the union
+union = fa_1.union(fa_2)
+get_random_strings.each { |s| union.add_string(String.new(s, valid_for_union?(s))) }
+union.evaluate!
+
+# Perform the difference
+difference = fa_1.difference(fa_2)
+get_random_strings.each { |s| difference.add_string(String.new(s, valid_for_difference?(s))) }
+union.evaluate!

data/lib/fae/finite_automata.rb

@@ -5,6 +5,7 @@ module Fae
   # Takes in a language, states, and strings, and checks them
   # to validate a state diagram.
   class FiniteAutomata
+    attr_reader :language, :description, :states, :strings
     
     # Initializes a new instance of the FiniteAutomata.
     #
@@ -27,6 +28,13 @@ module Fae
       end
     end
 
+    # Adds a single string to the strings array.
+    #
+    # @param string [String] the string to add
+    def add_string(string)
+      @strings << string
+    end
+    
     # Adds strings to check against when evaluating.
     #
     # @param states [Array] an array of states
@@ -53,6 +61,30 @@ module Fae
       return retrieved_state
     end
 
+    # Generates the finite automata for the intersection
+    # of two different finite automatas.
+    #
+    # @param fa [FiniteAutomata] the finite automata to intersect this one with
+    def intersection(fa)
+      perform_set_operation(:intersection, fa)
+    end
+
+    # Generates the finite automata for the union
+    # of two different finite automatas.
+    #
+    # @param fa [FiniteAutomata] the finite automata to union this one with
+    def union(fa)
+      perform_set_operation(:union, fa)
+    end
+
+    # Generates the finite automata for the difference
+    # of two different finite automatas.
+    #
+    # @param fa [FiniteAutomata] the finite automata to difference this one with
+    def difference(fa)
+      perform_set_operation(:difference, fa)
+    end
+
     # Runs the evaluation on the finite automata.
     def evaluate!
       @invalids = []
@@ -84,7 +116,55 @@ module Fae
       puts
     end
 
+    def to_s
+      output = ""
+      output << "Description: ".colorize(:yellow) + @description
+      output << "\nLanguage: ".colorize(:yellow) + language.characters.to_s
+      output << "\nStates:".colorize(:yellow)
+      @states.each do |state|
+        output << "\n  State #{state.name}: ".colorize(:blue)
+        state.paths.keys.each do |key|
+          output << "\n    #{'~'.colorize(:yellow)} #{key} #{'->'.colorize(:light_black)} #{state.paths[key]}"
+        end
+        accepting = state.accepting ? "accepting".colorize(:green) : "not accepting".colorize(:red)
+        output << "\n    #{'~'.colorize(:yellow)} #{accepting}"
+      end
+      return output
+    end
+
   private
+    def perform_set_operation(type, fa)
+      if (@language.characters.uniq.sort != fa.language.characters.uniq.sort)
+        puts "Performing the #{type.to_s} requires the languages to be the same.".colorize(:red)
+        return 
+      end
+      i_states  = []
+      i_strings = []
+      i_description = "the #{type.to_s} of #{@description} and #{fa.description}"
+      i_fa = FiniteAutomata.new(@language, i_description)
+
+      @states.each do |state|
+        fa.states.each do |fa_state|
+          name = state.name + fa_state.name
+          accepting = false
+          paths = {}
+          state.paths.keys.each do |key|
+            path = state.paths[key] + fa_state.paths[key]
+            paths[key] = path
+          end
+          if ((type == :intersection && (state.accepting && fa_state.accepting)) || 
+              (type == :difference && (state.accepting && !fa_state.accepting )) ||
+              (type == :union && (state.accepting || fa_state.accepting)))
+            accepting = true
+          end
+          i_states << State.new(name, paths, accepting)
+        end
+      end
+
+      i_fa.add_states(i_states)
+      return i_fa
+    end
+
     def add_state(new_state)
       valid = true
       @states.each do |state|
@@ -99,7 +179,7 @@ module Fae
       print "#{string.colorize(:blue)}: "
       if (@language.string_is_valid(string))
         result = @states.first.evaluate(string, self)
-        if (result[:valid] != string.expected)
+        if (result[:accepting] != string.expected)
           puts "\u2717".encode("utf-8").colorize(:red)
           return false
         else

data/lib/fae/state.rb

@@ -2,7 +2,7 @@ module Fae
 
   # A state in the state diagram.
   class State
-    attr_accessor :name, :next_states, :valid
+    attr_accessor :name, :paths, :accepting
 
     # Creates a new state instance.
     #
@@ -11,24 +11,27 @@ module Fae
     # @param valid [Boolean] whether or not this is an accepting state
     # @example
     #   State.new('A', { :a => 'B', :b => 'A' }, true)
-    def initialize(name, next_states, valid)
+    def initialize(name, paths, accepting)
       @name = name
-      @next_states = next_states
-      @valid = valid
+      @paths = paths
+      @accepting = accepting
     end
 
-    # Evaluates a string at this state, and passes it to the next state.
+    # Evaluates a string at this state, and passes the next string to the next state.
     #
     # @param string [String] the string to evaluate
     # @param fa [FiniteAutomata] the finite automata that this state belongs to
     def evaluate(string, fa)
       if (string.first.empty?)
-        output = @valid ? "valid".colorize(:green) : "invalid".colorize(:red)
+        output = @accepting ? "accepting".colorize(:green) : "not accepting".colorize(:red)
         print "#{@name} (#{output}) "
-        return { :output => output, :valid => @valid }
+        return { :output => output, :accepting => @accepting }
       end
       print "#{@name} #{'->'.colorize(:light_black)} "
-      fa.get_state(next_states[string.first.to_sym]).evaluate(string.shift_left, fa)
+      
+      next_state  = fa.get_state(paths[string.first.to_sym])
+      next_string = string.shift_left
+      next_state.evaluate(next_string, fa)
     end
   end
 end

data/lib/fae/version.rb

@@ -1,3 +1,3 @@
 module Fae
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: fae
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Casey Scarborough
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-08 00:00:00.000000000 Z
+date: 2014-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: colorize
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: ''
@@ -60,7 +60,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -69,9 +69,11 @@ files:
 - etc/example_failed_output.png
 - etc/example_file_mode_output.png
 - etc/example_interactive_mode_output.png
+- etc/example_intersection_output.png
 - etc/example_state_diagram.png
 - examples/diagrams.yml
 - examples/example.rb
+- examples/intersection_union_difference.rb
 - fae.gemspec
 - lib/fae.rb
 - lib/fae/finite_automata.rb
@@ -89,12 +91,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []