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

libFAUDES 2.16b --- 2010-9-8 --- c++ source docu by doxygen 1.6.3