libFAUDES

Sections

Index

3_functions.cpp

Go to the documentation of this file.
00001 /** @file 3_functions.cpp 
00002 
00003 Tutorial, operations on genarators.
00004 
00005 This tutorial  demonstrates the use of 
00006 general purpose operations on generators.
00007 It also produces example output for the HTML
00008 documentation.
00009 
00010 @ingroup Tutorials 
00011 
00012 @include 3_functions.cpp
00013 */
00014 
00015 
00016 #include "libfaudes.h"
00017 
00018 
00019 // make the faudes namespace available to our program
00020 
00021 using namespace faudes;
00022 
00023 
00024 
00025 /////////////////
00026 // main program
00027 /////////////////
00028 
00029 int main() {
00030 
00031 
00032   ////////////////////////////
00033   // make deterministic
00034   ////////////////////////////
00035 
00036      
00037   // read nondeterministic generator and  perform operation 
00038   Generator deter_nondet("data/deterministic_nondet.gen");
00039   Generator deter_det;
00040   Deterministic(deter_nondet, deter_det);
00041   deter_det.Write("tmp_deterministic_det.gen");
00042   deter_nondet.Write("tmp_deterministic_nondet.gen");
00043 
00044   // report result to console
00045   std::cout << "################################\n";
00046   std::cout << "# deterministic generator \n";
00047   deter_det.DWrite();
00048   std::cout << "################################\n";
00049 
00050 
00051   ////////////////////////////
00052   // make minimal
00053   ////////////////////////////
00054 
00055 
00056   // read nonminimal generator and  perform operation 
00057   Generator minimal_nonmin("data/minimal_nonmin.gen");
00058   Generator minimal_min;
00059   StateMin(minimal_nonmin, minimal_min);
00060   minimal_nonmin.Write("tmp_minimal_nonmin.gen");
00061   minimal_min.Write("tmp_minimal_min.gen");
00062 
00063   // report result to console
00064   std::cout << "################################\n";
00065   std::cout << "# minimal generator \n";
00066   minimal_min.DWrite();
00067   std::cout << "################################\n";
00068 
00069 
00070   ////////////////////////////
00071   // project
00072   ////////////////////////////
00073 
00074 
00075   // read generator to project 
00076   Generator project_g("data/project_g.gen");
00077   Generator project_prog;
00078   EventSet alph_proj;
00079   alph_proj.Insert("a");
00080   alph_proj.Insert("c");
00081   alph_proj.Insert("e");
00082   alph_proj.Insert("g");
00083   Project(project_g,  alph_proj, project_prog);
00084   project_g.Write("tmp_project_g.gen");
00085   project_prog.Write("tmp_project_prog.gen");
00086 
00087   // report result to console
00088   std::cout << "################################\n";
00089   std::cout << "# projected generator \n";
00090   project_prog.DWrite();
00091   std::cout << "################################\n";
00092 
00093 
00094   ////////////////////////////
00095   // synchronous composition
00096   ////////////////////////////
00097 
00098 
00099   // read generators
00100   Generator parallel_g1("data/parallel_g1.gen");
00101   Generator parallel_g2("data/parallel_g2.gen");
00102 
00103   // perform composition
00104   Generator parallel_g1g2;
00105   Parallel(parallel_g1, parallel_g2, parallel_g1g2);
00106   
00107   // write result and operands for html docu
00108   parallel_g1.Write("tmp_parallel_g1.gen");
00109   parallel_g2.Write("tmp_parallel_g2.gen");
00110   parallel_g1g2.Write("tmp_parallel_g1g2.gen");
00111  
00112   // read generators
00113   Generator parallel_m1("data/wparallel_g1.gen");
00114   Generator parallel_m2("data/wparallel_g2.gen");
00115 
00116   // perform composition
00117   Generator parallel_m1m2;
00118   Parallel(parallel_m1, parallel_m2, parallel_m1m2);
00119   
00120   // write result and operands for html docu
00121   parallel_m1.Write("tmp_parallel_m1.gen");
00122   parallel_m2.Write("tmp_parallel_m2.gen");
00123   parallel_m1m2.Write("tmp_parallel_m1m2.gen");
00124  
00125   // read generators
00126   Generator wparallel_g1("data/wparallel_g1.gen");
00127   Generator wparallel_g2("data/wparallel_g2.gen");
00128 
00129   // perform composition
00130   Generator wparallel_g1g2;
00131   OmegaParallel(wparallel_g1, wparallel_g2, wparallel_g1g2);
00132   
00133   // write result and operands for html docu
00134   wparallel_g1.Write("tmp_wparallel_g1.gen");
00135   wparallel_g2.Write("tmp_wparallel_g2.gen");
00136   wparallel_g1g2.Write("tmp_wparallel_g1g2.gen");
00137 
00138 
00139 
00140   ////////////////////////////
00141   // boolean language operations
00142   ////////////////////////////
00143 
00144 
00145   // read generators
00146   Generator boolean_g1("data/boolean_g1.gen");
00147   Generator boolean_g2("data/boolean_g2.gen");
00148 
00149   // perform union
00150   Generator boolean_union;
00151   boolean_union.StateNamesEnabled(false);
00152   LanguageUnion(boolean_g1, boolean_g2, boolean_union);
00153   
00154   // perform intersection
00155   Generator boolean_intersection;
00156   boolean_intersection.StateNamesEnabled(false);
00157   LanguageIntersection(boolean_g1, boolean_g2, boolean_intersection);
00158   
00159   // perform complement twice
00160   Generator boolean_complement_g1=boolean_g1; 
00161   boolean_complement_g1.StateNamesEnabled(false);
00162   LanguageComplement(boolean_complement_g1);
00163   Generator boolean_complement2_g1=boolean_complement_g1;
00164   LanguageComplement(boolean_complement2_g1);
00165   
00166   // write results and operands for html docu
00167   boolean_g1.Write("tmp_boolean_g1.gen");
00168   boolean_g2.Write("tmp_boolean_g2.gen");
00169   boolean_union.Write("tmp_union_g1g2.gen");
00170   boolean_intersection.Write("tmp_intersection_g1g2.gen");
00171   boolean_complement_g1.Write("tmp_complement_g1.gen");
00172   boolean_complement2_g1.Write("tmp_complement2_g1.gen");
00173 
00174   // inspect on console
00175   std::cout << "################################\n";
00176   std::cout << "# boolean language operations\n";
00177   boolean_union.DWrite();
00178   boolean_intersection.DWrite();
00179   boolean_complement_g1.DWrite();
00180   std::cout << "################################\n";
00181 
00182   // compare languages
00183   std::cout << "################################\n";
00184   std::cout << "# boolean language operations\n";
00185   if(LanguageInclusion(boolean_g1,boolean_union))  
00186     std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): OK\n";
00187   else
00188     std::cout << "Lm(g1) > Lm(g1) v Lm(g2): ERR\n";
00189   if(LanguageDisjoint(boolean_complement_g1,boolean_g1))  
00190     std::cout << "Lm(g1) ^ ~Lm(g1) = empty: OK\n";
00191   else
00192     std::cout << "(Lm(g1) v Lm(g2)) ^ ~(Lm(g1) v Lm(g2)) != empty: ERR\n";
00193   if(LanguageEquality(boolean_g1,boolean_complement2_g1))  
00194     std::cout << "Lm(g1) = ~~Lm(g1) : OK\n";
00195   else
00196     std::cout << "Lm(g1) != ~~Lm(g1) : ERR\n";
00197   std::cout << "################################\n";
00198 
00199   
00200 
00201   ////////////////////////////
00202   // language difference
00203   ////////////////////////////
00204   
00205 
00206   // read generator and write for html docu
00207   Generator difference_g1("data/difference_g1.gen");
00208   difference_g1.Write("tmp_difference_g1.gen");
00209   
00210   Generator difference_g2("data/difference_g2.gen");
00211   difference_g2.Write("tmp_difference_g2.gen");
00212     
00213   // compute language difference Lm(g1)-Lm(g2)
00214   
00215   Generator difference_g1minusg2;
00216   LanguageDifference(difference_g1,difference_g2,difference_g1minusg2);
00217   difference_g1minusg2.Write("tmp_difference_g1minusg2.gen");
00218 
00219   // inspect on console 
00220   std::cout << "################################\n";
00221   std::cout << "# language difference Lm(g1)-Lm(g2) \n";
00222   difference_g1minusg2.DWrite();
00223   std::cout << "################################\n";
00224 
00225 
00226 
00227   ////////////////////////////
00228   // convert to automaton
00229   ////////////////////////////
00230   
00231 
00232   // read generator and write for html docu
00233   Generator automaton_g("data/automaton_g.gen");
00234   automaton_g.Write("tmp_automaton_g.gen");
00235   
00236   // convert to automaton
00237   Automaton(automaton_g);
00238   automaton_g.Write("tmp_automaton_gRes.gen");
00239 
00240   // inspect on console 
00241   std::cout << "################################\n";
00242   std::cout << "# automaton from generator \n";
00243   automaton_g.DWrite();
00244   std::cout << "################################\n";
00245   
00246   
00247 
00248   ////////////////////////////
00249   // language concatenation
00250   ////////////////////////////
00251 
00252 
00253   // read generators and write for html docu
00254   Generator concat_g1("data/concat_g1.gen");
00255   Generator concat_g2("data/concat_g2.gen");
00256   Generator concat_g3("data/concat_g3.gen");
00257   Generator concat_g4("data/concat_g4.gen");
00258   Generator concat_g5("data/concat_g5.gen");
00259   Generator concat_g6("data/concat_g6.gen");
00260   concat_g1.Write("tmp_concat_g1.gen");
00261   concat_g2.Write("tmp_concat_g2.gen");
00262   concat_g3.Write("tmp_concat_g3.gen");
00263   concat_g4.Write("tmp_concat_g4.gen");
00264   concat_g5.Write("tmp_concat_g5.gen");
00265   concat_g6.Write("tmp_concat_g6.gen");
00266 
00267 
00268   // perform language concatenations and inspect on console
00269   std::cout << "################################\n";
00270   std::cout << "# language concatenation\n";
00271   Generator concat;
00272   concat.StateNamesEnabled(false);
00273   LanguageConcatenate(concat_g1,concat_g3,concat);
00274   concat.Write("tmp_concat_g1g3.gen");
00275   concat.DWrite();
00276   LanguageConcatenate(concat_g1,concat_g4,concat);
00277   concat.Write("tmp_concat_g1g4.gen");
00278   concat.DWrite();
00279   LanguageConcatenate(concat_g2,concat_g3,concat);
00280   concat.Write("tmp_concat_g2g3.gen");
00281   concat.DWrite();
00282   LanguageConcatenate(concat_g2,concat_g4,concat);
00283   concat.Write("tmp_concat_g2g4.gen");
00284   concat.DWrite();
00285   LanguageConcatenate(concat_g5,concat_g6,concat);
00286   concat.Write("tmp_concat_g5g6.gen");
00287   concat.DWrite();
00288   std::cout << "################################\n";
00289   
00290   
00291 
00292   ////////////////////////////
00293   // full language, alphabet language, empty string language and empty language
00294   ////////////////////////////
00295   
00296   // create alphabet={a,b}
00297   EventSet languages_alphabet;
00298   languages_alphabet.Insert("a");
00299   languages_alphabet.Insert("b");
00300   
00301   // generator for result
00302   Generator languages_g;
00303   
00304   // construct full language from alphabet
00305   FullLanguage(languages_alphabet,languages_g);
00306   languages_g.Write("tmp_languagesFull_result.gen");
00307 
00308   // inspect on console
00309   std::cout << "################################\n";
00310   std::cout << "# full language \n";
00311   languages_g.DWrite();
00312   
00313   // construct alphabet language from alphabet
00314   AlphabetLanguage(languages_alphabet,languages_g);
00315   languages_g.Write("tmp_languagesAlphabet_result.gen");
00316   std::cout << "# alphabet language \n";
00317   languages_g.DWrite();
00318   
00319   // construct empty string language from alphabet
00320   EmptyStringLanguage(languages_alphabet,languages_g);
00321   languages_g.Write("tmp_languagesEmptyString_result.gen");
00322   std::cout << "# empty string language \n";
00323   languages_g.DWrite();
00324   
00325   // construct empty language from alphabet
00326   EmptyLanguage(languages_alphabet,languages_g);
00327   languages_g.Write("tmp_languagesEmpty_result.gen");
00328   std::cout << "# empty language \n";
00329   languages_g.DWrite();
00330   std::cout << "################################\n";
00331 
00332 
00333 
00334   ////////////////////////////
00335   // Kleene closure
00336   ////////////////////////////
00337   
00338 
00339   // read generator and write for html docu
00340   Generator kleene_g("data/kleene_g.gen");
00341   kleene_g.Write("tmp_kleene_g.gen");
00342   
00343   // compute Kleene closure
00344   kleene_g.StateNamesEnabled(false);
00345   KleeneClosure(kleene_g);
00346   kleene_g.Write("tmp_kleene_gRes.gen");
00347 
00348   // inspect on console 
00349   std::cout << "################################\n";
00350   std::cout << "# Kleene closure \n";
00351   kleene_g.DWrite();
00352   std::cout << "################################\n";
00353   
00354   
00355 
00356   ////////////////////////////
00357   // prefix closure
00358   ////////////////////////////
00359   
00360 
00361   // read generator and write for html docu
00362   Generator prefixclosure_g("data/prefixclosure_g.gen");
00363   prefixclosure_g.Write("tmp_prefixclosure_g.gen");
00364   
00365   // compute prefix closure
00366   PrefixClosure(prefixclosure_g);
00367   prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");
00368 
00369   // inspect on console 
00370   std::cout << "################################\n";
00371   std::cout << "# prefix closure \n";
00372   prefixclosure_g.DWrite();
00373   std::cout << "################################\n";
00374   
00375 
00376 
00377   ////////////////////////////
00378   // selfloop
00379   ////////////////////////////
00380   
00381 
00382   // read generator and write for html docu
00383   Generator selfloop_g("data/selfloop_g.gen");
00384   selfloop_g.Write("tmp_selfloop_g.gen");
00385   
00386   // create alphabet={e,f}
00387   EventSet selfloop_alphabet;
00388   selfloop_alphabet.Insert("e");
00389   selfloop_alphabet.Insert("f");
00390   
00391   // generator for result
00392   Generator selfloop_gRes=selfloop_g;
00393   
00394   // add selfloops in each state
00395   SelfLoop(selfloop_gRes,selfloop_alphabet);
00396   selfloop_gRes.Write("tmp_selfloop_gRes.gen");
00397 
00398   // inspect on console 
00399   std::cout << "################################\n";
00400   std::cout << "# selfloop, each state \n";
00401   selfloop_gRes.DWrite();
00402   
00403   // add selfloops in marked states
00404   selfloop_gRes=selfloop_g;
00405   SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
00406   selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
00407   std::cout << "# selfloop, marked states \n";
00408   selfloop_gRes.DWrite();
00409   
00410   // add selfloops in inital state(s)
00411   selfloop_gRes=selfloop_g;
00412   SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
00413   selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
00414   std::cout << "# selfloop, init state(s) \n";
00415   selfloop_gRes.DWrite();
00416   std::cout << "################################\n";
00417 
00418   // say good bye    
00419   std::cout << "done.\n";
00420   return 0;
00421 }
00422 
00423 
00424 

libFAUDES 2.14g --- 2009-12-3 --- c++ source docu by doxygen 1.5.6