rlsm 0.4.0 → 1.0.0

data/Manifest.txt

@@ -3,8 +3,16 @@ Manifest.txt
 README.txt
 Rakefile
 bin/smon
-lib/data/monoids.db
-lib/dfa.rb
-lib/monoid.rb
-lib/re.rb
+data/monoids.db
+lib/database.rb
+lib/monkey_patching/array_ext.rb
 lib/rlsm.rb
+lib/rlsm/dfa.rb
+lib/rlsm/monoid.rb
+lib/rlsm/re.rb
+lib/smon/base.rb
+lib/smon/db.rb
+lib/smon/dot.rb
+lib/smon/latex.rb
+lib/smon/smon.rb
+stdarb.tex

data/bin/smon

@@ -1,2 +1,39 @@
-#! /usr/bin/env ruby
-puts "Comming soon"
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'smon', 'smon')
+require 'optparse'
+
+Version = RLSM::VERSION
+out = STDOUT
+path = ""
+
+opts = OptionParser.new do |op|
+  op.banner = <<USEAGE
+Usage: smon [-oh] [FILE1 FILE2 ...]
+Executes each FILE as smon script or if no file is given
+starts in interactive mode.
+
+USEAGE
+  op.separator("Options:")
+
+  op.on('-p','--path PATH', "Adds PATH to the loadpath for librarys.") do |p|
+    path = p
+  end
+
+  op.on('-o', '--out FILE', "Output is redirected to FILE.") do |f|
+    out = File.open(f, 'w')
+  end
+
+  op.on_tail('-h', '--help', "This help.") { puts op; exit }
+  op.on_tail('--version', "Shows version.") { puts op.ver }
+end
+
+begin
+  opts.parse! ARGV
+
+  SMON.new :files =>ARGV, :messenger => out, :path => path
+rescue => e
+  STDERR.puts "Error: #{e.message}"
+  STDERR.puts
+  STDERR.puts opts
+  exit 1
+end

data/lib/database.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'rlsm'))
+
+require "rubygems"
+require "sqlite3"
+
+class RLSM::MonoidDB
+  @@db = SQLite3::Database.open(File.join(File.dirname(__FILE__), '..',
+                                          'data', 'monoids.db'))
+
+  Columns = [:binop, :m_order, :num_generators,
+             :num_idempotents, :num_left_nulls, :num_right_nulls,
+             :syntactic, :idempotent, :aperiodic,
+             :commutative, :is_group, :has_null,
+             :l_trivial, :r_trivial, :d_trivial]
+
+  def self.query(query, &block)
+    if block_given?
+      @@db.execute(query, &block)
+    else
+      @@db.execute(query)
+    end
+  end
+
+  def self.find(params = {}, &block)
+    if block_given?
+      query construct_query(params), &block
+    else
+      query construct_query(params)
+    end
+  end
+
+  def self.count(params = {})
+    q = construct_query(params).sub('T binop F',
+                                    "T count(*), total(syntactic) F")
+    query(q).first.map { |x| x.to_i }
+  end
+
+  def self.statistic
+    res = @@db.execute2 <<SQL
+SELECT
+m_order AS 'Order',
+count(*) AS 'Total',
+total(syntactic) AS 'Syntactic',
+total(is_group) AS 'Groups',
+total(commutative) AS 'Commutative',
+total(aperiodic) AS 'Aperiodic',
+total(idempotent) AS 'Idempotent'
+FROM monoids
+GROUP BY m_order
+ORDER BY 'Order' ASC;
+SQL
+
+    desc  = res.shift
+    res.map! { |row| row.map { |x| x.to_i } }
+    res.unshift desc
+
+    res
+  end
+
+  private
+  def self.construct_query(params)
+    limit = ""
+    if params[:limit]
+      limit = "\nLIMIT #{params[:limit]}"
+      params.delete :limit
+      if params[:offset]
+        limit += " OFFSET #{params[:offset]}"
+      end
+    end
+
+    order_by = "\nORDER BY binop #{params[:ordering] || 'ASC'}"
+
+    params.delete :ordering
+
+    q = "SELECT binop FROM monoids"
+
+    where = Columns.inject([]) do |res,col|
+      if params[col]
+        if [:binop, :m_order].include?(col) or col.to_s =~ /^num_/
+          res << "#{col.to_s} = #{params[col]}"
+        else
+          res << "#{col.to_s} = 1"
+        end
+      end
+
+      res
+    end.join(" AND ")
+
+    if where.length > 0
+      q += "\nWHERE " + where
+    end
+
+    q + order_by + limit + ";"
+  end
+end

data/lib/monkey_patching/array_ext.rb

@@ -0,0 +1,50 @@
+module RLSMArrayExt # :nodoc:
+  #Returns all permutations of the array.
+  def permutations
+    return [self] if size < 2
+    perm = []
+    each { |e| (self - [e]).permutations.each { |p| perm << ([e] + p) } }
+    perm
+  end
+
+  #Returns the powerset of the array (interpreted as set).
+  def powerset
+    ret = self.inject([[]]) do |acc, x|
+      res = []
+      acc.each { |s| res << s; res << ([x]+s).sort }
+      res
+    end
+
+    ret.sort_lex
+  end
+
+  #Sorts an array of arrays more or less lexicographical.
+  def sort_lex
+    sort { |s1, s2| s1.size == s2.size ? s1 <=> s2 : s1.size <=> s2.size }
+  end
+
+  #Returns the cartesian product of self and the given arrays
+  def product(*args)
+    args.inject(self.map { |x| [x] }) do |res,arr|
+      new = []
+      arr.each do |x|
+        new += res.map  { |tup| tup += [x] }
+      end
+      new
+    end
+  end
+
+  #Returns all unordered pairs.
+  def unordered_pairs
+    pairs = []
+    (0...size-1).each do |i|
+      pairs |= self[i+1..-1].map { |x| [self[i],x] }
+    end
+
+    pairs
+  end
+end
+
+class Array # :nodoc:
+  include RLSMArrayExt
+end

data/lib/rlsm.rb

@@ -1,7 +1,9 @@
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
+require 'monkey_patching/array_ext'
+
 module RLSM
-  VERSION = '0.4.0'
+  VERSION = '1.0.0'
 end
 
 #Setting up the exception classes.
@@ -10,51 +12,6 @@ class MonoidException < RLSMException; end
 class DFAException < RLSMException; end
 class REException < RLSMException; end
 
-#--
-#Monkey patching the Array class
-class Array # :nodoc:
-  #Returns all permutations of the array.
-  def permutations
-    return [self] if size < 2
-    perm = []
-    each { |e| (self - [e]).permutations.each { |p| perm << ([e] + p) } }
-    perm
-  end
-
-  #Returns the powerset of the array (interpreted as set).
-  def powerset
-    ret = self.inject([[]]) do |acc, x|
-      res = []
-      acc.each { |s| res << s; res << ([x]+s).sort }
-      res
-    end
-
-    ret.sort_lex
-  end
-
-  #Sorts an array of arrays more or less lexicographical.
-  def sort_lex
-    sort { |s1, s2| s1.size == s2.size ? s1 <=> s2 : s1.size <=> s2.size }
-  end
-
-  #Returns the cartesian product of self and the given arrays
-  def product(*args)
-    args.inject(self.map { |x| [x] }) do |res,arr|
-      new = []
-      arr.each do |x|
-        new += res.map  { |tup| tup += [x] }
-      end
-      new
-    end
-  end
-
-  #Returns all unordered pairs.
-  def unordered_pairs
-    pairs = []
-    (0...size-1).each do |i|
-      pairs |= self[i+1..-1].map { |x| [self[i],x] }
-    end
-
-    pairs
-  end
-end
+require 'rlsm/monoid'
+require 'rlsm/dfa'
+require 'rlsm/re'

data/lib/{dfa.rb → rlsm/dfa.rb}

@@ -1,6 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'rlsm'))
-require 'monoid'
-require "re"
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rlsm'))
 
 =begin rdoc
 ==Basic theory of deterministic finite automaton (short DFA)
@@ -160,6 +158,16 @@ It is required that all occuring states are in the states array and all transiti
 
   attr_reader :alphabet, :states, :initial_state, :finals
 
+  #Returns an Array with 3-tuples as transitions.
+  def transitions
+    res = []
+    @alphabet.each do |letter|
+      res |= @transitions[letter].to_a.map { |x| [letter] + x }
+    end
+
+    res
+  end
+
   #Returns the number of states.
   def num_states
     @states.size
@@ -338,7 +346,7 @@ Minimizes the DFA. Takes as optional parameter a hash with only processed key :+
 
   #Returns the transition monoid of the DFA.
   def transition_monoid
-    RLSM::Monoid.new get_binary_operation, :rename_elements => true
+    RLSM::Monoid.new get_binary_operation, :rename => true
   end
 
   #Returns the transition monoid of the equivalent minimal DFA.
@@ -346,6 +354,16 @@ Minimizes the DFA. Takes as optional parameter a hash with only processed key :+
     minimize.transition_monoid
   end
 
+  #Synonym for syntactic_monoid
+  def to_monoid
+    syntactic_monoid
+  end
+
+  #Returns self.
+  def to_dfa
+    self
+  end
+
   #Returns a RE which represents the same language.
   def to_re
     les = []
@@ -360,6 +378,49 @@ Minimizes the DFA. Takes as optional parameter a hash with only processed key :+
     simplify_les_row(les.pop)[:final]
   end
 
+  def inspect
+    "<#{self.class}: #{@states.join(',')}>"
+  end
+
+  def to_s
+    output = []
+    output << @states.inject(['']) do |res, state|
+      prefix = ''
+      prefix += '*' if @finals.include? state
+      prefix += '->' if initial_state == state
+
+      res + [prefix + ' ' + state + ' ']
+    end
+
+    @alphabet.each do |letter|
+      column = [' ' + letter + ' ']
+      @states.each do |state|
+        tmp = self[letter,state]
+        if tmp.nil?
+          column << ' nil '
+        else
+          column << ' ' + tmp + ' '
+        end
+      end
+
+      output << column.clone
+    end
+
+    #Align output
+    output.map! do |col|
+      max_length = col.map { |x| x.length }.max
+      col.map { |x| ' '*(max_length - x.length) + x }
+    end
+
+    rows = (0..@states.size).map { |i| output.map { |col| col[i] } }
+    rows.map! { |row| row.join('|') }
+    head = rows.shift
+    rows.unshift head.scan(/./).map { |c| c == '|' ? '+' : '-' }.join
+    rows.unshift head
+
+    rows.join("\n")
+  end
+
   private
   def initialize_row_for(state)
     row = { :state => state.clone }

data/lib/{monoid.rb → rlsm/monoid.rb}

@@ -1,5 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'rlsm'))
-require 'dfa'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rlsm'))
 
 =begin rdoc
 =The RLSM::Monoid class
@@ -548,7 +547,7 @@ Returns true if the monoid is aperiodic. (A synonym for h_trivial?)
   end
 
   def inspect # :nodoc:
-    "<#{self.class} : {#{@elements.join(',')}}; #{to_s}>"
+    "<#{self.class}: #{to_s}>"
   end
 
 =begin rdoc
@@ -638,9 +637,22 @@ Also if the monoid is syntactic the set returned by disjunctive subset will be u
       end
     end
 
-    RLSM::DFA.create(:initial => neutral_element,
-                     :finals => finals,
-                     :transitions => get_transitions)
+    dfa = RLSM::DFA.create(:initial => neutral_element,
+                           :finals => finals,
+                           :transitions => get_transitions)
+    dfa.rename_states
+
+    dfa
+  end
+
+  #Returns itself.
+  def to_monoid
+    self
+  end
+
+  #Returns the regexp for the language.
+  def to_re
+    to_dfa.to_re
   end
 
   private

data/lib/{re.rb → rlsm/re.rb}

@@ -1,6 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'rlsm'))
-require 'dfa'
-
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rlsm'))
 require 'enumerator'
 
 class RLSM::RE
@@ -11,6 +9,10 @@ class RLSM::RE
   Lambda = '&'
   Specials = [LeftBracket, RightBracket, Star, Union, Lambda]
 
+  def to_s
+    @pattern
+  end
+
   def inspect
     "<#{self.class}: #@pattern>"
   end
@@ -86,6 +88,16 @@ class RLSM::RE
     end
   end
 
+  #Returns the syntactic monoid to this language.
+  def to_monoid
+    to_dfa.to_monoid
+  end
+
+  #Returns self.
+  def to_re
+    self
+  end
+
   #Returns true if the res are equal
   def ==(other)
     return true if @pattern == other.pattern
@@ -158,7 +170,7 @@ class RLSM::RE
 
   def recursive_split(child, type)
     if type_of(child) == type
-      return self.send "split_#{type}".to_sym, child
+      return self.send("split_#{type}".to_sym, child)
     else
       return [child]
     end