rlsm 0.4.0 → 1.0.0

data/lib/smon/smon.rb

@@ -0,0 +1,183 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'rlsm'))
+
+class SMON
+  def self.tmp_filename
+    "tmp" + Time.now.to_s.gsub(/[ :+]/, '')
+  end
+
+  def self.add_help(desc)
+    name = desc.delete(:name).to_s
+    @@__help[name] = desc
+  end
+
+  @@__help = {}
+
+  def initialize(args = {:files => []})
+    puts "Welcome to SMON (v#{RLSM::VERSION})"
+
+    #Setting up internal variables
+    @out = args[:messenger] || STDOUT
+
+    if args[:path]
+      @loadpath = [File.expand_path(File.dirname(__FILE__))] +
+        args[:path].split(':').map { |f| File.expand_path(f) }
+    else
+      @loadpath = [File.expand_path(File.dirname(__FILE__))]
+    end
+
+    @objects = []
+    @__cmds = []
+
+    #Set up internal help system.
+    SMON.add_help :type => 'cmd',
+    :name => 'help',
+    :summary => 'Shows help for commands.',
+    :usage => 'help [<cmd>]',
+    :description => <<DESC
+If no argument is given, displays an overview of all availible
+commands.
+
+The optional <cmd> parameter should be a String or a Symbol, if given,
+displays the help to this command.
+DESC
+
+    SMON.add_help :type => 'cmd',
+    :name => 'exit',
+    :summary => 'Finishes the program.',
+    :usage => 'exit',
+    :description => <<DESC
+Finishes the program. Mostly  useful in interactive mode.
+DESC
+
+    SMON.add_help :type => 'cmd',
+    :name => 'libload',
+    :summary => 'Loads a library.',
+    :usage => 'libload <lib>',
+    :description => <<DESC
+Searches in the directorys listed in the @loadpath variable for a file
+called '<lib>.rb' or '<lib>' and includes it.
+
+The file content must be a module with name 'SMONLIB<lib>'.
+DESC
+
+    #Load all base libraries
+    ['base', 'db', 'latex', 'dot'].each do |lib|
+      process_command "libload '#{lib}'"
+    end
+
+    #Select the mode
+    if args[:files].empty?
+      interactive_mode
+    else
+      args[:files].each do |file|
+        execute file
+      end
+    end
+  end
+
+  def libload(lib)
+    load = []
+    @loadpath.each do |path|
+      load << Dir.glob( File.join(path, lib) )
+      load << Dir.glob( File.join(path, lib + '.rb') )
+    end
+
+    load.flatten!
+
+    if load.empty?
+      STDERR.puts "E: Could not load library '#{lib}'."
+    else
+      require load[0]
+      self.class.class_eval "include SMONLIB#{lib}"
+      STDERR.puts "I: Loaded #{lib}"
+    end
+
+    @__cmds = find_all_commands
+  end
+
+  def method_missing(cmd, *args)
+    puts "Error: Unknown command '#{cmd}'."
+  end
+
+  def help(topic = nil)
+    if topic
+      t = topic.to_s
+      if @@__help.key? t
+        @out.puts @@__help[t][:summary]
+        @out.puts "\nUSAGE: " + @@__help[t][:usage]
+        @out.puts
+        @out.puts @@__help[t][:description]
+      else
+        @out.puts "No help for '#{t}' availible."
+      end
+    else
+      @@__help.each_pair do |name, desc|
+        @out.puts name.to_s + "\t\t" + desc[:summary]
+      end
+      @out.puts
+    end
+  end
+
+  private
+  def interactive_mode
+    puts "Entering interactive mode."
+
+    @interactive = true
+    setup_readline
+
+    puts "\nInteractive mode started."
+    puts "Type 'help' to get an overview of all availible commands or"
+    puts "type 'help :help' for an explanation of the help system."
+
+    loop { process_command Readline.readline("smon:> ", true) }
+  end
+
+  def execute(file)
+    if File.exists? file
+      STDOUT.puts "Executing file '#{file}' ..."
+      begin
+        instance_eval File.open(file, 'r') { |f| f.read }
+      rescue => e
+        STDERR.puts "E: Error while executing '#{file}'. #{e.message}"
+      end
+    else
+      raise Exception, "File '#{file}' not found."
+    end
+  end
+
+  def find_all_commands
+    ['exit'] + self.public_methods -
+      (Object.public_methods + ['method_missing'])
+  end
+
+  def setup_readline
+    require 'readline'
+
+    if @__cmds.include? 'db_stat'
+      @__cmds += RLSM::MonoidDB::Columns.map { |x| x.inspect + " =>" }
+    end
+
+    Readline.completion_proc = lambda do |str|
+      pos = @__cmds.find_all { |cmd| cmd =~ Regexp.new("^#{str}") }
+      pos.size == 1 ? pos.first : nil
+    end
+  end
+
+  def process_command(cmd)
+    begin
+      if cmd =~ Regexp.new("^(#{@__cmds.join('|')})")
+        instance_eval(cmd)
+      else
+        STDOUT.puts "=> " + instance_eval(cmd).inspect
+      end
+    rescue RLSMException => e
+      STDERR.puts "An error occured. #{e.message}"
+    rescue SystemExit
+      STDOUT.puts "Cya."
+      exit
+    rescue Exception => e
+      STDERR.puts "An unexpected error occured. #{e.message}"
+    end
+  end
+end
+

data/stdarb.tex

@@ -0,0 +1,118 @@
+\documentclass[a4paper, halfparskip*]{scrartcl}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage[german]{babel}
+
+\usepackage{amsmath,paralist}
+
+\begin{document}
+\section{Theoretische Grundlagen}
+\label{sec:tg}
+In diesem Abschnitt geht es uns darum, die wichtigsten theoretischen Grundlagen
+darzulegen.
+
+\subsection{Magmen, Halbgruppen und Monoide}
+\label{sec:tg:monoide}
+\textbf{Defintion:} Sei $\emptyset \neq M$ eine Menge. Eine Abbildung
+\begin{equation*}
+  * \colon M \times M \to M,\, (a,b) \mapsto a*b
+\end{equation*}
+heißt \emph{(binäre) Operation auf $M$}. Eine Operation heißt \emph{assoziativ}, falls
+\begin{equation*}
+  \forall a,b,c\in M \colon a*(b*c) = (a*b)*c
+\end{equation*}
+und sie heißt \emph{kommutativ}, falls
+\begin{equation*}
+  \forall a,b\in M \colon a*b = b*a
+\end{equation*}
+
+Ein \emph{Magma} $M$ ist eine nichtleere Menge zusammen mit einer Operation $*$
+auf $M$. Ist die Operation assoziativ, so nennen wir $M$ eine \emph{Halbgruppe}.
+
+\textit{Bemerkung:} Sofern keine Verwirrung entstehen kann, werden wir die
+Operation nicht explizit mitangeben und schreiben statt $a*b$ einfach
+$ab$. Zusätzlich definieren wir für natürliche Zahlen $n\geq 1$ und ein Element
+$a\in M$ rekursiv
+\begin{equation*}
+  a^1 := a;\quad a^n := a*a^{n-1}
+\end{equation*}
+
+
+\textbf{Defintion:} Sei $M$ ein Magma und $x\in M$. Dann heißt $x$
+\begin{enumerate}[(a)]
+\item \emph{Neutralelement}, falls $\forall a\in M\colon xa = ax = a$.
+\item \emph{Links-Nullelement}, falls $\forall a\in M\colon xa = x$.
+\item \emph{Rechts-Nullelement}, falls $\forall a\in M\colon ax = x$.
+\item \emph{Nullelement}, falls es ein Links- und Rechts-Nullelement ist.
+\item \emph{idempotent}, falls $x^2 = x$. Sind alle Elemente eines Magmas
+  idempotent, so nennen wir das Magma selbst \emph{idempotent}.
+\item \emph{Inverses zu $a$}, falls $ax = xa = 1$, wobei $1$ ein Neutralelement
+  bezeichnet.
+\end{enumerate}
+Ein \emph{Monoid} ist eine Halbgruppe mit einem Neutralelement. Ein Monoid in
+dem jedes Element ein Inverses besitzt heißt \emph{Gruppe}.
+
+\textit{Bemerkung:} Falls ein Inverses, Neutral- oder Nullelement existiert,
+so ist es eindeutig. Der Beweis dafür ist leicht und in jedem Lehrbuch zur
+Algebra zu finden. Wir werden in Zukunft immer das Symbol $1$ für das
+Neutralelement eines Monoids $M$ verwenden (oder auch $1_M$ um deutlich zu
+machen, dass dies das Neutralelement von $M$ ist) und das Symbol $0$ bezeichnet
+immer das Nullelement, falls es existiert. Das Inverse zu $a$ bezeichnen wir mit
+$a^{-1}$ (falls es existiert).
+
+Im Fall eines Monoids $M$ setzen wir noch $a^0 = 1$ für jedes $a\in M$.
+
+\textbf{Definition:} Sei $M$ ein Monoid. Eine Menge $N$ heißt
+\emph{Untermonoid} von $M$, in Zeichen $N\leq M$, falls
+\begin{enumerate}[(i)]
+\item $N \subseteq M$
+\item $1_N = 1_M$
+\item $\forall a,b\in N \colon a*b\in N$
+\end{enumerate}
+
+\textit{Bemerkung:} $N$ wird mit der Operation  $\circ = *|_{N\times N}$ selbst
+zu einem Monoid.
+
+\textbf{Proposition:} Der Schnitt von Untermonoiden ist wieder ein Untermonoid.
+
+\textbf{Definition:} Sei $M$ ein Monoid und $N \subset M$. Der von $N$
+\emph{erzeugte Untermonoid} ist
+\begin{equation*}
+  \langle N \rangle := \bigcap_{N \subset S \leq M} S
+\end{equation*}
+
+Eine Menge $E$ heißt \emph{Erzeuger} von $M$, falls $\langle E \rangle = M$.
+
+\textbf{Defintion:} Seien $(M,*)$ und $(N,\circ)$ Monoide. Eine Abbildung $\phi\colon M \to
+N$ heißt \emph{(Monoid-)Homomorphismus}, falls
+\begin{enumerate}[(i)]
+\item $\phi(1_M) = 1_N$
+\item $\forall a,b \in M \colon \phi(a*b) = \phi(a)\circ\phi(b)$
+\end{enumerate}
+Ein Homomorphismus $\phi$ heißt
+\begin{enumerate}[(a)]
+\item \emph{Monomorphismus}, falls $\phi$ injektiv ist.
+\item \emph{Epimorphismus}, falls $\phi$ surjektiv ist.
+\item \emph{Isomorphismus}, falls $\phi$ bijektiv ist.
+\end{enumerate}
+
+
+\subsection{Formale Sprachen}
+\label{sec:tg:fs}
+
+\textbf{Defintion:} Wir nennen eine endliche nichleere Menge $\Sigma$ ein
+\emph{Alphabet} und Elemente von $\Sigma$ Buchstaben. Der freie Monoid über
+$\Sigma$ bezeichnen wir mit $\Sigma^*$ und das Neutralelement darin bezeichnen
+wir mit $\lambda$
+
+
+\subsection{Deterministische endliche Automaten}
+\label{sec:tg:dfa}
+
+% \textbf{Proposition:} Sei $M$ eine Halbgruppe und $x\in M$. Dann gibt es eine
+% natürliche Zahl $n\geq 1$, sodass $x^n$ idempotent ist.
+
+% \textbf{Korollar:} Ein Monoid ist genau dann eine Gruppe, wenn das einzige
+% idempotente Element das Neutralelement ist.
+\end{document}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rlsm
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 1.0.0
 platform: ruby
 authors: 
 - asmodis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-20 00:00:00 +01:00
+date: 2009-03-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -39,11 +39,19 @@ files:
 - 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
 has_rdoc: true
 homepage: http://www.github.com/asmodis/rlsm
 post_install_message: