automaton 0.0.1

data/lib/tex/multido.sty

@@ -0,0 +1,27 @@
+%%
+%% This is file `multido.sty'.
+%%
+%% IMPORTANT NOTICE:
+%%
+%% multido.sty Copyright (C) 1997 Timothy Van Zandt
+%%                       (C) 2004 Herbert Voss <voss@perce.de>
+%%                                Rolf Niepraschk <Rolf.Niepraschk@ptb.de>
+%%
+%% This package may be distributed under the terms of the LaTeX Project 
+%% Public License, as described in lppl.txt in the base LaTeX distribution.
+%% Either version 1.0 or, at your option, any later version.
+%%
+
+\ProvidesPackage{multido}
+  [2004/05/17 package wrapper for PSTricks `multido.tex', (HV/RN)]
+
+\@ifundefined{MultidoLoaded}
+{%
+  \input{multido.tex}
+  \ProvidesFile{multido.tex}
+    [\filedate\space v\fileversion\space `multido' (tvz)]
+}{}
+
+\endinput
+%%
+%% End of file `multido.sty'.

data/lib/tex/template.tex

@@ -0,0 +1,24 @@
+\documentclass{report}
+
+\usepackage{vaucanson-g}
+
+\begin{document}
+\begin{VCPicture}{(0,0)(10, 10)}
+  
+  % states
+  %\State[p]{(0,0)}{A} \State{(3,0)}{B} \State[r]{(6,0.5)}{C}
+  <%= @states.join("\n")%>
+ 
+  % initial--final
+  % \Initial{A}
+  <%= @initial %>
+  
+  % \Final{C}
+  <%= @finals.join("\n")%>
+
+  % transitions
+  %\EdgeL{B}{A}{a} \EdgeL{B}{C}{b}
+  <%= @transitions.join("\n") %>
+  
+\end{VCPicture}
+\end{document}

data/lib/tex/vaucanson-g.sty

@@ -0,0 +1,14 @@
+\ProvidesPackage{vaucanson-g}[2003/05/09 package wrapper for Vaucanson-G]
+\DeclareOption{slides}{\AtEndOfPackage{\input VCPref-slides.tex}}
+\ProcessOptions
+\RequirePackage{ifthen}
+\RequirePackage[usenames]{pstcol}
+\RequirePackage{pst-node}
+\RequirePackage{pst-plot}
+\RequirePackage{pst-coil}
+%\RequirePackage{multido}
+\RequirePackage{pst-3d}
+\RequirePackage{color}
+\RequirePackage{calc}
+\input Vaucanson-G.tex
+\endinput

data/spec/automaton_spec.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'automaton'
+
+describe Automaton do
+  
+  it "can be pruned" do
+    automata = Automaton.create(:a, :b, {:a => {'1' => [:b], '2' => [:d]}, :c => {'3' => [:b]}})
+    expected = Automaton.create(:a, :b, {:a => {'1' => [:b], '2' => [:d]}})
+    automata.prune.should == expected
+  end
+  
+  it "has successors" do
+    automata = Automaton.create(:a, :b, {:a => {'1' => [:b, :c], '2' => [:d]}, :c => {'3' => [:b]}})
+    automata.successors_of(:a).should == Set[:b, :c, :d]
+    automata.successors_of(:b).should == Set.new
+    automata.successors_of(:c).should == Set[:b]
+  end
+  
+  it "has start state and final states" do
+    automata = Automaton.create(:a, :b, {:a => {'1' => [:b, :c], '2' => [:d]}, :c => {'3' => [:b]}})
+    automata.start.should == :a
+    automata.finals.should == Set[:b]
+  end
+  
+  it "is comparable" do
+    a = Automaton.create(:a, :b, '1' => {:a => :b})
+    b = Automaton.create(:a, :b, '1' => {:a => :b})
+    a.should == b
+  end
+  
+  it "is taggable" do
+    automata = Automaton.create(:a, :b, :a => {'1' => [:b, :c]})
+    automata.tag(:left).should == Automaton.create(:a_left, [:b_left], :a_left => {'1' => [:b_left, :c_left]})
+  end
+  
+  it "has reachable states" do
+    automata = Automaton.create(:a, :b, {:a => {'1' => [:b, :c], '2' => [:d]}, :x => {'3' => [:a]}})
+    automata.reachable_states.should == Set[:a, :b, :c, :d]
+  end
+  
+  #NOTE This is meaningless now that the states are stored as a set
+  it "does not repeat reachable states" do
+    automata = Automaton.create(:a, :a, {:a => {'1' => [:a]}})
+    automata.reachable_states.should == Set[:a]
+  end
+  
+  it "can deal with loops on reachable states" do
+    automata = Automaton.create(:a, :x, {:a => {'1' => [:b]}, :b => {'1' => [:a]}})
+    automata.reachable_states.should == Set[:a, :b]
+  end
+  
+  it "has an alphabet" do 
+    automata = Automaton.create(:a, :b, :a => {'1' => :b, '2' => :x}, 
+    :b => {'1' => :x, '2' => :c}, 
+    :x => {'1' => :x, '2' => :x})
+    automata.alphabet.should == Set['1', '2']
+  end
+  
+  it "has transitions" do 
+    automaton = Automaton.create(:a, :b, :a => {'1' => [:b, :c], '2' => [:d]}, :b => {'3' => [:f]})
+    one = Automaton::Transition.new(:a, Set[:b, :c], '1')
+    two = Automaton::Transition.new(:a, Set[:d], '2')
+    three = Automaton::Transition.new(:b, Set[:f], '3')
+    automaton.transitions.to_set.should == Set[one, two, three]
+  end
+  
+  it "may not accept any strings" do
+    Automaton.create(:a, [:b], :a => {'1' => :b}).should be_accepting
+    Automaton.create(:a, [], :a => {'1' => :b}).should_not be_accepting
+    Automaton.create(:a, [:b], :a => {'1' =>:c}).should_not be_accepting
+  end
+  
+  it "has a complement" do
+    automata = Automaton.create(:a, :b, {:a => {'1' => [:b, :c], '2' => [:d]}, :c => {'3' => [:b]}})
+    automata.complement.complement.should == automata
+    automata.complement.finals.should == Set[:a,:c,:d]
+  end
+  
+  it "has intersection for total DFA" do
+    one = Automaton.create(:a, :b, :a => {'1' => :b, '2' => :a}, :b => {'1' => :b, '2' => :b})
+    two = Automaton.create(:x, [:x, :y], :x => {'1' => :y, '2' => :x}, :y => {'1' => :x, '2' => :y})
+    product = Automaton.create(:a_x, [:b_x, :b_y], :a_x => {'1' => :b_y, '2' => :a_x},
+                                              :b_x => {'1' => :b_y, '2' => :b_x},
+                                              :b_y => {'1' => :b_x, '2' => :b_y})
+    one.intersect(two).should == product
+  end
+
+  it "has intersection for NFA" do
+    one = Automaton.create(:a, :b, :a => {'2' => :a}, :b => {'1' => :b, '2' => [:a,:b]})
+    two = Automaton.create(:x, [:x, :y], :x => {'1' => :y, '2' => :x}, :y => {'1' => :x, '2' => :y})
+    product = Automaton.create(:a_x, [:b_x, :b_y], :a_x => {'2' => :a_x},
+                                              :a_y => {'2' => :a_y},
+                                              :b_x => {'1' => :b_y, '2' => [:a_x,:b_x]},
+                                              :b_y => {'1' => :b_x, '2' => [:a_y,:b_y]})
+    one.intersect(two).should == product
+  end
+  
+  it "subtracts another automata from itself" do
+    one = Automaton.create(:a, [:b], :a => {'1' => [:b]})
+    one_two = Automaton.create(:a, [:b, :c], {:a => {'1' => :b, '2' => :c}})
+     (one_two - one).should be_accepting
+     (one - one_two).should_not be_accepting
+     (one - one).should_not be_accepting
+  end
+ 
+  it "can be made total" do
+    input = [:a, :b, {:a => {'1' => [:b,:c]}}]
+    automata = Automaton.create(*input)
+    total_automata = Automaton.create(:a, :b, :a => {'1' => [:b,:c], '2' => :x},
+                                         :b => {'1' => :x, '2' => :x},
+                                         :c => {'1' => :x, '2' => :x},
+                                         :x => {'1' => :x, '2' => :x})
+    automata.to_total(Set['1','2']).should == total_automata
+    automata.to_total(Set['1','2']).to_total(Set['1','2']).should == automata.to_total(Set['1','2'])
+  end
+  
+  it "is comparable to other automata" do
+    a = Automaton.create(:a, [:b], :a => {'1' => :b})
+    b = Automaton.create(:a, [:b], :a => {'2' => :b})
+    a.should_not be_accepting_same_language_as(b)
+    a.should be_accepting_same_language_as(a)
+
+    a = Automaton.create(:a, [:b], :a => {'1' => :b})
+    b = Automaton.create(:a, [:b], :a => {'1' => :b})
+    a.should be_accepting_same_language_as(b)
+    
+  end
+  
+  it "determines if it accepts a subset of the lanugage of other automata" do
+    small = Automaton.create(:a, [:b], {:a => {'1' => :b}})
+    medium = Automaton.create(:a, [:b, :c], {:a => {'1' => :b}, :b => {'2' => :c}})
+    large = Automaton.create(:a, [:b, :c], {:a => {'1' => :b, '2' => :c}, :b => {'1' => :c}})
+    
+    small.subset?(medium).should be_true
+    small.subset?(large).should be_true
+    large.subset?(large).should be_true
+    medium.subset?(small).should be_false
+    large.subset?(medium).should be_false
+    small.subset?(small).should be_true
+    medium.subset?(medium).should be_true
+    large.subset?(large).should be_true
+  end
+  
+  it "has a latex representation" do
+    small = Automaton.create(:a, :b, :a => {'1' => :b})
+    latex = Automaton::Latex.new(:a, [:b], [[:a, 0, 0], [:b, 1, 1]], [[:a, :b, '1']])
+    small.to_tex.should == latex
+  end
+end
+
+describe Automaton::Graph do
+  
+  it "allows a state to have no transitions" do
+    tf = Automaton::Graph.new
+    tf[:a].should == {}
+    tf[:a]='b'
+    tf[:a].should == 'b'
+    hash = {:b => {'2' => Set[:c]}}
+    Automaton::Graph.from_hash(hash)[:a].should_not == hash[:a]
+    Automaton::Graph.from_hash(hash)[:b].should == hash[:b]
+  end
+  
+  it "can merge two hashes of transitions" do
+    t1 = {}
+    t2 = {'1' => Set[:a]}
+    Automaton::Graph.merge_transitions(t1,t2).should == t2
+  end
+  
+  it "can merge in another transition function" do
+    tf1 = Automaton::Graph.from_hash({:a => {'1' => [:a,:b]}})
+    tf2 = Automaton::Graph.from_hash({:a => {'1' => [:a,:c]}})
+    tf3 = Automaton::Graph.from_hash({:b => {'1' => [:a,:c]}})
+    tf1.merge(tf1).should == tf1.merge(tf1)
+    tf2.merge(tf2).should == tf2.merge(tf2)
+    tf2.merge(tf1).should == tf1.merge(tf2)
+    tf2.merge(tf3).should == Automaton::Graph.from_hash({:b => {'1' => [:a,:c]}, :a => {'1' => [:a,:c]}})
+    tf1.merge(tf2).class.should == Automaton::Graph
+  end
+
+end

data/spec/layout_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'layout'
+
+Node = Automaton::Layout::Node
+describe Automaton::Layout do
+  before(:all) do
+    @a = Node.new(:a, 0, 0)
+    @b = Node.new(:b, 0, 1)
+    @c = Node.new(:c, 16, 0)
+    @a.connect(@b, @c)
+  end
+
+  it "does force direction" do
+    graph = Automaton::Layout.new(@a, @b, @c)
+    graph.nodes.size.should == 3
+    graph.force_direct
+    graph.normalize
+    graph.nodes.size.should == 3
+  end
+
+  describe Automaton::Layout::Node do 
+
+    before(:all) do
+      @a = Node.new(:a, 0, 0)
+      @b = Node.new(:b, 0, 1)
+      @c = Node.new(:c, 4, 0)
+      @a.connect(@b, @c)
+    end
+    
+    it "has repulsion" do 
+      @a.repulsion(@b).should be_close_to_enum(Vector[0, 0.23], 0.01)
+      @a.repulsion(@c).should == -@c.repulsion(@a)
+      @a.repulsion(@c).should be_close_to_enum(Vector[0.0149, 0], 0.01)
+    end
+    
+    it "has attraction" do
+      @a.attraction(@b).should be_close_to_enum(Vector[0,  -0.8], 0.01)
+      @a.attraction(@c).should be_close_to_enum(Vector[0.4, 0], 0.01)
+      @a.attraction(@c).should == -@c.attraction(@a)
+      @b.attraction(@c).should be_close_to_enum(Vector[0, 0], 0.01)
+    end
+
+    it "has vector to other node" do 
+      @a.vector(@b).should be_close_to_enum(Vector[0.0, 1.0])
+      @a.vector(@c).should be_close_to_enum(Vector[4.0, 0.0])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+
+module EnumerableMatchers #:nodoc:
+  class BeCloseToEnum #:nodoc:
+    def initialize(expected, delta)
+      @expected = expected
+      @delta = delta
+    end
+    
+    def matches?(actual)
+      @actual = actual
+      return false if actual.nil?
+      return false unless @actual.size == @expected.size
+      @actual.to_a.zip(@expected.to_a).all? do |actual_item, expected_item|
+        (actual_item - expected_item).abs < @delta
+      end
+    end
+    
+    def failure_message
+        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
+    end
+    
+    def description
+        "be close to #{@expected} (within +- #{@delta})"
+    end
+  end
+  
+  
+  def be_close_to_enum(expected, delta = 1.0e-014)
+    BeCloseToEnum.new(expected, delta)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include(EnumerableMatchers)
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: automaton
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tor Erik Linnerud
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-16 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rtex
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+description: 
+email: tel@jklm.no
+executables: 
+- tex2pdf
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/layout.rb
+- lib/latex.rb
+- lib/automaton.rb
+- lib/generate.rb
+- lib/ruby_extensions.rb
+- lib/tex/template.tex
+- lib/tex/VCPref-main.tex
+- lib/tex/multido.sty
+- lib/tex/FinalStateVar.tex
+- lib/tex/vaucanson-g.sty
+- lib/tex/Vaucanson-G.tex
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/layout_spec.rb
+- spec/automaton_spec.rb
+- README
+has_rdoc: true
+homepage: http://www.jklm.no/automation
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: automaton
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Implementation of automata, supporting visualization and regular language operations
+test_files: 
+- spec/layout_spec.rb
+- spec/automaton_spec.rb