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   ////////////////////////////
00034   // make deterministic
00035   ////////////////////////////
00036 
00037      
00038   // read nondeterministic generator and  perform operation 
00039   Generator deter_nondet("data/deterministic_nondet.gen");
00040   Generator deter_det;
00041   Deterministic(deter_nondet, deter_det);
00042   deter_det.Write("tmp_deterministic_det.gen");
00043   deter_nondet.Write("tmp_deterministic_nondet.gen");
00044 
00045   // report result to console
00046   std::cout << "################################\n";
00047   std::cout << "# deterministic generator \n";
00048   deter_det.DWrite();
00049   std::cout << "################################\n";
00050 
00051 
00052   // Test protocol
00053   FAUDES_TEST_DUMP("deterministic",deter_det);
00054 
00055 
00056   ////////////////////////////
00057   // make minimal
00058   ////////////////////////////
00059 
00060 
00061   // read nonminimal generator and  perform operation 
00062   Generator minimal_nonmin("data/minimal_nonmin.gen");
00063   Generator minimal_min;
00064   StateMin(minimal_nonmin, minimal_min);
00065   minimal_nonmin.Write("tmp_minimal_nonmin.gen");
00066   minimal_min.Write("tmp_minimal_min.gen");
00067 
00068   // report result to console
00069   std::cout << "################################\n";
00070   std::cout << "# minimal generator \n";
00071   minimal_min.DWrite();
00072   std::cout << "################################\n";
00073 
00074 
00075   // Test protocol
00076   FAUDES_TEST_DUMP("minimal",minimal_min);
00077 
00078   ////////////////////////////
00079   // project
00080   ////////////////////////////
00081 
00082 
00083   // read generator to project 
00084   Generator project_g("data/project_g.gen");
00085   Generator project_prog;
00086   EventSet alph_proj;
00087   alph_proj.Insert("a");
00088   alph_proj.Insert("c");
00089   alph_proj.Insert("e");
00090   alph_proj.Insert("g");
00091   Project(project_g,  alph_proj, project_prog);
00092   project_g.Write("tmp_project_g.gen");
00093 
00094   // tmoor 201308: minimize stateset (for html docu, purely cosmetic)
00095   Generator project_prog_min;
00096   project_prog_min.StateNamesEnabled(false);
00097   StateMin(project_prog,project_prog_min); 
00098   project_prog_min.Write("tmp_project_prog.gen");
00099 
00100   // report result to console
00101   std::cout << "################################\n";
00102   std::cout << "# projected generator \n";
00103   project_prog_min.DWrite();
00104   std::cout << "################################\n";
00105 
00106   // Test protocol
00107   FAUDES_TEST_DUMP("project",project_prog_min);
00108 
00109 
00110   ////////////////////////////
00111   // synchronous composition
00112   ////////////////////////////
00113 
00114 
00115   // read generators
00116   Generator parallel_g1("data/parallel_g1.gen");
00117   Generator parallel_g2("data/parallel_g2.gen");
00118 
00119   // perform composition
00120   Generator parallel_g1g2;
00121   Parallel(parallel_g1, parallel_g2, parallel_g1g2);
00122   
00123   // write result and operands for html docu
00124   parallel_g1.Write("tmp_parallel_g1.gen");
00125   parallel_g2.Write("tmp_parallel_g2.gen");
00126   parallel_g1g2.Write("tmp_parallel_g1g2.gen");
00127  
00128   // read generators
00129   Generator parallel_m1("data/wparallel_g1.gen");
00130   Generator parallel_m2("data/wparallel_g2.gen");
00131 
00132   // perform composition
00133   Generator parallel_m1m2;
00134   Parallel(parallel_m1, parallel_m2, parallel_m1m2);
00135   
00136   // write result and operands for html docu
00137   parallel_m1.Write("tmp_parallel_m1.gen");
00138   parallel_m2.Write("tmp_parallel_m2.gen");
00139   parallel_m1m2.Write("tmp_parallel_m1m2.gen");
00140  
00141   // read generators
00142   Generator wparallel_g1("data/wparallel_g1.gen");
00143   Generator wparallel_g2("data/wparallel_g2.gen");
00144 
00145   // perform composition
00146   Generator wparallel_g1g2;
00147   OmegaParallel(wparallel_g1, wparallel_g2, wparallel_g1g2);
00148   
00149   // write result and operands for html docu
00150   wparallel_g1.Write("tmp_wparallel_g1.gen");
00151   wparallel_g2.Write("tmp_wparallel_g2.gen");
00152   wparallel_g1g2.Write("tmp_wparallel_g1g2.gen");
00153 
00154   // Test protocol
00155   FAUDES_TEST_DUMP("parallel",parallel_g1g2);
00156   FAUDES_TEST_DUMP("wparallel",wparallel_g1g2);
00157 
00158 
00159   ////////////////////////////
00160   // boolean language operations
00161   ////////////////////////////
00162 
00163 
00164   // read generators
00165   Generator boolean_g1("data/boolean_g1.gen");
00166   Generator boolean_g2("data/boolean_g2.gen");
00167   Generator lequal_g1("data/lequal_g1.gen");
00168   Generator lequal_g2("data/lequal_g2.gen");
00169 
00170   // perform union
00171   Generator boolean_union;
00172   boolean_union.StateNamesEnabled(false);
00173   LanguageUnion(boolean_g1, boolean_g2, boolean_union);
00174   
00175   // perform intersection
00176   Generator boolean_intersection;
00177   boolean_intersection.StateNamesEnabled(false);
00178   LanguageIntersection(boolean_g1, boolean_g2, boolean_intersection);
00179   
00180   // perform complement twice
00181   Generator boolean_complement_g1=boolean_g1; 
00182   boolean_complement_g1.StateNamesEnabled(false);
00183   LanguageComplement(boolean_complement_g1);
00184   Generator boolean_complement2_g1=boolean_complement_g1;
00185   LanguageComplement(boolean_complement2_g1);
00186   
00187   // write results and operands for html docu
00188   boolean_g1.Write("tmp_boolean_g1.gen");
00189   boolean_g2.Write("tmp_boolean_g2.gen");
00190   boolean_union.Write("tmp_union_g1g2.gen");
00191   boolean_intersection.Write("tmp_intersection_g1g2.gen");
00192   boolean_complement_g1.Write("tmp_complement_g1.gen");
00193   boolean_complement2_g1.Write("tmp_complement2_g1.gen");
00194 
00195   // inspect on console
00196   std::cout << "################################\n";
00197   std::cout << "# boolean language operations\n";
00198   boolean_union.DWrite();
00199   boolean_intersection.DWrite();
00200   boolean_complement_g1.DWrite();
00201   std::cout << "################################\n";
00202 
00203   // compare languages
00204   std::cout << "################################\n";
00205   std::cout << "# boolean language operations\n";
00206   if(LanguageInclusion(boolean_g1,boolean_union))  
00207     std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): OK\n";
00208   else
00209     std::cout << "Lm(g1) <= Lm(g1) v Lm(g2): ERR\n";
00210   if(LanguageDisjoint(boolean_complement_g1,boolean_g1))  
00211     std::cout << "Lm(g1) ^ ~Lm(g1) = empty: OK\n";
00212   else
00213     std::cout << "(Lm(g1) v Lm(g2)) ^ ~(Lm(g1) v Lm(g2)) != empty: ERR\n";
00214   if(LanguageEquality(boolean_g1,boolean_complement2_g1))  
00215     std::cout << "Lm(g1) = ~~Lm(g1) : OK\n";
00216   else
00217     std::cout << "Lm(g1) != ~~Lm(g1) : ERR\n";
00218   std::cout << "################################\n";
00219 
00220   // compare languages (track error report, thanks)
00221   std::cout << "################################\n";
00222   std::cout << "# boolean language operations for empty Lm(g1)\n";
00223   if(LanguageInclusion(lequal_g1,lequal_g2))  
00224     std::cout << "Lm(g1) <= Lm(g2): OK\n";
00225   else
00226     std::cout << "Lm(g1) <= Lm(g2): ERR\n";
00227   if(LanguageInclusion(lequal_g2,lequal_g1))  
00228     std::cout << "Lm(g2) <= Lm(g1): ERR\n";
00229   else
00230     std::cout << "~(Lm(g2) <= Lm(g1)): OK\n";
00231   bool boolean_lequal = LanguageEquality(lequal_g1,lequal_g2);
00232   if(boolean_lequal)  
00233     std::cout << "Lm(g1) == Lm(g2): ERR\n";
00234   else
00235     std::cout << "Lm(g1) != Lm(g2): OK\n";
00236 
00237   // Record test case
00238   FAUDES_TEST_DUMP("boolean union",boolean_union);
00239   FAUDES_TEST_DUMP("boolean inter",boolean_intersection);
00240   FAUDES_TEST_DUMP("boolean compl",boolean_complement_g1);
00241   FAUDES_TEST_DUMP("boolean equal",boolean_lequal);
00242 
00243 
00244   ////////////////////////////
00245   // language difference
00246   ////////////////////////////
00247   
00248 
00249   // read generator and write for html docu
00250   Generator difference_g1("data/difference_g1.gen");
00251   difference_g1.Write("tmp_difference_g1.gen");
00252   
00253   Generator difference_g2("data/difference_g2.gen");
00254   difference_g2.Write("tmp_difference_g2.gen");
00255     
00256   // compute language difference Lm(g1)-Lm(g2)
00257   
00258   Generator difference_g1minusg2;
00259   LanguageDifference(difference_g1,difference_g2,difference_g1minusg2);
00260   difference_g1minusg2.Write("tmp_difference_g1minusg2.gen");
00261 
00262   // inspect on console 
00263   std::cout << "################################\n";
00264   std::cout << "# language difference Lm(g1)-Lm(g2) \n";
00265   difference_g1minusg2.DWrite();
00266   std::cout << "################################\n";
00267 
00268   // Record test case
00269   FAUDES_TEST_DUMP("difference",difference_g1minusg2);
00270 
00271 
00272   ////////////////////////////
00273   // convert to automaton
00274   ////////////////////////////
00275   
00276 
00277   // read generator and write for html docu
00278   Generator automaton_g("data/automaton_g.gen");
00279   automaton_g.Write("tmp_automaton_g.gen");
00280   
00281   // convert to automaton
00282   Automaton(automaton_g);
00283   automaton_g.Write("tmp_automaton_gRes.gen");
00284 
00285   // inspect on console 
00286   std::cout << "################################\n";
00287   std::cout << "# automaton from generator \n";
00288   automaton_g.DWrite();
00289   std::cout << "################################\n";
00290   
00291   
00292 
00293   ////////////////////////////
00294   // language concatenation
00295   ////////////////////////////
00296 
00297 
00298   // read generators and write for html docu
00299   Generator concat_g1("data/concat_g1.gen");
00300   Generator concat_g2("data/concat_g2.gen");
00301   Generator concat_g3("data/concat_g3.gen");
00302   Generator concat_g4("data/concat_g4.gen");
00303   Generator concat_g5("data/concat_g5.gen");
00304   Generator concat_g6("data/concat_g6.gen");
00305   concat_g1.Write("tmp_concat_g1.gen");
00306   concat_g2.Write("tmp_concat_g2.gen");
00307   concat_g3.Write("tmp_concat_g3.gen");
00308   concat_g4.Write("tmp_concat_g4.gen");
00309   concat_g5.Write("tmp_concat_g5.gen");
00310   concat_g6.Write("tmp_concat_g6.gen");
00311 
00312 
00313   // perform language concatenations and inspect on console
00314   std::cout << "################################\n";
00315   std::cout << "# language concatenation\n";
00316   Generator concat;
00317   concat.StateNamesEnabled(false);
00318   LanguageConcatenate(concat_g1,concat_g3,concat);
00319   concat.Write("tmp_concat_g1g3.gen");
00320   concat.DWrite();
00321   LanguageConcatenate(concat_g1,concat_g4,concat);
00322   concat.Write("tmp_concat_g1g4.gen");
00323   concat.DWrite();
00324   LanguageConcatenate(concat_g2,concat_g3,concat);
00325   concat.Write("tmp_concat_g2g3.gen");
00326   concat.DWrite();
00327   LanguageConcatenate(concat_g2,concat_g4,concat);
00328   concat.Write("tmp_concat_g2g4.gen");
00329   concat.DWrite();
00330   LanguageConcatenate(concat_g5,concat_g6,concat);
00331   concat.Write("tmp_concat_g5g6.gen");
00332   concat.DWrite();
00333   std::cout << "################################\n";
00334 
00335   // Record test case  
00336   FAUDES_TEST_DUMP("concat ", concat);
00337   
00338 
00339   ////////////////////////////
00340   // full language, alphabet language, empty string language and empty language
00341   ////////////////////////////
00342   
00343   // create alphabet={a,b}
00344   EventSet languages_alphabet;
00345   languages_alphabet.Insert("a");
00346   languages_alphabet.Insert("b");
00347   
00348   // generator for result
00349   Generator languages_g;
00350   
00351   // construct full language from alphabet
00352   FullLanguage(languages_alphabet,languages_g);
00353   languages_g.Write("tmp_languagesFull_result.gen");
00354 
00355   // inspect on console
00356   std::cout << "################################\n";
00357   std::cout << "# full language \n";
00358   languages_g.DWrite();
00359   
00360   // construct alphabet language from alphabet
00361   AlphabetLanguage(languages_alphabet,languages_g);
00362   languages_g.Write("tmp_languagesAlphabet_result.gen");
00363   std::cout << "# alphabet language \n";
00364   languages_g.DWrite();
00365   
00366   // construct empty string language from alphabet
00367   EmptyStringLanguage(languages_alphabet,languages_g);
00368   languages_g.Write("tmp_languagesEmptyString_result.gen");
00369   std::cout << "# empty string language \n";
00370   languages_g.DWrite();
00371   
00372   // construct empty language from alphabet
00373   EmptyLanguage(languages_alphabet,languages_g);
00374   languages_g.Write("tmp_languagesEmpty_result.gen");
00375   std::cout << "# empty language \n";
00376   languages_g.DWrite();
00377   std::cout << "################################\n";
00378 
00379 
00380 
00381   ////////////////////////////
00382   // Kleene closure
00383   ////////////////////////////
00384   
00385 
00386   // read generator and write for html docu
00387   Generator kleene_g("data/kleene_g.gen");
00388   kleene_g.Write("tmp_kleene_g.gen");
00389   
00390   // compute Kleene closure
00391   kleene_g.StateNamesEnabled(false);
00392   KleeneClosure(kleene_g);
00393   kleene_g.Write("tmp_kleene_gRes.gen");
00394 
00395   // inspect on console 
00396   std::cout << "################################\n";
00397   std::cout << "# Kleene closure \n";
00398   kleene_g.DWrite();
00399   std::cout << "################################\n";
00400   
00401   // Record test case  
00402   FAUDES_TEST_DUMP("kleene closure ", kleene_g);
00403   
00404 
00405   ////////////////////////////
00406   // prefix closure
00407   ////////////////////////////
00408   
00409 
00410   // read generator and write for html docu
00411   Generator prefixclosure_g("data/prefixclosure_g.gen");
00412   prefixclosure_g.Write("tmp_prefixclosure_g.gen");
00413 
00414   // test prefix closure
00415   bool isprefixclosed_g = IsPrefixClosed(prefixclosure_g);
00416   
00417   // compute prefix closure
00418   PrefixClosure(prefixclosure_g);
00419   prefixclosure_g.Write("tmp_prefixclosure_gRes.gen");
00420 
00421   // test prefix closure
00422   bool isprefixclosed_gRes = IsPrefixClosed(prefixclosure_g);
00423 
00424   // inspect on console 
00425   std::cout << "################################\n";
00426   std::cout << "# prefix closure \n";
00427   if(isprefixclosed_g) 
00428      std::cout << "# argument was prefix closed (test case error!)\n";
00429   else
00430      std::cout << "# argument was not prefix closed (expected)\n";
00431   if(isprefixclosed_gRes) 
00432      std::cout << "# result is prefix closed (expected)\n";
00433   else
00434      std::cout << "# result is not prefix closed (test case error!)\n";
00435   prefixclosure_g.DWrite();
00436   std::cout << "################################\n";
00437   
00438   // Record test case  
00439   FAUDES_TEST_DUMP("prefix closure", prefixclosure_g);
00440 
00441 
00442   ////////////////////////////
00443   // omega closure
00444   ////////////////////////////
00445   
00446 
00447   // read generator and write for html docu
00448   Generator omegaclosure_g("data/omegaclosure_g.gen");
00449   omegaclosure_g.Write("tmp_omegaclosure_g.gen");
00450   
00451   // test omega closure
00452   bool isomegaclosed_g = IsOmegaClosed(omegaclosure_g);
00453   
00454   // compute omega closure
00455   OmegaClosure(omegaclosure_g);
00456   omegaclosure_g.Write("tmp_omegaclosure_gRes.gen");
00457 
00458   // test omega closure
00459   bool isomegaclosed_gRes = IsOmegaClosed(omegaclosure_g);
00460   
00461   // inspect on console 
00462   std::cout << "################################\n";
00463   std::cout << "# omega closure \n";
00464   if(isomegaclosed_g) 
00465      std::cout << "# argument was omega closed (test case error!)\n";
00466   else
00467      std::cout << "# argument was not omega closed (expected)\n";
00468   if(isomegaclosed_gRes) 
00469      std::cout << "# result is omega closed (expected)\n";
00470   else
00471      std::cout << "# result is not omega closed (test case error!)\n";
00472   omegaclosure_g.DWrite();
00473   std::cout << "################################\n";
00474   
00475   // Record test case  
00476   FAUDES_TEST_DUMP("omega closure", omegaclosure_g);
00477 
00478 
00479   ////////////////////////////
00480   // selfloop
00481   ////////////////////////////
00482   
00483 
00484   // read generator and write for html docu
00485   Generator selfloop_g("data/selfloop_g.gen");
00486   selfloop_g.Write("tmp_selfloop_g.gen");
00487   
00488   // create alphabet={e,f}
00489   EventSet selfloop_alphabet;
00490   selfloop_alphabet.Insert("e");
00491   selfloop_alphabet.Insert("f");
00492   
00493   // generator for result
00494   Generator selfloop_gRes=selfloop_g;
00495   
00496   // add selfloops in each state
00497   SelfLoop(selfloop_gRes,selfloop_alphabet);
00498   selfloop_gRes.Write("tmp_selfloop_gRes.gen");
00499 
00500   // inspect on console 
00501   std::cout << "################################\n";
00502   std::cout << "# selfloop, each state \n";
00503   selfloop_gRes.DWrite();
00504   
00505   // add selfloops in marked states
00506   selfloop_gRes=selfloop_g;
00507   SelfLoopMarkedStates(selfloop_gRes,selfloop_alphabet);
00508   selfloop_gRes.Write("tmp_selfloopMarked_gRes.gen");
00509   std::cout << "# selfloop, marked states \n";
00510   selfloop_gRes.DWrite();
00511   
00512   // add selfloops in inital state(s)
00513   selfloop_gRes=selfloop_g;
00514   SelfLoop(selfloop_gRes,selfloop_alphabet,selfloop_gRes.InitStates());
00515   selfloop_gRes.Write("tmp_selfloopInit_gRes.gen");
00516   std::cout << "# selfloop, init state(s) \n";
00517   selfloop_gRes.DWrite();
00518   std::cout << "################################\n";
00519 
00520   FAUDES_TEST_DIFF()
00521 
00522   // say good bye    
00523   std::cout << "done.\n";
00524   return 0;
00525 }
00526 
00527 
00528 

libFAUDES 2.23h --- 2014.04.03 --- c++ api documentaion by doxygen