More renaming and refactoring

adeterminize2/src/adeterminize.cpp

@@ -10,10 +10,7 @@
 #include "factory/DataFactory.hpp"
 #include "exception/AlibException.h"
-#include "automaton/determinize/nfa/NFADeterminizer.h"
-#include "automaton/determinize/idpda/IDPDADeterminizer.h"
-#include "automaton/determinize/vpa/VPADeterminizer.h"
-#include "automaton/determinize/hdpda/HDPDADeterminizer.h"
+#include "automaton/determinize/Determinize.h"
 #include "automaton/transform/PDAToRHPDA.h"
 #include "automaton/transform/RHPDAToPDA.h"
@@ -93,7 +90,7 @@ int main(int argc, char** argv) {
 			std::string xmlMark = tokens.front( ).getData( );
 			if(xmlMark == "NFA") {
 				automaton::NFA nfa = alib::DataFactory::fromTokens<automaton::NFA>(tokens);
-				automaton::DFA dfa = determinize::NFADeterminizer::determinize(nfa);
+				automaton::DFA dfa = automaton::determinize::Determinize::determinize(nfa);
 				alib::DataFactory::toStdout(dfa);
 				return 0;
 			} else if(xmlMark == "DFA") {
@@ -106,18 +103,18 @@ int main(int argc, char** argv) {
 		} else if (type == TYPE_IDPDA) {
 			automaton::InputDrivenNPDA npda = alib::DataFactory::fromTokens<automaton::InputDrivenNPDA>(tokens);
-			automaton::DPDA dpda = determinize::IDPDADeterminizer::determinize(npda);
+			automaton::DPDA dpda = automaton::determinize::Determinize::determinize(npda);
 			alib::DataFactory::toStdout(dpda);
 			return 0;
 		} else if (type == TYPE_VPA) {
 			automaton::VisiblyPushdownNPDA npda = alib::DataFactory::fromTokens<automaton::VisiblyPushdownNPDA>(tokens);
-			automaton::VisiblyPushdownDPDA dpda = determinize::VPADeterminizer::determinize(npda);
+			automaton::VisiblyPushdownDPDA dpda = automaton::determinize::Determinize::determinize(npda);
 			alib::DataFactory::toStdout(dpda);
 			return 0;
 		} else if (type == TYPE_RHDPDA) {
 			automaton::NPDA npda = alib::DataFactory::fromTokens<automaton::NPDA>(tokens);
 			automaton::RealTimeHeightDeterministicNPDA rhpda = automaton::PDAToRHPDA::convert(npda);
-			automaton::RealTimeHeightDeterministicDPDA dpda = determinize::HDPDADeterminizer::determinize(rhpda);
+			automaton::RealTimeHeightDeterministicDPDA dpda = automaton::determinize::Determinize::determinize(rhpda);
 			automaton::DPDA dpda2 = automaton::RHPDAToPDA::convert(dpda);
 			alib::DataFactory::toStdout(dpda2);
 			return 0;

alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp

@@ -48,9 +48,7 @@ regexp::RegExp ToRegExpStateElimination::convert(const T& automaton)
         extendedAutomaton = eliminateState(extendedAutomaton, state);
     // step 4
-    regexp::RegExpOptimize opt;
-
-    return regexp::RegExpOptimize::optimize(regexp::RegExpConcatenate::concatenate(
+    return regexp::simplify::RegExpOptimize::optimize(regexp::RegExpConcatenate::concatenate(
 				transition(extendedAutomaton, extendedAutomaton.getInitialState(), *extendedAutomaton.getFinalStates().begin()),
 				regexp::RegExpIterate::iterate(transition(extendedAutomaton, *extendedAutomaton.getFinalStates().begin(), *extendedAutomaton.getFinalStates().begin()))));
 }
@@ -64,8 +62,6 @@ automaton::ExtendedNFA ToRegExpStateElimination::eliminateState(const automaton:
     newAutomaton.setInputSymbols(extendedAutomaton.getInputAlphabet());
     newAutomaton.setFinalStates(extendedAutomaton.getFinalStates());
-    regexp::RegExpOptimize opt;
-
     for(const auto& p: newAutomaton.getStates())
     {
         for(const auto& r : newAutomaton.getStates())
@@ -76,7 +72,7 @@ automaton::ExtendedNFA ToRegExpStateElimination::eliminateState(const automaton:
             regexp::RegExp alt = regexp::RegExpAlternate::alternate(concat, transition(extendedAutomaton, p, r));
-            newAutomaton.addTransition(p, regexp::RegExpOptimize::optimize(alt), r);
+            newAutomaton.addTransition(p, regexp::simplify::RegExpOptimize::optimize(alt), r);
         }
     }
@@ -85,14 +81,13 @@ automaton::ExtendedNFA ToRegExpStateElimination::eliminateState(const automaton:
 const regexp::RegExp ToRegExpStateElimination::transition(const automaton::ExtendedNFA& automaton, const automaton::State& from, const automaton::State& to)
 {
-    regexp::RegExpOptimize opt;
     regexp::RegExp ret(regexp::UnboundedRegExp(regexp::UnboundedRegExpEmpty { }));
     for(const auto& transition: automaton.getTransitionsFromState(from))
         if(transition.second.count(to) > 0)
             ret = regexp::RegExpAlternate::alternate(ret, transition.first.second);
-    return regexp::RegExpOptimize::optimize(ret);
+    return regexp::simplify::RegExpOptimize::optimize(ret);
 }
 void ToRegExpStateElimination::extendExtendedNFA(automaton::ExtendedNFA& automaton)

alib2algo/src/automaton/determinize/Determinize.cpp

+/*
+ * Determinize.cpp
+ *
+ *  Created on: 16. 1. 2014
+ *	  Author: Jan Vesely
+ */
+
+#include "Determinize.h"
+
+namespace automaton {
+
+namespace determinize {
+
+automaton::Automaton Determinize::determinize(const automaton::Automaton& automaton) {
+	automaton::Automaton* out = NULL;
+	automaton.getData().Accept((void*) &out, Determinize::DETERMINIZE);
+	automaton::Automaton res = std::move(*out);
+	delete out;
+	return res;
+}
+
+void Determinize::Visit(void*, const automaton::EpsilonNFA&) const {
+	throw exception::AlibException("Unsupported automaton type EpsilonNFA");
+}
+
+void Determinize::Visit(void* data, const automaton::MultiInitialStateNFA& automaton) const {
+	automaton::Automaton* & out = *((automaton::Automaton**) data);
+	out = new automaton::Automaton(this->determinize(automaton));
+}
+
+void Determinize::Visit(void* data, const automaton::NFA& automaton) const {
+	automaton::Automaton* & out = *((automaton::Automaton**) data);
+	out = new automaton::Automaton(this->determinize(automaton));
+}
+
+void Determinize::Visit(void*, const automaton::DFA&) const {
+	throw exception::AlibException("Unsupported automaton type DFA");
+}
+
+void Determinize::Visit(void*, const automaton::ExtendedNFA& ) const {
+	throw exception::AlibException("Unsupported automaton type ExtendedNFA");
+}
+
+void Determinize::Visit(void*, const automaton::CompactNFA& ) const {
+	throw exception::AlibException("Unsupported automaton type CompactNFA");
+}
+
+void Determinize::Visit(void*, const automaton::DPDA&) const {
+	throw exception::AlibException("Unsupported automaton type DPDA");
+}
+
+void Determinize::Visit(void*, const automaton::SinglePopDPDA&) const {
+	throw exception::AlibException("Unsupported automaton type SinglePopDPDA");
+}
+
+void Determinize::Visit(void* data, const automaton::InputDrivenNPDA& automaton) const {
+	automaton::Automaton* & out = *((automaton::Automaton**) data);
+	out = new automaton::Automaton(this->determinize(automaton));
+}
+
+void Determinize::Visit(void*, const automaton::VisiblyPushdownDPDA&) const {
+	throw exception::AlibException("Unsupported automaton type VisiblyPushdownDPDA");
+}
+
+void Determinize::Visit(void* data, const automaton::VisiblyPushdownNPDA& automaton) const {
+	automaton::Automaton* & out = *((automaton::Automaton**) data);
+	out = new automaton::Automaton(this->determinize(automaton));
+}
+
+void Determinize::Visit(void*, const automaton::RealTimeHeightDeterministicDPDA&) const {
+	throw exception::AlibException("Unsupported automaton type RealTimeHeightDeterministicDPDA");
+}
+
+void Determinize::Visit(void* data, const automaton::RealTimeHeightDeterministicNPDA& automaton) const {
+	automaton::Automaton* & out = *((automaton::Automaton**) data);
+	out = new automaton::Automaton(this->determinize(automaton));
+}
+
+void Determinize::Visit(void*, const automaton::NPDA&) const {
+	throw exception::AlibException("Unsupported automaton type NPDA");
+}
+
+void Determinize::Visit(void*, const automaton::SinglePopNPDA&) const {
+	throw exception::AlibException("Unsupported automaton type SinglePopNPDA");
+}
+
+void Determinize::Visit(void*, const automaton::OneTapeDTM&) const {
+	throw exception::AlibException("Unsupported automaton type OneTapeDTM");
+}
+
+const Determinize Determinize::DETERMINIZE;
+
+} /* namespace determinize */
+
+} /* namespace automaton */
+
+#include "DeterminizeNFAPart.cxx"
+#include "DeterminizeIDPDAPart.cxx"
+#include "DeterminizeVPAPart.cxx"
+#include "DeterminizeRHDPDAPart.cxx"
+

alib2algo/src/automaton/determinize/nfa/NFADeterminizer.h → alib2algo/src/automaton/determinize/Determinize.h

@@ -5,25 +5,28 @@
  *	  Author: Jan Vesely
  */
-#ifndef NFA_DETERMINIZER_H_
-#define NFA_DETERMINIZER_H_
+#ifndef DETERMINIZE_H_
+#define DETERMINIZE_H_
 #include <set>
 #include <automaton/common/State.h>
 #include <automaton/Automaton.h>
-#include <automaton/FSM/NFA.h>
-#include <automaton/FSM/MultiInitialStateNFA.h>
 #include <automaton/FSM/DFA.h>
+#include <automaton/PDA/DPDA.h>
+#include <automaton/PDA/VisiblyPushdownDPDA.h>
+#include <automaton/PDA/RealTimeHeightDeterministicDPDA.h>
 #include <exception/AlibException.h>
+namespace automaton {
+
 namespace determinize {
 /**
  * Class for running determinization algorithm on fsm.
  */
-class NFADeterminizer : public automaton::VisitableAutomatonBase::const_visitor_type {
+class Determinize : public automaton::VisitableAutomatonBase::const_visitor_type {
 private:
 	void Visit(void*, const automaton::EpsilonNFA& automaton) const;
 	void Visit(void*, const automaton::MultiInitialStateNFA& automaton) const;
@@ -42,7 +45,7 @@ private:
 	void Visit(void*, const automaton::SinglePopNPDA& automaton) const;
 	void Visit(void*, const automaton::OneTapeDTM& automaton) const;
-	static const NFADeterminizer NFA_DETERMINIZER;
+	static const Determinize DETERMINIZE;
 public:
@@ -55,8 +58,13 @@ public:
 	static automaton::DFA determinize(const automaton::NFA& nfa);
 	static automaton::DFA determinize(const automaton::MultiInitialStateNFA& nfa);
+	static automaton::VisiblyPushdownDPDA determinize(const automaton::VisiblyPushdownNPDA& nondeterministic);
+	static automaton::DPDA determinize(const automaton::InputDrivenNPDA& nfa);
+	static automaton::RealTimeHeightDeterministicDPDA determinize(const automaton::RealTimeHeightDeterministicNPDA& nondeterministic);
 };
 } /* namespace determinize */
-#endif /* NFA_DETERMINIZER_H_ */
+} /* namespace automaton */
+
+#endif /* DETERMINIZE_H_ */

alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.cpp → alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx

@@ -5,16 +5,17 @@
  *	  Author: Jan Vesely
  */
-#include "IDPDADeterminizer.h"
-#include "../common/NFACommon.h"
+#include "common/NFACommon.h"
+#include <automaton/PDA/InputDrivenNPDA.h>
 #include <deque>
 #include <algorithm>
-namespace determinize {
-automaton::DPDA IDPDADeterminizer::determinize(const automaton::InputDrivenNPDA& nfa) {
+namespace automaton {
+namespace determinize {
+automaton::DPDA Determinize::determinize(const automaton::InputDrivenNPDA& nfa) {
 	// 1, 4
 	automaton::State initialState(createDFAState(nfa.getInitialStates()));
 	automaton::DPDA res(initialState, nfa.getInitialSymbol());
@@ -63,4 +64,6 @@ automaton::DPDA IDPDADeterminizer::determinize(const automaton::InputDrivenNPDA&
 	return res;
 }
-}
+} /* namespace determinize */
+
+} /* namespace automaton */

alib2algo/src/automaton/determinize/nfa/NFADeterminizer.cpp → alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx

@@ -5,23 +5,18 @@
  *	  Author: Jan Vesely
  */
-#include "NFADeterminizer.h"
-#include "../common/NFACommon.h"
+#include "common/NFACommon.h"
+#include <automaton/FSM/NFA.h>
+#include <automaton/FSM/MultiInitialStateNFA.h>
 #include <deque>
 #include <algorithm>
-namespace determinize {
-automaton::Automaton NFADeterminizer::determinize(const automaton::Automaton& automaton) {
-	automaton::Automaton* out = NULL;
-	automaton.getData().Accept((void*) &out, NFADeterminizer::NFA_DETERMINIZER);
-	automaton::Automaton res = std::move(*out);
-	delete out;
-	return res;
-}
-automaton::DFA NFADeterminizer::determinize(const automaton::MultiInitialStateNFA& nfa) {
+namespace automaton {
+namespace determinize {
+automaton::DFA Determinize::determinize(const automaton::MultiInitialStateNFA& nfa) {
 	// 1, 4
 	automaton::State initialState(createDFAState(nfa.getInitialStates()));
 	automaton::DFA res(initialState);
@@ -68,7 +63,7 @@ automaton::DFA NFADeterminizer::determinize(const automaton::MultiInitialStateNF
 	return res;
 }
-automaton::DFA NFADeterminizer::determinize(const automaton::NFA& nfa) {
+automaton::DFA Determinize::determinize(const automaton::NFA& nfa) {
 	// 1, 4
 	automaton::State initialState(createDFAState({nfa.getInitialState()}));
 	automaton::DFA res(initialState);
@@ -115,72 +110,6 @@ automaton::DFA NFADeterminizer::determinize(const automaton::NFA& nfa) {
 	return res;
 }
-void NFADeterminizer::Visit(void*, const automaton::EpsilonNFA&) const {
-	throw exception::AlibException("Unsupported automaton type EpsilonNFA");
-}
-
-void NFADeterminizer::Visit(void* data, const automaton::MultiInitialStateNFA& automaton) const {
-	automaton::Automaton* & out = *((automaton::Automaton**) data);
-	out = new automaton::Automaton(this->determinize(automaton));
-}
-
-void NFADeterminizer::Visit(void* data, const automaton::NFA& automaton) const {
-	automaton::Automaton* & out = *((automaton::Automaton**) data);
-	out = new automaton::Automaton(this->determinize(automaton));
-}
-
-void NFADeterminizer::Visit(void*, const automaton::DFA&) const {
-	throw exception::AlibException("Unsupported automaton type DFA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::ExtendedNFA& ) const {
-	throw exception::AlibException("Unsupported automaton type ExtendedNFA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::CompactNFA& ) const {
-	throw exception::AlibException("Unsupported automaton type CompactNFA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::DPDA&) const {
-	throw exception::AlibException("Unsupported automaton type DPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::SinglePopDPDA&) const {
-	throw exception::AlibException("Unsupported automaton type SinglePopDPDA");
-}
-void NFADeterminizer::Visit(void*, const automaton::InputDrivenNPDA&) const {
-	throw exception::AlibException("Unsupported automaton type InputDrivenNPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::VisiblyPushdownDPDA&) const {
-	throw exception::AlibException("Unsupported automaton type VisiblyPushdownDPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::VisiblyPushdownNPDA&) const {
-	throw exception::AlibException("Unsupported automaton type VisiblyPushdownNPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::RealTimeHeightDeterministicDPDA&) const {
-	throw exception::AlibException("Unsupported automaton type RealTimeHeightDeterministicDPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::RealTimeHeightDeterministicNPDA&) const {
-	throw exception::AlibException("Unsupported automaton type RealTimeHeightDeterministicNPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::NPDA&) const {
-	throw exception::AlibException("Unsupported automaton type NPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::SinglePopNPDA&) const {
-	throw exception::AlibException("Unsupported automaton type SinglePopNPDA");
-}
-
-void NFADeterminizer::Visit(void*, const automaton::OneTapeDTM&) const {
-	throw exception::AlibException("Unsupported automaton type OneTapeDTM");
-}
-
-const NFADeterminizer NFADeterminizer::NFA_DETERMINIZER;
-
-}
+} /* namespace determinize */
+} /* namespace automaton */

alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.cpp → alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx

-#include "HDPDADeterminizer.h"
-#include "../common/RHDPDACommon.h"
+/*
+ * NFADeterminizer.cpp
+ *
+ *  Created on: 16. 1. 2014
+ *	  Author: Jan Travnicek
+ */
+#include "common/RHDPDACommon.h"
+
+#include <automaton/PDA/RealTimeHeightDeterministicNPDA.h>
 #include "automaton/common/State.h"
 #include "alphabet/Symbol.h"
 #include "alphabet/LabeledSymbol.h"
@@ -9,6 +16,8 @@
 #include <std/set.hpp>
 #include <iostream>
+namespace automaton {
+
 namespace determinize {
 void addRetTransition(const automaton::State& from, const std::variant<string::Epsilon, alphabet::Symbol>& input, const alphabet::Symbol& dvpdaSymbol, const automaton::State& to, automaton::RealTimeHeightDeterministicDPDA& deterministic) {
@@ -185,7 +194,7 @@ std::tuple<std::set<std::variant<string::Epsilon, alphabet::Symbol>>, std::set<s
 	return std::make_tuple(local, call, ret);
 }
-automaton::RealTimeHeightDeterministicDPDA HDPDADeterminizer::determinize(const automaton::RealTimeHeightDeterministicNPDA& n) {
+automaton::RealTimeHeightDeterministicDPDA Determinize::determinize(const automaton::RealTimeHeightDeterministicNPDA& n) {
 	label::Label initialLabel = packToStateLabel(createIdentity(retrieveLabels(n.getInitialStates())));
 	automaton::RealTimeHeightDeterministicDPDA d(automaton::State(initialLabel), n.getBottomOfTheStackSymbol());
@@ -239,4 +248,6 @@ automaton::RealTimeHeightDeterministicDPDA HDPDADeterminizer::determinize(const
 	return d;
 }
-}
+} /* namespace determinize */
+
+} /* namespace automaton */

alib2algo/src/automaton/determinize/vpa/VPADeterminizer.cpp → alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx

-#include "VPADeterminizer.h"
-#include "../common/RHDPDACommon.h"
+/*
+ * NFADeterminizer.cpp
+ *
+ *  Created on: 16. 1. 2014
+ *	  Author: Jan Travnicek
+ */
+#include "common/RHDPDACommon.h"
+
+#include <automaton/PDA/VisiblyPushdownNPDA.h>
 #include "automaton/common/State.h"
 #include "alphabet/Symbol.h"
 #include "alphabet/LabeledSymbol.h"
@@ -8,6 +15,8 @@
 #include <std/set.hpp>
 #include <iostream>
+namespace automaton {
+
 namespace determinize {
 void addRetTransition(const automaton::State& from, const alphabet::Symbol& input, const alphabet::Symbol& dvpdaSymbol, const automaton::State& to, automaton::VisiblyPushdownDPDA& deterministic) {
@@ -150,7 +159,7 @@ void local(const automaton::State& state, const alphabet::Symbol& input, const a
 	addLocalTransition(state, input, automaton::State(packToStateLabel(std::move(S1))), deterministic);
 }
-automaton::VisiblyPushdownDPDA VPADeterminizer::determinize(const automaton::VisiblyPushdownNPDA& n) {
+automaton::VisiblyPushdownDPDA Determinize::determinize(const automaton::VisiblyPushdownNPDA& n) {
 	label::Label initialLabel = packToStateLabel(createIdentity(retrieveLabels(n.getInitialStates())));
 	
 	automaton::VisiblyPushdownDPDA d(automaton::State(initialLabel), n.getBottomOfTheStackSymbol());
@@ -194,4 +203,6 @@ automaton::VisiblyPushdownDPDA VPADeterminizer::determinize(const automaton::Vis
 	return d;
 }
-}
+} /* namespace determinize */
+
+} /* namespace automaton */

alib2algo/src/automaton/determinize/common/NFACommon.cpp

@@ -11,6 +11,8 @@
 #include <deque>
 #include <algorithm>
+namespace automaton {
+
 namespace determinize {
 automaton::State createDFAState(const std::set<automaton::State>& nfaStates) {
@@ -29,4 +31,6 @@ std::set<automaton::State> recreateNFAStates(const automaton::State& dfaState) {
 	return states;
 }
-}
+} /* namespace determinize */
+
+} /* namespace automaton */

alib2algo/src/automaton/determinize/common/NFACommon.h

@@ -11,6 +11,8 @@
 #include <automaton/common/State.h>
 #include <set>
+namespace automaton {
+
 namespace determinize {
 /**
@@ -34,4 +36,6 @@ std::set<automaton::State> recreateNFAStates(const automaton::State& dfaState);
 } /* namespace determinize */
+} /* namespace automaton */
+
 #endif /* NFA_COMMON_H_ */

alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp

@@ -10,6 +10,8 @@
 #include "automaton/PDA/RealTimeHeightDeterministicDPDA.h"
 #include "automaton/PDA/RealTimeHeightDeterministicNPDA.h"
+namespace automaton {
+
 namespace determinize {
 label::Label packToStateLabel(std::set<std::pair<label::Label, label::Label>>&& data) {
@@ -221,4 +223,6 @@ std::set<label::Label> retrieveLabels(const std::set<automaton::State>& states)
 	return labels;
 }
+} /* namespace automaton */
+
 } /* namespace determinize */

alib2algo/src/automaton/determinize/common/RHDPDACommon.h

@@ -9,6 +9,8 @@
 #include <set>
 #include <map>
+namespace automaton {
+
 namespace determinize {
 label::Label packToStateLabel(std::set<std::pair<label::Label, label::Label>>&& data);
@@ -40,4 +42,6 @@ std::set<label::Label> retrieveLabels(const std::set<automaton::State>& states);
 } /* namespace determinize */
+} /* namespace automaton */
+
 #endif /* RHDPDA_VPA_COMMON_H_ */

alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.h

-#ifndef HDPDA_DETERMINIZER_H_
-#define HDPDA_DETERMINIZER_H_
-
-#include "automaton/PDA/RealTimeHeightDeterministicNPDA.h"
-#include "automaton/PDA/RealTimeHeightDeterministicDPDA.h"
-
-namespace determinize {
-
-/**
- * Class for running basic determinization algorithm on vpa.
- */
-class HDPDADeterminizer {
-public:
-	/**
-	 * Runs determinization algorithm on nondeterministic vpa given in constructor.
-	 *
-	 * @return deterministic visibly pushdown automaton
-	 */
-	static automaton::RealTimeHeightDeterministicDPDA determinize(const automaton::RealTimeHeightDeterministicNPDA& nondeterministic);
-
-};
-
-} /* namespace determinize */
-
-#endif /* HDPDA_DETERMINIZER_h_ */

alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.h

-/*
- * IDPDADeterminizer.h
- *
- *  Created on: 16. 1. 2014
- *	  Author: Jan Vesely
- */
-
-#ifndef IDPDA_DETERMINIZER_H_
-#define IDPDA_DETERMINIZER_H_
-
-#include <set>
-
-#include "automaton/common/State.h"
-#include "automaton/PDA/InputDrivenNPDA.h"
-#include "automaton/PDA/DPDA.h"
-
-namespace determinize {
-
-/**
- * Class for running determinization algorithm on fsm.
- */
-class IDPDADeterminizer {
-public:
-
-	/**
-	 * @param nfsm nondeterministic final-state machine given for determinization
-	 * Runs determinization algorithm on nondeterministic fsm given in constructor.
-	 */
-	static automaton::DPDA determinize(const automaton::InputDrivenNPDA& nfa);
-
-};
-
-} /* namespace determinize */
-
-#endif /* IDPDA_DETERMINIZER_H_ */

alib2algo/src/automaton/determinize/vpa/VPADeterminizer.h

-#ifndef VPADETERMINIZER_H_
-#define VPADETERMINIZER_H_
-
-#include "automaton/PDA/VisiblyPushdownNPDA.h"
-#include "automaton/PDA/VisiblyPushdownDPDA.h"
-
-namespace determinize {
-
-/**
- * Class for running basic determinization algorithm on vpa.
- */
-class VPADeterminizer {
-public:
-	/**
-	 * Runs determinization algorithm on nondeterministic vpa given in constructor.
-	 *
-	 * @return deterministic visibly pushdown automaton
-	 */
-	static automaton::VisiblyPushdownDPDA determinize(const automaton::VisiblyPushdownNPDA& nondeterministic);
-
-};
-
-} /* namespace determinize */
-
-#endif /* VPADETERMINIZER_H_ */

alib2algo/src/equations/LeftRegularEquationSolver.cpp

@@ -13,8 +13,6 @@
 namespace equations {
 regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
-	regexp::RegExpOptimize opt;
-
 	for(auto itA = nonterminalSymbolsByDepth.rbegin(); itA != nonterminalSymbolsByDepth.rend(); itA ++) {
 		const alphabet::Symbol& a = * itA;
@@ -24,7 +22,7 @@ regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
 		 * => A = 10*B + 20*C
 		 */
 		regexp::UnboundedRegExpIteration loop(std::move(equationTransition.find(std::make_pair(a, a))->second));
-		regexp::RegExpOptimize::optimize(loop);
+		regexp::simplify::RegExpOptimize::optimize(loop);
 		// for all transitions from A apply Arden's Lemma
 		for(auto itB = std::next(itA) ; itB != nonterminalSymbolsByDepth.rend(); itB ++) {
@@ -35,7 +33,7 @@ regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
 			regexp::UnboundedRegExpAlternation alt;
 			alt.appendElement(std::move(concat));
 			equationTransition.find(std::make_pair(a, b))->second = std::move(alt);
-			regexp::RegExpOptimize::optimize(equationTransition.find(std::make_pair(a, b))->second);
+			regexp::simplify::RegExpOptimize::optimize(equationTransition.find(std::make_pair(a, b))->second);
 		}
 		regexp::UnboundedRegExpConcatenation concat;
 		concat.appendElement(std::move(equationFinal.find(a)->second));
@@ -43,7 +41,7 @@ regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
 		regexp::UnboundedRegExpAlternation alt;
 		alt.appendElement(std::move(concat));
 		equationFinal.find(a)->second = std::move(alt);
-		regexp::RegExpOptimize::optimize(equationFinal.find(a)->second);
+		regexp::simplify::RegExpOptimize::optimize(equationFinal.find(a)->second);
 		/*
 		 * eliminate A from rest of the equations using this pattern:
@@ -62,7 +60,7 @@ regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
 				alt.appendElement(std::move(equationTransition.find(std::make_pair(b, c))->second));
 				alt.appendElement(std::move(concat));
 				equationTransition.find(std::make_pair(b, c))->second = std::move(alt);
-				regexp::RegExpOptimize::optimize(equationTransition.find(std::make_pair(b, c))->second);
+				regexp::simplify::RegExpOptimize::optimize(equationTransition.find(std::make_pair(b, c))->second);
 			}
 			regexp::UnboundedRegExpConcatenation concat;
@@ -72,11 +70,11 @@ regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
 			alt.appendElement(std::move(equationFinal.find(b)->second));
 			alt.appendElement(std::move(concat));
 			equationFinal.find(b)->second = std::move(alt);
-			regexp::RegExpOptimize::optimize(equationFinal.find(b)->second);
+			regexp::simplify::RegExpOptimize::optimize(equationFinal.find(b)->second);
 		}
 	}
-	return regexp::RegExpOptimize::optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
+	return regexp::simplify::RegExpOptimize::optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
 }
 } /* namespace equations */

alib2algo/src/equations/RightRegularEquationSolver.cpp

@@ -13,8 +13,6 @@
 namespace equations {
 regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
-	regexp::RegExpOptimize opt;
-
 	for(auto itA = nonterminalSymbolsByDepth.rbegin(); itA != nonterminalSymbolsByDepth.rend(); itA ++) {
 		const alphabet::Symbol& a = * itA;
@@ -24,7 +22,7 @@ regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
 		 * => A = 0*1B + 0*2C
 		 */
 		regexp::UnboundedRegExpIteration loop(std::move(equationTransition.find(std::make_pair(a, a))->second));
-		regexp::RegExpOptimize::optimize(loop);
+		regexp::simplify::RegExpOptimize::optimize(loop);
 		// for all transitions from A apply Arden's Lemma
 		for(auto itB = std::next(itA) ; itB != nonterminalSymbolsByDepth.rend(); itB ++) {
@@ -35,7 +33,7 @@ regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
 			regexp::UnboundedRegExpAlternation alt;
 			alt.appendElement(std::move(concat));
 			equationTransition.find(std::make_pair(a, b))->second = std::move(alt);
-			regexp::RegExpOptimize::optimize(equationTransition.find(std::make_pair(a, b))->second);
+			regexp::simplify::RegExpOptimize::optimize(equationTransition.find(std::make_pair(a, b))->second);
 		}
 		regexp::UnboundedRegExpConcatenation concat;
 		concat.appendElement(std::move(loop));
@@ -43,7 +41,7 @@ regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
 		regexp::UnboundedRegExpAlternation alt;
 		alt.appendElement(std::move(concat));
 		equationFinal.find(a)->second = std::move(alt);
-		regexp::RegExpOptimize::optimize(equationFinal.find(a)->second);
+		regexp::simplify::RegExpOptimize::optimize(equationFinal.find(a)->second);
 		/*
 		 * eliminate A from rest of the equations using this pattern:
@@ -62,7 +60,7 @@ regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
 				alt.appendElement(std::move(equationTransition.find(std::make_pair(b, c))->second));
 				alt.appendElement(std::move(concat));
 				equationTransition.find(std::make_pair(b, c))->second = std::move(alt);
-				regexp::RegExpOptimize::optimize(equationTransition.find(std::make_pair(b, c))->second);
+				regexp::simplify::RegExpOptimize::optimize(equationTransition.find(std::make_pair(b, c))->second);
 			}
 			regexp::UnboundedRegExpConcatenation concat;
@@ -72,11 +70,11 @@ regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
 			alt.appendElement(std::move(equationFinal.find(b)->second));
 			alt.appendElement(std::move(concat));
 			equationFinal.find(b)->second = std::move(alt);
-			regexp::RegExpOptimize::optimize(equationFinal.find(b)->second);
+			regexp::simplify::RegExpOptimize::optimize(equationFinal.find(b)->second);
 		}
 	}
-	return regexp::RegExpOptimize::optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
+	return regexp::simplify::RegExpOptimize::optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
 }
 } /* namespace equations */

alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp

@@ -36,8 +36,7 @@ template<class T>
 automaton::NFA ToAutomatonDerivation::convert(const T& regexp)
 {
 	// 1.
-	regexp::RegExpOptimize opt;
-	regexp::RegExp V = regexp::RegExp{regexp::RegExpOptimize::optimize(regexp)};
+	regexp::RegExp V = regexp::RegExp{regexp::simplify::RegExpOptimize::optimize(regexp)};
 	std::set<regexp::RegExp> Q = { V };
 	std::deque<std::set<regexp::RegExp>> Qi;
@@ -60,7 +59,7 @@ automaton::NFA ToAutomatonDerivation::convert(const T& regexp)
 			{
 				string::LinearString string(std::vector<alphabet::Symbol>{a});
 				regexp::RegExp derived = deriv.derivation(dregexp, string);
-				derived = regexp::RegExpOptimize::optimize(derived);
+				derived = regexp::simplify::RegExpOptimize::optimize(derived);
 				// this will also add \emptyset as a regexp (and as FA state)
 				if(Q.count(derived) == 0) // if this state has already been found, do not add
@@ -101,7 +100,7 @@ automaton::NFA ToAutomatonDerivation::convert(const T& regexp)
 		{
 			string::LinearString string(std::vector<alphabet::Symbol>{a});
 			regexp::RegExp derived = deriv.derivation(r, string);
-			derived = regexp::RegExpOptimize::optimize(derived);
+			derived = regexp::simplify::RegExpOptimize::optimize(derived);
 			automaton.addTransition(stateMap.find(r)->second, a, stateMap.find(derived)->second);
 		}

alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp

@@ -35,7 +35,7 @@ template<class T>
 grammar::RightRG ToGrammarRightRGDerivation::convert(const T& regexp)
 {
 	// 1.
-	regexp::RegExp V = regexp::RegExp{regexp::RegExpOptimize::optimize(regexp)};
+	regexp::RegExp V = regexp::RegExp{regexp::simplify::RegExpOptimize::optimize(regexp)};
 	std::set<regexp::RegExp> N = { V };
 	std::deque<std::set<regexp::RegExp>> Ni;
@@ -58,7 +58,7 @@ grammar::RightRG ToGrammarRightRGDerivation::convert(const T& regexp)
 			{
 				string::LinearString string(std::vector<alphabet::Symbol>{a});
 				regexp::RegExp derived = deriv.derivation(dregexp, string);
-				derived = regexp::RegExpOptimize::optimize(derived);
+				derived = regexp::simplify::RegExpOptimize::optimize(derived);
 				// this will also add \emptyset as a regexp (and as FA state)
 				if(N.count(derived) == 0) // if this state has already been found, do not add
@@ -99,7 +99,7 @@ grammar::RightRG ToGrammarRightRGDerivation::convert(const T& regexp)
 		{
 			string::LinearString string(std::vector<alphabet::Symbol>{a});
 			regexp::RegExp derived = deriv.derivation(r, string);
-			derived = regexp::RegExpOptimize::optimize(derived);
+			derived = regexp::simplify::RegExpOptimize::optimize(derived);
 			grammar.addRule(nonterminalMap.find(r)->second, std::make_pair(a, nonterminalMap.find(derived)->second));

alib2algo/src/regexp/simplify/RegExpOptimize.cpp

@@ -15,6 +15,8 @@
 namespace regexp {
+namespace simplify {
+
 regexp::RegExp RegExpOptimize::optimize(const regexp::RegExp& regexp)
 {
     regexp::RegExp * out = NULL;
@@ -157,7 +159,9 @@ void RegExpOptimize::optimize( UnboundedRegExpElement & element ) {
 const RegExpOptimize RegExpOptimize::REG_EXP_OPTIMIZE;
+} /* namespace regexp */
+
+} /* namespace simplify */
+
 #include "RegExpOptimizeUnboundedPart.cxx"
 #include "RegExpOptimizeFormalPart.cxx"
-
-}