3_regular.cpp File Reference


Detailed Description

Tutorial, operations on genarators.

This tutorial demonstrates the use of general purpose operations on generators. It also produces example output for the html documentation.

#include "libfaudes.h"


// make the faudes namespace available to our program

using namespace faudes;



// main program

int main() {


  // make deterministic


  // read nondeterministic generator and  perform operation 

  Generator deter_nondet("data/deterministic_nondet.gen");
  Generator deter_det;
  Deterministic(deter_nondet, deter_det);
  deter_det.Write("tmp_deterministic_det.gen");
  deter_nondet.Write("tmp_deterministic_nondet.gen");

  // report result to console
 
  std::cout << "################################\n";
  std::cout << "# deterministic generator \n";
  deter_det.DWrite();
  std::cout << "################################\n";


  // make minimal


  // read nonminimal generator and  perform operation 

  Generator minimal_nonmin("data/minimal_nonmin.gen");
  Generator minimal_min;
  StateMin(minimal_nonmin, minimal_min);
  minimal_nonmin.Write("tmp_minimal_nonmin.gen");
  minimal_min.Write("tmp_minimal_min.gen");

  // report result to console
 
  std::cout << "################################\n";
  std::cout << "# minimal generator \n";
  minimal_min.DWrite();
  std::cout << "################################\n";


  // project


  // read generator to project 

  Generator project_g("data/project_g.gen");
  Generator project_prog;
  EventSet alph_proj;
  alph_proj.Insert("a");
  alph_proj.Insert("c");
  alph_proj.Insert("e");
  alph_proj.Insert("g");
  Project(project_g,  alph_proj, project_prog);
  project_g.Write("tmp_project_g.gen");
  project_prog.Write("tmp_project_prog.gen");

  // report result to console
 
  std::cout << "################################\n";
  std::cout << "# projected generator \n";
  project_prog.DWrite();
  std::cout << "################################\n";



  // boolean language operations


  // read generators
  Generator boolean_g1("data/boolean_g1.gen");
  Generator boolean_g2("data/boolean_g2.gen");

  // perform union
  Generator boolean_union;
  boolean_union.StateNamesEnabled(false);
  LanguageUnion(boolean_g1, boolean_g2, boolean_union);
  
  // perform intersection
  Generator boolean_intersection;
  boolean_intersection.StateNamesEnabled(false);
  LanguageIntersection(boolean_g1, boolean_g2, boolean_intersection);
  
  // perform complement twice
  Generator boolean_complement_g1=boolean_g1; 
  boolean_complement_g1.StateNamesEnabled(false);
  LanguageComplement(boolean_complement_g1);
  Generator boolean_complement2_g1=boolean_complement_g1;
  LanguageComplement(boolean_complement2_g1);

  // write results and operands for html docu
  boolean_g1.Write("tmp_boolean_g1.gen");
  boolean_g2.Write("tmp_boolean_g2.gen");
  boolean_union.Write("tmp_union_g1g2.gen");
  boolean_intersection.Write("tmp_intersection_g1g2.gen");
  boolean_complement_g1.Write("tmp_complement_g1.gen");
  boolean_complement2_g1.Write("tmp_complement2_g1.gen");

  // inspect on console
  std::cout << "################################\n";
  std::cout << "# boolean language operations\n";
  boolean_union.DWrite();
  boolean_intersection.DWrite();
  boolean_complement_g1.DWrite();
  std::cout << "################################\n";

  // compare languages
  std::cout << "################################\n";
  std::cout << "# boolean language operations\n";
  if(LanguageInclusion(boolean_g1,boolean_union))  
    std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): OK\n";
  else
    std::cout << "Lm(g1) > Lm(g1) v Lm(g2): ERR\n";
  if(LanguageDisjoint(boolean_complement_g1,boolean_g1))  
    std::cout << "Lm(g1) ^ ~Lm(g1) = empty: OK\n";
  else
    std::cout << "(Lm(g1) v Lm(g2)) ^ ~(Lm(g1) v Lm(g2)) != empty: ERR\n";
  if(LanguageEquality(boolean_g1,boolean_complement2_g1))  
    std::cout << "Lm(g1) = ~~Lm(g1) : OK\n";
  else
    std::cout << "Lm(g1) != ~~Lm(g1) : ERR\n";
  std::cout << "################################\n";


  // convert to automaton
  
  // read generator and write for html docu
  Generator automaton_g("data/automaton_g.gen");
  automaton_g.Write("tmp_automaton_g.gen");
  
  // convert to automaton
  
  Automaton(automaton_g);
  automaton_g.Write("tmp_automaton_gRes.gen");

  // inspect on console 
  std::cout << "################################\n";
  std::cout << "# automaton from generator \n";
  automaton_g.DWrite();
  std::cout << "################################\n";
  
  
  // language concatenation

  // read generators and write for html docu
  Generator concat_g1("data/concat_g1.gen");
  Generator concat_g2("data/concat_g2.gen");
  Generator concat_g3("data/concat_g3.gen");
  Generator concat_g4("data/concat_g4.gen");
  concat_g1.Write("tmp_concat_g1.gen");
  concat_g2.Write("tmp_concat_g2.gen");
  concat_g3.Write("tmp_concat_g3.gen");
  concat_g4.Write("tmp_concat_g4.gen");

  // perform language concatenations and inspect on console
  std::cout << "################################\n";
  std::cout << "# language concatenation\n";
  Generator concat;
  concat.StateNamesEnabled(false);
  LanguageConcatenate(concat_g1,concat_g3,concat);
  concat.Write("tmp_concat_g1g3.gen");
  concat.DWrite();
  LanguageConcatenate(concat_g1,concat_g4,concat);
  concat.Write("tmp_concat_g1g4.gen");
  concat.DWrite();
  LanguageConcatenate(concat_g2,concat_g3,concat);
  concat.Write("tmp_concat_g2g3.gen");
  concat.DWrite();
  LanguageConcatenate(concat_g2,concat_g4,concat);
  concat.Write("tmp_concat_g2g4.gen");
  concat.DWrite();
  std::cout << "################################\n";
  
  
  // full language, alphabet language, empty string language and empty language
  
  // create alphabet={a,b}
  EventSet languages_alphabet;
  languages_alphabet.Insert("a");
  languages_alphabet.Insert("b");
  
  // generator for result
  Generator languages_g;
  
  // construct full language from alphabet
  FullLanguage(languages_alphabet,languages_g);
  languages_g.Write("tmp_languagesFull_result.gen");

  // inspect on console
  std::cout << "################################\n";
  std::cout << "# full language \n";
  languages_g.DWrite();
  
  // construct alphabet language from alphabet
  AlphabetLanguage(languages_alphabet,languages_g);
  languages_g.Write("tmp_languagesAlphabet_result.gen");
  std::cout << "# alphabet language \n";
  languages_g.DWrite();
  
  // construct empty string language from alphabet
  EmptyStringLanguage(languages_alphabet,languages_g);
  languages_g.Write("tmp_languagesEmptyString_result.gen");
  std::cout << "# empty string language \n";
  languages_g.DWrite();
  
  // construct empty language from alphabet
  EmptyLanguage(languages_alphabet,languages_g);
  languages_g.Write("tmp_languagesEmpty_result.gen");
  std::cout << "# empty language \n";
  languages_g.DWrite();
  std::cout << "################################\n";


  // Kleene closure
  
  // read generator and write for html docu
  Generator kleene_g("data/kleene_g.gen");
  kleene_g.Write("tmp_kleene_g.gen");
  
  // compute Kleene closure
  kleene_g.StateNamesEnabled(false);
  KleeneClosure(kleene_g);
  kleene_g.Write("tmp_kleene_gRes.gen");

  // inspect on console 
  std::cout << "################################\n";
  std::cout << "# Kleene closure \n";
  kleene_g.DWrite();
  std::cout << "################################\n";
  
  
  // prefix closure
  
  // read generator and write for html docu
  Generator prefixclosure_g("data/prefixclosure_g.gen");
  prefixclosure_g.Write("tmp_prefixclosure_g.gen");
  
  // compute prefix closure
  PrefixClosure(prefixclosure_g);
  prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");

  // inspect on console 
  std::cout << "################################\n";
  std::cout << "# prefix closure \n";
  prefixclosure_g.DWrite();
  std::cout << "################################\n";
  

  // selfloop
  
  // read generator and write for html docu
  Generator selfloop_g("data/selfloop_g.gen");
  selfloop_g.Write("tmp_selfloop_g.gen");
  
  // create alphabet={e,f}
  EventSet selfloop_alphabet;
  selfloop_alphabet.Insert("e");
  selfloop_alphabet.Insert("f");
  
  // generator for result
  Generator selfloop_gRes=selfloop_g;
  
  // add selfloops in each state
  SelfLoop(selfloop_gRes,selfloop_alphabet);
  selfloop_gRes.Write("tmp_selfloop_gRes.gen");

  // inspect on console 
  std::cout << "################################\n";
  std::cout << "# selfloop, each state \n";
  selfloop_gRes.DWrite();
  
  // add selfloops in marked states
  selfloop_gRes=selfloop_g;
  SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
  selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
  std::cout << "# selfloop, marked states \n";
  selfloop_gRes.DWrite();
  
  // add selfloops in inital state(s)
  selfloop_gRes=selfloop_g;
  SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
  selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
  std::cout << "# selfloop, init state(s) \n";
  selfloop_gRes.DWrite();
  std::cout << "################################\n";

  // say good bye    
  std::cout << "done.\n";
  return 0;
}



Definition in file 3_regular.cpp.

#include "libfaudes.h"

Go to the source code of this file.

Functions

int main ()


Function Documentation

int main  ) 
 

Definition at line 29 of file 3_regular.cpp.


Generated on Fri May 9 11:26:47 2008 for libFAUDES 2.09b by  doxygen 1.4.4