rlsm 1.0.0 → 1.1.0

data/lib/smon/base.rb

@@ -1,284 +0,0 @@
-module SMONLIBbase
-  def quit
-    exit
-  end
-
-  def monoid(mon, options = {})
-    @objects << RLSM::Monoid.new(mon, options)
-    puts "=> #{@objects.last.inspect}" if @interactive
-    @monoid = @objects.last
-  end
-
-  def dfa(dfa)
-    @objects << RLSM::DFA.create(dfa)
-    puts "=> #{@objects.last.inspect}" if @interactive
-    @dfa = @objects.last
-  end
-
-  def regexp(re)
-    @objects << RLSM::RE.new(re)
-    puts "=> #{@objects.last.inspect}" if @interactive
-    @re = @objects.last
-  end
-
-  def show(obj = nil)
-    obj ||= @objects.last
-    if obj
-      @out.puts obj.to_s
-      @out.puts
-    else
-      STDERR.puts "No object present."
-    end
-  end
-
-  def describe(obj = nil)
-    obj ||= @objects.last
-
-    if obj
-      monoid, dfa = obj.to_monoid, obj.to_dfa
-      print_language(monoid, dfa)
-      print_monoid_properties(monoid)
-      print_submonoids(monoid)
-      print_syntactic_properties(monoid)
-    else
-      STDERR.puts "No object present."
-    end
-  end
-
-
-  def self.included(mod)
-    #Setting up the help system
-    mod.add_help :type => 'cmd',
-    :name => 'quit',
-    :usage => 'quit',
-    :summary => "Quits the program.",
-    :description => <<DESC
-The 'quit' command is a synonym for the 'exit' command.
-Only needed in interactive mode.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'monoid',
-    :usage => "monoid '<mon>' [<options>]",
-    :summary => "Creates a new monoid.",
-    :description => <<DESC
-The <mon> parameter is a description of the binary operation
-of the monoid as a table. The <mon> parameter is parsed as follows:
-  * Rows are seperated by spaces.
-  * Elements in a row are seperated by commas (',').
-    Commas are optional if each element consists of a single letter.
-  * IMPORTANT: The first row and column belongs to the neutral element!
-  * IMPORTANT: The <mon> parameter must be enclosed
-    in single or double quotes.
-
-EXAMPLES:
-monoid '1ab aab bbb'
-monoid 'e,a1,a2 a1,a2,e a2,e,a1'
-
-The optional <options> parameter is a Hash and can take the following keys:
- :elements  -> an array
-               The value of this key is used to rename
-               the elements of the monoid.
- :normalize -> true|false
-               If true, the monoid will be normalized, i.e.
-               the generating elements will be moved to the beginning.
- :rename    -> true|false
-               If true, the elements ill be renamed to 1 a b c ...
-
-Adds the  created monoid to the @objects array
-and sets the variable @monoid to the created monoid.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'dfa',
-    :usage => "dfa <hash>",
-    :summary => "Creates a new DFA.",
-    :description => <<DESC
-The <hash> parameter must have the following keys:
- :initial     -> label
-                 The label of the initial state.
- :finals      -> an Array
-                 The array contains the labels of the final states.
- :transitions -> an Array
-                 The array contains the transitions of the monoid.
-                 A transition is an array consisting of
-                  the label of the transition
-                  the starting state of the transition
-                  the destination of the transition
-
-EXAMPLE:
-dfa :initial => '0', :finals => ['1'], :transitions => [['a','0','1']]
-
-Adds the  created DFA to the @objects array
-and sets the variable @dfa to the created DFA.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'regexp',
-    :usage => "regexp '<re>'",
-    :summary => "Creates a new Regular Expression.",
-    :description => <<DESC
-The <re> parameter is simply a regular expression. Special Symbols are
- #{RLSM::RE::Lambda} -> the empty word
- #{RLSM::RE::Star} -> the Kleene star
- #{RLSM::RE::Union} -> the union of two regexps
- #{RLSM::RE::LeftBracket}, #{RLSM::RE::RightBracket} -> Parenthesis to group a subregexp
-
-IMPORTANT: The <re> parameter must be enclosed in single or double quotes.
-           Parentheses must be balanced.
-
-EXAMPLES:
-regexp 'a'
-regexp
-'#{RLSM::RE::Lambda}#{RLSM::RE::Union}#{RLSM::RE::LeftBracket}a#{RLSM::RE::Union}aab#{RLSM::RE::Star}#{RLSM::RE::RightBracket}'
-
-Adds the  created regular expression to the @objects array
-and sets the variable @re to the created regular expression.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'show',
-    :usage => "show [<obj>]",
-    :summary => "Prints a very concise description of <obj>.",
-    :description => <<DESC
-The optional <obj> parameter is either a monoid, a DFA or a RE.
-If none is given the last created object will be used.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'describe',
-    :usage => "describe [<obj>]",
-    :summary => "Prints a verbose description of <obj>.",
-    :description => <<DESC
-The optional <obj> parameter is either a monoid, a DFA or a RE.
-If none is given the last created object will be used.
-DESC
-  end
-
-  private
-  def print_syntactic_properties(m)
-    if m.syntactic?
-      @out.puts "SYNTACTIC PROPERTIES:"
-
-      m.all_disjunctive_subsets.each do |ds|
-        @out.puts "{#{ds.join(',')}} => #{m.to_dfa(ds).to_re}"
-      end
-      @out.puts
-    end
-  end
-
-  def print_submonoids(m)
-    subs = m.proper_submonoids.map do |sm|
-      binary_operation(sm)
-    end
-
-    if subs.empty?
-      @out.puts "SUBMONOIDS: none"
-      @out.puts
-    else
-      @out.puts "SUBMONOIDS:"
-      rows = [[]]
-      width = 0
-      subs.each do |sm|
-        spl = sm.split("\n")
-        if (width + spl[0].length) <= 30
-          rows.last << spl
-          width += spl[0].length
-        else
-          rows << [spl]
-          width = spl[0].length
-        end
-      end
-      rows.each do |row|
-        max_lines = row.map { |sm| sm.size }.max
-
-        row.map! { |sm| sm + [' '*sm[0].length]*(max_lines-sm.size) }
-        (0...row[0].size).each do |i|
-          @out.puts row.map { |sm| sm[i] }.join('  ')
-        end
-        @out.puts
-      end
-    end
-  end
-
-  def print_monoid_properties(m)
-    block1 = []
-    block1 << "PROPERTIES OF THE MONOID:"
-    block1 << "   Generator: {#{m.generating_subset.join(',')}}"
-    block1 << "       Group: #{m.group?}"
-    block1 << " Commutative: #{m.commutative?}"
-    block1 << "  Idempotent: #{m.idempotent?}"
-    block1 << "   Syntactic: #{m.syntactic?}"
-    block1 << "   Aperiodic: #{m.aperiodic?}"
-    block1 << "   L-trivial: #{m.l_trivial?}"
-    block1 << "   R-trivial: #{m.r_trivial?}"
-    block1 << "   D-trivial: #{m.d_trivial?}"
-    block1 << "Zero element: #{!m.zero_element.nil?}"
-
-    max_length = block1.map { |row| row.length }.max
-    block1.map! { |row| row + ' '*(max_length - row.length) }
-
-    block2 = []
-    block2 << "SPECIAL ELEMENTS:"
-    block2 << " Idempotents: #{m.idempotents.join(',')}"
-    if m.zero_element
-      block2 << "Zero element: #{m.zero_element}"
-    else
-      lz = (m.left_zeros.empty? ? ['none'] : m.left_zeros).join(',')
-      block2 << "  Left-Zeros: #{lz}"
-      rz = (m.right_zeros.empty? ? ['none'] : m.right_zeros).join(',')
-      block2 << " Right-Zeros: #{rz}"
-    end
-    block2 << ''
-    block2 << ''
-    block2 << "GREEN RELATIONS:"
-    lc = m.l_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
-    rc = m.r_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
-    hc = m.h_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
-    dc = m.d_classes.map { |cl| '{' + cl.join(',') + '}' }.join(' ')
-    block2 << "L-Classes: #{lc}"
-    block2 << "R-Classes: #{rc}"
-    block2 << "H-Classes: #{hc}"
-    block2 << "D-Classes: #{dc}"
-    block2 << ''
-
-    @out.puts block1.zip(block2).map { |row| row.join('  ') }.join("\n")
-    @out.puts
-  end
-
-  def print_language(m,d)
-    @out.puts "\nDFA:\n#{d.to_s}\n"
-    @out.puts "\nMONOID:\n"
-    @out.puts binary_operation(m)
-    @out.puts
-  end
-
-  def binary_operation(monoid)
-   max_length = monoid.elements.map { |e| e.length }.max
-    rows = monoid.binary_operation.map do |row|
-       row.map do |e|
-        space = ' '*((max_length - e.length)/2)
-        extra_space = ' '*((max_length - e.length)%2)
-        space + extra_space + e + space
-      end.join(' | ')
-    end
-
-    first =  ' '*(max_length + 2) + '| ' + rows[0].clone + ' |'
-    seperator = first.gsub(/[^|]/,'-').gsub('|', '+')
-
-    rows.map! do |row|
-      ' ' + row[/^[^|]+\|/] + ' ' + row + " |"
-    end
-
-    result = [first]
-    result << seperator
-    result << rows.join("\n" + seperator + "\n")
-    result << seperator
-
-    result.join("\n")
-  end
-
-  def get_elements(obj)
-    [obj.to_monoid, obj.to_dfa, obj.to_re]
-  end
-end

data/lib/smon/db.rb

@@ -1,98 +0,0 @@
-module SMONLIBdb
-  def db_stat
-    stat = RLSM::MonoidDB.statistic
-    result = stat.shift.join(' | ')
-
-    column_widths = result.scan(/./).inject([0]) do |res,char|
-      if char == '|'
-        res << 0
-      else
-        res << res.pop + 1
-      end
-
-      res
-    end
-
-    result += ("\n" + '   ' + result.gsub(/[^|]/, '-').gsub('|', '+'))
-
-    stat.each do |row|
-      justified = []
-      row.each_with_index do |col,i|
-        col = col.to_s
-        space = ' '*((column_widths[i] - col.length)/2)
-        extra_space = ' '*((column_widths[i] - col.length)%2)
-        justified << space + col + space + extra_space
-      end
-
-      result += ("\n" + '   ' + justified.join('|'))
-    end
-
-    @out.puts result
-    @out.puts
-  end
-
-  def db_find(args)
-    count = RLSM::MonoidDB.count(args)
-    STDOUT.puts "Found: #{count[0]} monoid(s) (#{count[1]} syntactic)"
-    STDOUT.puts "Saved result in variable '@search_result'"
-
-    @search_result = RLSM::MonoidDB.find(args).flatten
-  end
-
-  def self.included(mon)
-    #Check if database is usable
-    begin
-      require 'database'
-
-      mon.add_help :type => 'cmd',
-      :name => 'db_stat',
-      :summary => "Shows an overview of the database.",
-      :usage => 'db_stat',
-      :description => <<DESC
-Prints for each order of a monoid the number of monoids in the database
-and the number of monoids with certain properties.
-DESC
-
-      mon.add_help :type => 'cmd',
-      :name => 'db_find',
-      :summary => "Finds monoids in the database.",
-      :usage => 'db_find [<options>]',
-      :description => <<DESC
-Finds monoids which matches the given options and saves the result
-in the variable '@serach_result'.
-
-The optional <options> parameter is a Hash with the following keys:
- :binop -> a String
-           Searches in the database for a monoid with this binary operation.
-           The :binop-value must have the same format as for the monoid command
-           and in the database the element names are 0 1 2 3 4 5 ...
-           (Not very useful in practice.)
-
- :m_order -> an Integer
-             Searches for monoids with the given order.
-
- :num_generators
- :num_idempotents
- :num_left_nulls
- :num_right_nulls -> an Integer
-                     Seraches for monoids with the given number of special
-                     elements like idempotents or left-zeros.
-
- :syntactic
- :idempotent
- :aperiodic
- :commutative
- :is_group
- :has_null
- :l_trivial
- :r_trivial
- :d_trivial   -> true|false
-                 Searches for monoids with the given attribute.
-DESC
-    rescue LoadError
-      STDERR.puts "W: Could not load 'db'."
-      remove_method :db_find
-      remove_method :db_stat
-    end
-  end
-end

data/lib/smon/dot.rb

@@ -1,65 +0,0 @@
-module SMONLIBdot
-  #Creates a picture of a DFA using dot.
-  def dfa2pic(dfa, options = {:format => 'png'})
-    filename = options[:filename] || SMON.tmp_filename
-    File.open(filename + ".dot", "w") { |f| f.puts dfa2dot(dfa) }
-    system "dot -T#{options[:format]} -o #{filename}.#{options[:format]} #{filename}.dot"
-    File.delete(filename + ".dot")
-  end
-
-  #Creates string which is a dot representation of a DFA.
-  def dfa2dot(dfa)
-    str = "digraph {\n"
-    str += "size=\"2,2\"\nratio=1.0\n"
-    str += "node [shape=circle]\n"
-    str += "preinit [shape=plaintext, label=\"\"]\n"
-    (dfa.states - dfa.finals).each do |state|
-      str += state + "\n"
-    end
-    str += "node [shape=doublecircle]\n"
-    dfa.finals.each do |state|
-      str += state + "\n"
-    end
-    str += "preinit -> #{dfa.initial_state}\n"
-    dfa.states.product(dfa.states).each do |s1,s2|
-      res = dfa.transitions.find_all { |tr| tr[1] == s1 and tr[2] == s2 }
-      unless res.empty?
-        label = res.map { |tr| tr[0] }.join(',')
-        str += s1 + "->" + s2 + "[label=\"#{label}\"]\n"
-      end
-    end
-
-    str + "}"
-  end
-
-  def self.included(mod)
-    unless system("which dot > /dev/null")
-      remove_method :dfa2pic
-      STDERR.puts "W: No 'dot' command found."
-    else
-      mod.add_help :type => 'cmd',
-      :name => 'dfa2pic',
-      :summary => 'Creates a picture of a DFA using dot.',
-      :usage => 'dfa2pic <dfa> [<options>]',
-      :description => <<DESC
-The parameter <dfa> is a DFA which will be transformed with the dot program.
-Possible optional parameters are
- :format -> a String.
-            The output format. Defaults to 'png'. Could be all what dot
-            accepts.
-
- :filename -> a String.
-              The filename of the output.
-DESC
-    end
-
-    mod.add_help :type => 'cmd',
-      :name => 'dfa2dot',
-      :summary => 'Creates a string with dot commands.',
-      :usage => 'dfa2pic <dfa>',
-      :description => <<DESC
-The parameter <dfa> is a DFA which will be transformed to a string
-which is a valid dot description of a digraph.
-DESC
-  end
-end

data/lib/smon/latex.rb

@@ -1,313 +0,0 @@
-require 'enumerator'
-
-module SMONLIBlatex
-  def m2tex(monoid)
-    buffer = ['\begin{tabular}{' +
-               (['c']*(monoid.order+1)).join('|') + '|}']
-
-    buffer << ' & ' + monoid.binary_operation[0].map do |el|
-      "\\textbf{#{el}}"
-    end.join(' & ') + "\\\\ \\hline"
-
-    monoid.binary_operation.each do |row|
-      buffer << "\\textbf{#{row[0]}} & " + row.join(' & ') + "\\\\ \\hline"
-    end
-
-    buffer << ['\end{tabular}']
-    buffer.join("\n")
-  end
-
-  def d2tex(dfa, opts = {:dot => true})
-    #Have we dot support
-    if opts[:dot] #and @__cmds.include? "dfa2pic"
-      filename = SMON.tmp_filename
-      dfa2pic dfa, :filename => filename, :format => 'plain'
-      str = "\\begin{xy}\n0;<1.27cm,0cm>:\n"
-
-      edges = []
-      File.open(filename + ".plain", 'r').each_line do |line|
-        values = line.split
-        if ['edge','node'].include? values.first
-          str += tex_xy_node(values)
-        end
-        edges << tex_xy_edge(values) if values.first == 'edge'
-      end
-
-      str += edges.join("\n")
-
-      File.delete(filename + ".plain")
-
-      return str + "\n\\end{xy}\n"
-    else
-      str = "\\begin{tabular}{r|" +
-        (['c']*dfa.alphabet.size).join('|') + "}\n"
-      str += " & " + dfa.alphabet.map do |l|
-        "\\textbf{#{l}}"
-      end.join(' & ') + " \\\\ \\hline\n"
-      dfa.states.each do |state|
-        tmp_str = ''
-        tmp_str += "\\ensuremath{*}" if dfa.finals.include? state
-        tmp_str += "\\ensuremath{\\rightarrow}" if dfa.initial_state == state
-        tmp_str += state + " & "
-        tmp_str += dfa.alphabet.map do |letter|
-          tmp = dfa[letter,state]
-          tmp ? tmp : 'nil'
-        end.join(' & ')
-        str+= tmp_str + " \\\\\n"
-      end
-
-      return str + "\\end{tabular}\n"
-    end
-  end
-
-  def r2tex(re)
-    re_str = re.pattern.
-      gsub(RLSM::RE::Lambda, "\\lambda ").
-      gsub(RLSM::RE::Union, "\\mid ").
-      gsub(RLSM::RE::Star, "^{*}")
-
-    "\\ensuremath{#{re_str}}"
-  end
-
-  def tex_describe(obj)
-    monoid = obj.to_monoid
-    dfa = obj.to_dfa
-
-    str = <<LATEX
-\\begin{tabular}[t]{c|c}
-\\textbf{Binary Operation} & \\textbf{DFA} \\\\ \\hline
-#{m2tex(monoid)} & #{d2tex(dfa)}
-\\end{tabular}\\\\[2ex]
-#{tex_properties(monoid)}\\\\[2ex]
-#{tex_submonoids(monoid)}\\\\[2ex]
-#{monoid.syntactic? ? tex_syntactic_properties(monoid) : ''}
-
-LATEX
-
-    @out.puts str if @interactive
-
-    str
-  end
-
-  def tex_preamble
-    <<PREAMBLE
-\\documentclass[a4paper,DIV15,halfparskip*]{scrartcl}
-\\usepackage[all]{xy}
-\\usepackage{amsmath}
-
-\\begin{document}
-PREAMBLE
-  end
-
-  def compile(opts = {:format => 'dvi'})
-    str = tex_preamble
-    if opts[:object]
-      str += tex_describe(opts[:object])
-    else
-      str += opts[:input]
-    end
-    str += "\n\\end{document}"
-
-    filename = opts[:filename] || SMON.tmp_filename
-
-    File.open(filename + ".tex", 'w') { |f| f.puts str }
-
-    cmd = "latex -interaction=nonstopmode "
-    cmd += "-output-format=#{opts[:format]} " + filename  + ".tex"
-
-    system cmd
-
-    clean_up filename
-  end
-
-  def self.included(mod)
-    unless system("which latex >/dev/null")
-      remove_method :complile
-      STDERR.puts "W: compile command disabled."
-    else
-      mod.add_help :type => 'cmd',
-      :name => 'compile',
-      :summary => 'Creates a dvi or pdf from the given string or object.',
-      :usage => 'compile <options>',
-      :description => <<DESC
-Possible options are
- :input -> a String.
-           A string which contains a valid latex source file.
-
- :object -> a DFA or Monoid or Regular Expression.
-            The object will be transformed using tex_describe
-            and then typsetted.
-
- :format -> a String.
-            Either 'dvi' or 'pdf'. Determines the output format of the
-            latex command.
-
- :filename -> a String.
-              The filename of the output.
-DESC
-    end
-
-    mod.add_help :type => 'cmd',
-    :name => 'm2tex',
-    :summary => 'Transforms a monoid to tex code.',
-    :usage => 'm2tex <monoid>',
-    :description => <<DESC
-Takes a monoid and returns a string containing tex code for
-representing the monoid in tex.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'r2tex',
-    :summary => 'Transforms a regular expression to tex code.',
-    :usage => 'r2tex <re>',
-    :description => <<DESC
-Takes a regular expression and returns a string containing tex code for
-representing the regular expression in tex.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'd2tex',
-    :summary => 'Transforms a DFA to tex code.',
-    :usage => 'd2tex <dfa> [<options>]',
-    :description => <<DESC
-Takes a DFA and returns a string containing tex code for
-representing the DFA in tex.
-
-Optional a parameter :dot can be given.
- :dot -> true|false
-         If true and the dfa2pic command is found, uses dot and xy-pic
-         to genearte a graph for the DFA.
-         If false a simple table is used for representing the DFA.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'tex_describe',
-    :summary => 'Returns tex code equivalent to the describe command.',
-    :usage => 'tex_describe <object>',
-    :description => <<DESC
-Takes an object and returns a string containing tex code for
-representing this object in tex. Focuses on the monoid properties.
-DESC
-
-    mod.add_help :type => 'cmd',
-    :name => 'tex_preamble',
-    :summary => 'Returns the tex preamble used by the compile command.',
-    :usage => 'tex_preamble',
-    :description => <<DESC
-Not very useful in interactive mode.
-DESC
-  end
-
-  private
-  def clean_up(file)
-    files = Dir.glob(file + ".*").reject { |f| f =~ /(dvi|pdf)$/ }
-    files.each { |f| system("rm " + f) }
-  end
-
-  def set(s)
-    "\\ensuremath{\\lbrace \\mbox{#{s.join(', ')}}\\rbrace}"
-  end
-
-  def list(s)
-    str = s.join(', ')
-    str.empty? ? 'none' : str
-  end
-
-  def tex_submonoids(m)
-    sm = m.proper_submonoids.map { |s| m2tex(s) }
-    buffer = nil
-    if sm.empty?
-      buffer = ["\\textbf{Submonoids:} none"]
-    else
-      buffer = ["\\textbf{Submonoids:}\\\\[.5\\baselineskip]"]
-      buffer << sm.join("\\quad\n")
-    end
-
-    buffer.join("\n")
-  end
-
-  def tex_syntactic_properties(m)
-    buffer = ["\\textbf{Syntactic Properties:}\\\\"]
-    buffer << "\\begin{tabular}{ll}"
-    buffer << "Disjunctive Subset & Possible Regular Expression \\\\"
-    m.all_disjunctive_subsets.each do |ds|
-      re = m.to_dfa(ds).to_re
-      buffer << set(ds) + " & " + r2tex(re) + "\\\\"
-    end
-    buffer << "\\end{tabular}"
-
-    buffer.join("\n")
-  end
-
-
-  def tex_properties(m)
-    buffer = ['\begin{tabular}{llcll}']
-    buffer << '\multicolumn{2}{l}{\textbf{Properties of the Monoid:}} &'
-    buffer << ' & \multicolumn{2}{l}{\textbf{Special Elements:}} \\\\'
-    buffer << "Generator: & #{set(m.generating_subset)} & \\quad &" +
-      "Idempotents: & #{list(m.idempotents)} \\\\"
-
-    buffer << "Group: & #{m.group?} & \\quad &"
-    if m.zero_element
-      buffer[-1] += " Zero Element: & #{m.zero_element} \\\\"
-    else
-      buffer[-1] += " Left-Zeros: & #{list(m.left_zeros)} \\\\"
-    end
-
-    buffer << "Commutative: & #{m.commutative?} & \\quad &"
-    if m.zero_element
-      buffer[-1] += " & \\\\"
-    else
-      buffer[-1] += " Rigth-Zeros: & #{list(m.right_zeros)} \\\\"
-    end
-
-    buffer << "Idempotent: & #{m.idempotent?} & \\quad & & \\\\"
-    buffer << "Syntactic: & #{m.syntactic?} & \\quad &" +
-      "\\multicolumn{2}{l}{\\textbf{Green Relations:}} \\\\"
-    buffer << "Aperiodic: & #{m.aperiodic?} & \\quad &" +
-      " L-Classes: & #{list(m.l_classes.map { |x| set(x) })} \\\\"
-    buffer << "L-trivial: & #{m.l_trivial?} & \\quad &" +
-      " R-Classes: & #{list(m.r_classes.map { |x| set(x) })} \\\\"
-    buffer << "R-trivial: & #{m.r_trivial?} & \\quad &" +
-      " H-Classes: & #{list(m.h_classes.map { |x| set(x) })} \\\\"
-    buffer << "D-trivial: & #{m.d_trivial?} & \\quad &" +
-      " D-Classes: & #{list(m.d_classes.map { |x| set(x) })} \\\\"
-    buffer << "Zero Element: & #{!m.zero_element.nil?} & \\quad & & \\\\"
-    buffer << '\end{tabular}'
-
-    buffer.join("\n")
-  end
-
-  def tex_xy_node(n)
-    if n.first == 'edge'
-      return "" if n[1] == 'preinit'
-
-      num_points = n[3].to_i
-      lable_pos = n[2*num_points + 5,2].join(',')
-      label = n[2*num_points + 4].gsub("\"",'')
-
-      return ";(#{lable_pos})*[r]\\txt{#{label}}\n"
-    else
-      id = n[1]
-      xypos = n[2,2].join(',')
-      return  "(#{xypos})*{}=\"#{id}\"\n" if n[1] == 'preinit'
-
-      label = n[6]
-      type = n[8] == 'circle' ? '' : '='
-
-      return ";(#{xypos})*+=[o]++[F#{type}]{#{label}}=\"#{id}\"\n"
-    end
-  end
-
-  def tex_xy_edge(e)
-    from, to = e[1,2]
-    num_points = e[3].to_i
-    points = points_to_str(e[4,2*num_points])
-
-    "\\ar @`{#{points}} \"#{from}\";\"#{to}\""
-  end
-
-  def points_to_str(a)
-    "(" + a.enum_slice(2).to_a.map { |x| x.join(',') }.join('),(') + ")"
-  end
-end