diff --git a/adeterminize2/src/adeterminize.cpp b/adeterminize2/src/adeterminize.cpp
index 5c3e2d2f2d9748530ad87bdfc0d60b68caf9efdd..8b37b6a25af7d0bdbad5c21abd0b6d46ca6f1bce 100644
--- a/adeterminize2/src/adeterminize.cpp
+++ b/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;
diff --git a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp b/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
index 7de147e0d1d2f0539a457929535d8a4095c1bdfd..88bdb12a9beb6e42701ec060efaa225a08757542 100644
--- a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
+++ b/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)
diff --git a/alib2algo/src/automaton/determinize/Determinize.cpp b/alib2algo/src/automaton/determinize/Determinize.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3a9357d29f87e0189d2164e713d9e176648edc8b
--- /dev/null
+++ b/alib2algo/src/automaton/determinize/Determinize.cpp
@@ -0,0 +1,101 @@
+/*
+ * 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"
+
diff --git a/alib2algo/src/automaton/determinize/nfa/NFADeterminizer.h b/alib2algo/src/automaton/determinize/Determinize.h
similarity index 73%
rename from alib2algo/src/automaton/determinize/nfa/NFADeterminizer.h
rename to alib2algo/src/automaton/determinize/Determinize.h
index 87f05f9b3725d594427c5dc3ee6edc1a6424aed7..2fc78ff1e37ac55c8529d0b28d9f485804398392 100644
--- a/alib2algo/src/automaton/determinize/nfa/NFADeterminizer.h
+++ b/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_ */
diff --git a/alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.cpp b/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
similarity index 87%
rename from alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.cpp
rename to alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
index 36cd28c3029c6efc3d8550ac853b3f62a01885f6..1f85414a8d3e65b9d2feb088eff4acb16689c277 100644
--- a/alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.cpp
+++ b/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 {
+namespace automaton {
 
+namespace determinize {
 
-automaton::DPDA IDPDADeterminizer::determinize(const automaton::InputDrivenNPDA& nfa) {
+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 */
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx
new file mode 100644
index 0000000000000000000000000000000000000000..e156c3c8f16f54055897c6fbb1618e0691e9e5d6
--- /dev/null
+++ b/alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx
@@ -0,0 +1,115 @@
+/*
+ * NFADeterminizer.cpp
+ *
+ *  Created on: 16. 1. 2014
+ *	  Author: Jan Vesely
+ */
+
+#include "common/NFACommon.h"
+
+#include <automaton/FSM/NFA.h>
+#include <automaton/FSM/MultiInitialStateNFA.h>
+#include <deque>
+#include <algorithm>
+
+namespace automaton {
+
+namespace determinize {
+
+automaton::DFA Determinize::determinize(const automaton::MultiInitialStateNFA& nfa) {
+	// 1, 4
+	automaton::State initialState(createDFAState(nfa.getInitialStates()));
+	automaton::DFA res(initialState);
+	res.setInputSymbols(nfa.getInputAlphabet());
+	
+	// 2
+	std::deque<automaton::State> todo;
+	todo.push_back(initialState);
+	
+	do {
+		// 3a, c
+		automaton::State state = todo.front();
+		todo.pop_front();
+
+		// 3b
+		for (const auto& input : nfa.getInputAlphabet()) {
+			std::set<automaton::State> targetNFAStates;
+			for(const auto& nfaState : recreateNFAStates(state)) {
+				auto iter = nfa.getTransitions().find(std::make_pair(nfaState, input));
+				if(iter != nfa.getTransitions().end()) {
+					targetNFAStates.insert(iter->second.begin(), iter->second.end());
+				}
+			}
+			automaton::State dfaState = createDFAState(targetNFAStates);
+
+			// 4
+			bool existed = !res.addState(dfaState);
+
+			// 3b
+			res.addTransition(state, input, dfaState);
+
+			if(!existed) todo.push_back(dfaState);
+		}
+	} while(!todo.empty());
+	
+	// 5
+	for (const auto& dfaState : res.getStates()) {
+		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
+		if(std::any_of(nfaStates.begin(), nfaStates.end(), [&](const automaton::State& nfaState) { return nfa.getFinalStates().count(nfaState); })) {
+			res.addFinalState(dfaState);
+		}
+	}
+	
+	return res;
+}
+
+automaton::DFA Determinize::determinize(const automaton::NFA& nfa) {
+	// 1, 4
+	automaton::State initialState(createDFAState({nfa.getInitialState()}));
+	automaton::DFA res(initialState);
+	res.setInputSymbols(nfa.getInputAlphabet());
+	
+	// 2
+	std::deque<automaton::State> todo;
+	todo.push_back(initialState);
+	
+	do {
+		// 3a, c
+		automaton::State state = todo.front();
+		todo.pop_front();
+
+		// 3b
+		for (const auto& input : nfa.getInputAlphabet()) {
+			std::set<automaton::State> targetNFAStates;
+			for(const auto& nfaState : recreateNFAStates(state)) {
+				auto iter = nfa.getTransitions().find(std::make_pair(nfaState, input));
+				if(iter != nfa.getTransitions().end()) {
+					targetNFAStates.insert(iter->second.begin(), iter->second.end());
+				}
+			}
+			automaton::State dfaState = createDFAState(targetNFAStates);
+
+			// 4
+			bool existed = !res.addState(dfaState);
+
+			// 3b
+			res.addTransition(state, input, dfaState);
+
+			if(!existed) todo.push_back(dfaState);
+		}
+	} while(!todo.empty());
+	
+	// 5
+	for (const auto& dfaState : res.getStates()) {
+		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
+		if(std::any_of(nfaStates.begin(), nfaStates.end(), [&](const automaton::State& nfaState) { return nfa.getFinalStates().count(nfaState); })) {
+			res.addFinalState(dfaState);
+		}
+	}
+	
+	return res;
+}
+
+} /* namespace determinize */
+
+} /* namespace automaton */
diff --git a/alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.cpp b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
similarity index 96%
rename from alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.cpp
rename to alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
index 9c01e6c99210bdf890807acd1edeeb33804aa5d3..321b6e544020df05bd4410ac69688ce5022e573b 100644
--- a/alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.cpp
+++ b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
@@ -1,6 +1,13 @@
-#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 */
diff --git a/alib2algo/src/automaton/determinize/vpa/VPADeterminizer.cpp b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
similarity index 95%
rename from alib2algo/src/automaton/determinize/vpa/VPADeterminizer.cpp
rename to alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
index 136cf49c2c8a96427fbc5dd6be3b9bde7a2ef656..1a1e7ebca54a3fa1db5e6d6063d2a6d1bedcf4fc 100644
--- a/alib2algo/src/automaton/determinize/vpa/VPADeterminizer.cpp
+++ b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
@@ -1,6 +1,13 @@
-#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 */
diff --git a/alib2algo/src/automaton/determinize/common/NFACommon.cpp b/alib2algo/src/automaton/determinize/common/NFACommon.cpp
index 7a99e583251737d89f36aae9e055611135f8c11b..f86c2eff6754a6ed1b2937b764853746135955a3 100644
--- a/alib2algo/src/automaton/determinize/common/NFACommon.cpp
+++ b/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 */
diff --git a/alib2algo/src/automaton/determinize/common/NFACommon.h b/alib2algo/src/automaton/determinize/common/NFACommon.h
index d68e98f97911e6900768468fe6a5d82445f786fd..2265efdf84cab10999f5441fdeba3781d5a471db 100644
--- a/alib2algo/src/automaton/determinize/common/NFACommon.h
+++ b/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_ */
diff --git a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp b/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
index d309b75f55b89f66a83bba54d682f11ae41f90c9..e8c29d07032e22f5e19aa6411c25b4ca85ed7e3b 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.cpp
+++ b/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 */
diff --git a/alib2algo/src/automaton/determinize/common/RHDPDACommon.h b/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
index 26fff9071ec8806e4ad8340cb4b3abbdfac6fb3e..787037bd81b438b6fb3f7557db9d8404b482c95e 100644
--- a/alib2algo/src/automaton/determinize/common/RHDPDACommon.h
+++ b/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_ */
diff --git a/alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.h b/alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.h
deleted file mode 100644
index 2d867dcdd04578899e268dbda81b5afe9013f7ca..0000000000000000000000000000000000000000
--- a/alib2algo/src/automaton/determinize/hdpda/HDPDADeterminizer.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#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_ */
diff --git a/alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.h b/alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.h
deleted file mode 100644
index 4009c23dd29245ccac294b86ce5a6f916f012789..0000000000000000000000000000000000000000
--- a/alib2algo/src/automaton/determinize/idpda/IDPDADeterminizer.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * 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_ */
diff --git a/alib2algo/src/automaton/determinize/nfa/NFADeterminizer.cpp b/alib2algo/src/automaton/determinize/nfa/NFADeterminizer.cpp
deleted file mode 100644
index 3e0925ea731914873154ec7e967d09c88a99f501..0000000000000000000000000000000000000000
--- a/alib2algo/src/automaton/determinize/nfa/NFADeterminizer.cpp
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * NFADeterminizer.cpp
- *
- *  Created on: 16. 1. 2014
- *	  Author: Jan Vesely
- */
-
-#include "NFADeterminizer.h"
-#include "../common/NFACommon.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) {
-	// 1, 4
-	automaton::State initialState(createDFAState(nfa.getInitialStates()));
-	automaton::DFA res(initialState);
-	res.setInputSymbols(nfa.getInputAlphabet());
-	
-	// 2
-	std::deque<automaton::State> todo;
-	todo.push_back(initialState);
-	
-	do {
-		// 3a, c
-		automaton::State state = todo.front();
-		todo.pop_front();
-
-		// 3b
-		for (const auto& input : nfa.getInputAlphabet()) {
-			std::set<automaton::State> targetNFAStates;
-			for(const auto& nfaState : recreateNFAStates(state)) {
-				auto iter = nfa.getTransitions().find(std::make_pair(nfaState, input));
-				if(iter != nfa.getTransitions().end()) {
-					targetNFAStates.insert(iter->second.begin(), iter->second.end());
-				}
-			}
-			automaton::State dfaState = createDFAState(targetNFAStates);
-
-			// 4
-			bool existed = !res.addState(dfaState);
-
-			// 3b
-			res.addTransition(state, input, dfaState);
-
-			if(!existed) todo.push_back(dfaState);
-		}
-	} while(!todo.empty());
-	
-	// 5
-	for (const auto& dfaState : res.getStates()) {
-		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
-		if(std::any_of(nfaStates.begin(), nfaStates.end(), [&](const automaton::State& nfaState) { return nfa.getFinalStates().count(nfaState); })) {
-			res.addFinalState(dfaState);
-		}
-	}
-	
-	return res;
-}
-
-automaton::DFA NFADeterminizer::determinize(const automaton::NFA& nfa) {
-	// 1, 4
-	automaton::State initialState(createDFAState({nfa.getInitialState()}));
-	automaton::DFA res(initialState);
-	res.setInputSymbols(nfa.getInputAlphabet());
-	
-	// 2
-	std::deque<automaton::State> todo;
-	todo.push_back(initialState);
-	
-	do {
-		// 3a, c
-		automaton::State state = todo.front();
-		todo.pop_front();
-
-		// 3b
-		for (const auto& input : nfa.getInputAlphabet()) {
-			std::set<automaton::State> targetNFAStates;
-			for(const auto& nfaState : recreateNFAStates(state)) {
-				auto iter = nfa.getTransitions().find(std::make_pair(nfaState, input));
-				if(iter != nfa.getTransitions().end()) {
-					targetNFAStates.insert(iter->second.begin(), iter->second.end());
-				}
-			}
-			automaton::State dfaState = createDFAState(targetNFAStates);
-
-			// 4
-			bool existed = !res.addState(dfaState);
-
-			// 3b
-			res.addTransition(state, input, dfaState);
-
-			if(!existed) todo.push_back(dfaState);
-		}
-	} while(!todo.empty());
-	
-	// 5
-	for (const auto& dfaState : res.getStates()) {
-		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
-		if(std::any_of(nfaStates.begin(), nfaStates.end(), [&](const automaton::State& nfaState) { return nfa.getFinalStates().count(nfaState); })) {
-			res.addFinalState(dfaState);
-		}
-	}
-	
-	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;
-
-}
diff --git a/alib2algo/src/automaton/determinize/vpa/VPADeterminizer.h b/alib2algo/src/automaton/determinize/vpa/VPADeterminizer.h
deleted file mode 100644
index 129a90f2a3bda42bb9b35007fc8cbd4234286d04..0000000000000000000000000000000000000000
--- a/alib2algo/src/automaton/determinize/vpa/VPADeterminizer.h
+++ /dev/null
@@ -1,25 +0,0 @@
-#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_ */
diff --git a/alib2algo/src/equations/LeftRegularEquationSolver.cpp b/alib2algo/src/equations/LeftRegularEquationSolver.cpp
index d20bdda1be7e0ee6820e8aa3e5fc327987620662..59f2d51ab21432ce778de40714c1df5eb92c62d2 100644
--- a/alib2algo/src/equations/LeftRegularEquationSolver.cpp
+++ b/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 */
diff --git a/alib2algo/src/equations/RightRegularEquationSolver.cpp b/alib2algo/src/equations/RightRegularEquationSolver.cpp
index 0d0056475de97468e912692e77bd9f4c24b6f987..8403237f907543ea2699ae540206529335fcbf3e 100644
--- a/alib2algo/src/equations/RightRegularEquationSolver.cpp
+++ b/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 */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index 388f7a98d1921db13fcb8a85c77a9e49ca7307e7..b6fe2135bd87a144d4b0bad8c806c7ce8382111c 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
+++ b/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);
 		}
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index 666183c10f3d736836cf0e51adf18305ff687fd2..1268ed6f7e6f4d39774c2999b545dc7ec6bf537a 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
+++ b/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));
 
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimize.cpp b/alib2algo/src/regexp/simplify/RegExpOptimize.cpp
index 0172ef6beeeedf2afee7a4239d771e0093460404..e3c630f1a4863b676e1ce32f9d2235e4939ae32a 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimize.cpp
+++ b/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"
-
-}
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimize.h b/alib2algo/src/regexp/simplify/RegExpOptimize.h
index 1cd12f7a686a47d3719e46feffaad8c78d8b00b6..f0d7ba78c0fb52a2045b8ac01daa2f1f07b95c5d 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimize.h
+++ b/alib2algo/src/regexp/simplify/RegExpOptimize.h
@@ -24,6 +24,8 @@
 
 namespace regexp {
 
+namespace simplify {
+
 /*
  * Optimizes RegExp (or its subtree) using axioms defined in Melichar 2.87
  * (A1 to A10) and Melichar 2.95(V1 through V6 and V8, V9, V10)
@@ -134,6 +136,8 @@ private:
     static const RegExpOptimize REG_EXP_OPTIMIZE;
 };
 
-}
+} /* namespace simplify */
+
+} /* namespace regexp */
 
 #endif /* REGEXPNORMALIZE_H_ */
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.cxx b/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.cxx
index 8a6793f16eb4c2ed513811918ff5bcb935edd104..d2ac3dd6313390a3e61cefdff287af821574d653 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.cxx
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeFormalPart.cxx
@@ -1,3 +1,14 @@
+/*
+ * RegExpOptimize.cpp
+ *
+ *  Created on: 20. 1. 2014
+ *	  Author: Jan Travnicek
+ */
+
+namespace regexp {
+
+namespace simplify {
+
 FormalRegExpElement* RegExpOptimize::optimize( FormalRegExpElement const * const & node ) const
 {
 	FormalRegExpElement* elem = node->clone();
@@ -567,4 +578,9 @@ bool RegExpOptimize::X1( FormalRegExpElement * & n ) const
 	}
 
 	return false;
+
 }
+
+} /* namespace simplify */
+
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
index 053e0c5c8ca883e05bf61ab0647f3f18d40be569..9d3faf3058028244f8f590e68ee93c2d9fe712b7 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
@@ -1,3 +1,14 @@
+/*
+ * RegExpOptimize.cpp
+ *
+ *  Created on: 20. 1. 2014
+ *	  Author: Tomas Pecka
+ */
+
+namespace regexp {
+
+namespace simplify {
+
 UnboundedRegExpElement* RegExpOptimize::optimize( UnboundedRegExpElement const * const & node ) const
 {
 	const UnboundedRegExpAlternation * alternation = dynamic_cast<const UnboundedRegExpAlternation*>( node );
@@ -1160,3 +1171,7 @@ bool RegExpOptimize::X1( UnboundedRegExpAlternation * const & node ) const
 
 	return false;
 }
+
+} /* namespace simplify */
+
+} /* namespace regexp */
diff --git a/alib2algo/test-src/automaton/determinize/determinizeTest.cpp b/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
index a063671c991e272d32563075057c6f112c82ef3b..f2408f344d5c7d37098c5298661be4d6ca3f7b7b 100644
--- a/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
+++ b/alib2algo/test-src/automaton/determinize/determinizeTest.cpp
@@ -1,8 +1,7 @@
 #include <list>
 #include "determinizeTest.h"
 
-#include "automaton/determinize/nfa/NFADeterminizer.h"
-#include "automaton/determinize/idpda/IDPDADeterminizer.h"
+#include "automaton/determinize/Determinize.h"
 
 #include "factory/DataFactory.hpp"
 
@@ -30,7 +29,7 @@ void determinizeTest::testDeterminizeNFA() {
 
   automaton.addFinalState(automaton::State(3));
 
-  automaton::DFA determinized = determinize::NFADeterminizer::determinize(automaton);
+  automaton::DFA determinized = automaton::determinize::Determinize::determinize(automaton);
 
   CPPUNIT_ASSERT(determinized.getStates().size() == 3);
 
@@ -54,7 +53,7 @@ void determinizeTest::testDeterminizeIDPDA() {
   automaton.addInitialState(automaton::State(1));
   automaton.addFinalState(automaton::State(3));
 
-  automaton::DPDA determinized = determinize::IDPDADeterminizer::determinize(automaton);
+  automaton::DPDA determinized = automaton::determinize::Determinize::determinize(automaton);
 
   CPPUNIT_ASSERT(determinized.getStates().size() == 3);
 }
diff --git a/alib2algo/test-src/automaton/simplify/FSMSingleInitialStateTest.cpp b/alib2algo/test-src/automaton/simplify/FSMSingleInitialStateTest.cpp
index e6aacc111501d55f0bc046dbeb5b1abfd5979795..4a7ce40ba2436070e58dd19219c0bf2bd3e6a1a7 100644
--- a/alib2algo/test-src/automaton/simplify/FSMSingleInitialStateTest.cpp
+++ b/alib2algo/test-src/automaton/simplify/FSMSingleInitialStateTest.cpp
@@ -1,9 +1,11 @@
 #include "FSMSingleInitialStateTest.h"
 
 #include "automaton/simplify/SingleInitialState.h"
-#include "automaton/determinize/nfa/NFADeterminizer.h"
+#include "automaton/determinize/Determinize.h"
 #include "automaton/simplify/Normalize.h"
 
+#include "automaton/FSM/MultiInitialStateNFA.h"
+
 #define CPPUNIT_IMPLY(x, y) CPPUNIT_ASSERT(!(x) || (y))
 
 CPPUNIT_TEST_SUITE_REGISTRATION( FSMSingleInitialStateTest );
@@ -45,8 +47,8 @@ void FSMSingleInitialStateTest::testSingleInitialState() {
 	automaton3.addTransition(q1, b, q2);
 	automaton3.addTransition(q2, a, q3);
 
-	automaton::DFA dfa2 = determinize::NFADeterminizer::determinize(automaton2);
-	automaton::DFA dfa3 = determinize::NFADeterminizer::determinize(automaton3);
+	automaton::DFA dfa2 = automaton::determinize::Determinize::determinize(automaton2);
+	automaton::DFA dfa3 = automaton::determinize::Determinize::determinize(automaton3);
 
 	CPPUNIT_ASSERT(automaton::simplify::Normalize::normalize(dfa3) == automaton::simplify::Normalize::normalize(dfa3));
 }
diff --git a/alib2algo/test-src/playTest.cpp b/alib2algo/test-src/playTest.cpp
index 6396095747e032b793f278383886db90e8a5793b..82c3c242baab48d1d7af6a09cd14b94ac0e26b27 100644
--- a/alib2algo/test-src/playTest.cpp
+++ b/alib2algo/test-src/playTest.cpp
@@ -4,7 +4,7 @@
 #include <cstdlib>
 #include <ctime>
 
-#include "automaton/determinize/nfa/NFADeterminizer.h"
+#include "automaton/determinize/Determinize.h"
 #include "automaton/generate/RandomAutomatonFactory.h"
 #include "automaton/simplify/Minimize.h"
 #include "automaton/simplify/Normalize.h"
@@ -40,7 +40,7 @@ automaton::DFA playTest::mDFA(const automaton::NFA& automaton) const
 {
     automaton::NFA nfa = automaton::simplify::EpsilonRemover::remove(automaton);
     nfa = automaton::simplify::Trim::trim(nfa);
-    automaton::DFA dfa = determinize::NFADeterminizer::determinize(nfa);
+    automaton::DFA dfa = automaton::determinize::Determinize::determinize(nfa);
     dfa = automaton::simplify::Trim::trim(dfa);
     dfa = automaton::simplify::Minimize::minimize(dfa);
     dfa = automaton::simplify::Normalize::normalize(dfa);
diff --git a/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp b/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
index fa8460581808e6ff2764bc69a5fcb362edddb4f9..41c7be67a9006ea009c44b3576c81664d859832c 100644
--- a/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
+++ b/alib2algo/test-src/regexp/simplify/RegExpOptimizeTest.cpp
@@ -25,8 +25,7 @@ void RegExpOptimizeTest::testOptimize() {
 		regexp::RegExpFromStringParser parser(inputs);
 		regexp::UnboundedRegExp regexp( static_cast<const regexp::UnboundedRegExp &>( parser.parseValue().getData() ) );
 
-		regexp::RegExpOptimize opt;
-		regexp::UnboundedRegExp res = opt.optimize(regexp);
+		regexp::UnboundedRegExp res = regexp::simplify::RegExpOptimize::optimize(regexp);
 	}
 	{
 		std::string input = "a+a* (b+a)* c";
diff --git a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
index 8be6ccb6e2129abe6506e73d73f056e55fe63c2f..d02597094105a569b0e960ce5d3ef3e6d190fa89 100644
--- a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
+++ b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
@@ -5,7 +5,7 @@
 #include "regexp/convert/ToAutomatonGlushkov.h"
 #include "regexp/convert/ToAutomatonThompson.h"
 #include "automaton/convert/ToRegExpAlgebraic.h"
-#include "automaton/determinize/nfa/NFADeterminizer.h"
+#include "automaton/determinize/Determinize.h"
 #include "automaton/simplify/Minimize.h"
 #include "automaton/simplify/Normalize.h"
 #include "automaton/simplify/EpsilonRemover.h"
@@ -40,8 +40,8 @@ void re2faTest::testThompson() {
 	automaton::Automaton nfa1 = automaton::simplify::EpsilonRemover::remove(enfa1);
 	automaton::Automaton nfa2 = automaton::simplify::EpsilonRemover::remove(enfa2);
 
-	automaton::Automaton dfa1 = determinize::NFADeterminizer::determinize(nfa1);
-	automaton::Automaton dfa2 = determinize::NFADeterminizer::determinize(nfa2);
+	automaton::Automaton dfa1 = automaton::determinize::Determinize::determinize(nfa1);
+	automaton::Automaton dfa2 = automaton::determinize::Determinize::determinize(nfa2);
 
 	automaton::Automaton mdfa1 = automaton::simplify::Minimize::minimize(dfa1);
 	automaton::Automaton mdfa2 = automaton::simplify::Minimize::minimize(dfa2);
@@ -62,8 +62,8 @@ void re2faTest::testGlushkov() {
 
 	automaton::NFA nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
 
-	automaton::DFA dfa1 = determinize::NFADeterminizer::determinize(nfa1);
-	automaton::DFA dfa2 = determinize::NFADeterminizer::determinize(nfa2);
+	automaton::DFA dfa1 = automaton::determinize::Determinize::determinize(nfa1);
+	automaton::DFA dfa2 = automaton::determinize::Determinize::determinize(nfa2);
 
 	automaton::DFA mdfa1 = automaton::simplify::Minimize::minimize(dfa1);
 	automaton::DFA mdfa2 = automaton::simplify::Minimize::minimize(dfa2);
@@ -84,11 +84,11 @@ void re2faTest::testBrzozowski() {
 
 	automaton::Automaton nfa2 = regexp::convert::ToAutomatonDerivation::convert(regexp2);
 
-	automaton::DFA mdfa1_1 = determinize::NFADeterminizer::determinize(static_cast<const automaton::NFA&>(nfa1.getData()));
+	automaton::DFA mdfa1_1 = automaton::determinize::Determinize::determinize(static_cast<const automaton::NFA&>(nfa1.getData()));
 	automaton::DFA mdfa1_2 = automaton::simplify::Minimize::minimize(mdfa1_1);
 	automaton::DFA mdfa1_3 = automaton::simplify::Normalize::normalize(mdfa1_2);
 
-	automaton::DFA mdfa2_1 = determinize::NFADeterminizer::determinize(static_cast<const automaton::NFA&>(nfa2.getData()));
+	automaton::DFA mdfa2_1 = automaton::determinize::Determinize::determinize(static_cast<const automaton::NFA&>(nfa2.getData()));
 	automaton::DFA mdfa2_2 = automaton::simplify::Minimize::minimize(mdfa2_1);
 	automaton::DFA mdfa2_3 = automaton::simplify::Normalize::normalize(mdfa2_2);
 
diff --git a/alib2data/src/regexp/formal/FormalRegExpAlternation.h b/alib2data/src/regexp/formal/FormalRegExpAlternation.h
index cb53ab3f2428175058505e687839b569e31bc2a2..0ff6327c5b07830da28a2b96e53d4eb5ee8f3bd7 100644
--- a/alib2data/src/regexp/formal/FormalRegExpAlternation.h
+++ b/alib2data/src/regexp/formal/FormalRegExpAlternation.h
@@ -13,6 +13,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
+class RegExpOptimize;
+
+} /* namespace simplify */
+
 /**
  * Represents alternation operator in the regular expression. Contains list of FormalRegExpElement
  * as operands of the operator.
@@ -98,7 +104,7 @@ public:
 	 */
 	virtual void operator>>(std::ostream& out) const;
 
-	friend class RegExpOptimize;
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/alib2data/src/regexp/formal/FormalRegExpConcatenation.h b/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
index 1f539385db24877572a4c93f22fd7c20cc3a0ebd..b88af6b5898241739b62c8517685c9770fa80147 100644
--- a/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
+++ b/alib2data/src/regexp/formal/FormalRegExpConcatenation.h
@@ -14,6 +14,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
+class RegExpOptimize;
+
+} /* namespace simplify */
+
 /**
  * Represents concatenation operator in the regular expression. Contains list of FormalRegExpElement
  * as operands of the operator.
@@ -96,7 +102,7 @@ public:
 	 */
 	virtual void operator>>(std::ostream& out) const;
 
-	friend class RegExpOptimize;
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/alib2data/src/regexp/formal/FormalRegExpIteration.h b/alib2data/src/regexp/formal/FormalRegExpIteration.h
index aa35c9b21c2ca029ad37d1c023825fd894c7367c..9d0629cd7679d693a3e3811dad0541705c8c4ac6 100644
--- a/alib2data/src/regexp/formal/FormalRegExpIteration.h
+++ b/alib2data/src/regexp/formal/FormalRegExpIteration.h
@@ -13,6 +13,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
+class RegExpOptimize;
+
+} /* namespace simplify */
+
 /**
  * Represents iteration operator in the regular expression. Contains one FormalRegExpElement
  * as operand.
@@ -91,7 +97,7 @@ public:
 	 */
 	virtual void operator>>(std::ostream& out) const;
 
-	friend class RegExpOptimize;
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
index 18b9dec3a776af697f014f46a41278c99ba06b39..ab78cbfdac74d2f6e2a7b8b4b349a22337c05ea1 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpAlternation.h
@@ -13,8 +13,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
 class RegExpOptimize;
 
+} /* namespace simplify */
+
 /**
  * Represents alternation operator in the regular expression. Contains list of UnboundedRegExpElement
  * as operands of the operator.
@@ -94,7 +98,7 @@ public:
 	 */
 	virtual void operator>>(std::ostream& out) const;
 
-	friend class RegExpOptimize;
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
index feb155a2eb9cbfdb123dc38b3e371552da260bea..04314dfad668306318fc7fbc8d5b2cc7452a1469 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpConcatenation.h
@@ -13,8 +13,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
 class RegExpOptimize;
 
+} /* namespace simplify */
+
 /**
  * Represents concatenation operator in the regular expression. Contains list of UnboundedRegExpElement
  * as operands of the operator.
@@ -92,8 +96,8 @@ public:
 	 * @copydoc UnboundedRegExpElement::operator>>() const
 	 */
 	virtual void operator>>(std::ostream& out) const;
-	
-	friend class RegExpOptimize;
+
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h b/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
index 55b53447b360e77d5e0debe9a0977ad8faee3547..26901d9629db18efcb720fa1a0a1f0c73886ddd5 100644
--- a/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
+++ b/alib2data/src/regexp/unbounded/UnboundedRegExpIteration.h
@@ -13,8 +13,12 @@
 
 namespace regexp {
 
+namespace simplify {
+
 class RegExpOptimize;
 
+} /* namespace simplify */
+
 /**
  * Represents iteration operator in the regular expression. Contains one UnboundedRegExpElement
  * as operand.
@@ -92,7 +96,7 @@ public:
 	 */
 	virtual void operator>>(std::ostream& out) const;
 
-	friend class RegExpOptimize;
+	friend class simplify::RegExpOptimize;
 
 	virtual operator std::string() const;
 
diff --git a/atrim2/src/atrim.cpp b/atrim2/src/atrim.cpp
index ef96bd61530178b7ae35712fa3d54943b6f35ab1..5c4c11f8a360c8a955476ccbc77c6b03446b965f 100644
--- a/atrim2/src/atrim.cpp
+++ b/atrim2/src/atrim.cpp
@@ -46,7 +46,7 @@ automaton::Automaton trimAutomaton(const automaton::Automaton& g, bool del_unrea
 }
 
 regexp::RegExp optimizeRegExp(const regexp::RegExp& r) {
-	return regexp::RegExpOptimize::optimize( r );
+	return regexp::simplify::RegExpOptimize::optimize( r );
 }
 
 int main(int argc, char* argv[]) {