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

libFAUDES 2.20d --- 2011.04.26 --- c++ source docu by doxygen