3_functions.cppGo 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 |