make automaton determinize use set

alib2algo/src/automaton/determinize/Determinize.cpp

@@ -87,11 +87,15 @@ DFTA < > Determinize::determinize(const automaton::DFTA < > & automaton) {
 auto DeterminizeDFTA = Determinize::RegistratorWrapper<automaton::DFTA < >, automaton::DFTA < > >(Determinize::determinize);
+
+
+auto DeterminizeMultiInitialStateNFA = Determinize::RegistratorWrapper < automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::MultiInitialStateNFA < > > ( Determinize::determinize );
+auto DeterminizeNFA = Determinize::RegistratorWrapper < automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::NFA < > > ( Determinize::determinize );
+
 } /* namespace determinize */
 } /* namespace automaton */
-#include "DeterminizeNFAPart.cxx"
 #include "DeterminizeIDPDAPart.cxx"
 #include "DeterminizeVPAPart.cxx"
 #include "DeterminizeRHDPDAPart.cxx"

alib2algo/src/automaton/determinize/Determinize.h

@@ -32,8 +32,13 @@ public:
 	static automaton::Automaton determinize(const automaton::Automaton& nfa);
 	static automaton::DFA<> determinize(const automaton::DFA<>& nfa);
-	static automaton::DFA<> determinize(const automaton::NFA < > & nfa);
-	static automaton::DFA<> determinize(const automaton::MultiInitialStateNFA < > & nfa);
+
+	template < class SymbolType, class StateType >
+	static automaton::DFA < SymbolType, std::set < StateType > > determinize(const automaton::NFA < SymbolType, StateType > & nfa);
+
+	template < class SymbolType, class StateType >
+	static automaton::DFA < SymbolType, std::set < StateType > > determinize(const automaton::MultiInitialStateNFA < SymbolType, StateType > & nfa);
+
 	static automaton::DPDA < > determinize(const automaton::DPDA < > & dpda);
 	static automaton::DPDA < > determinize(const automaton::NPDA < > & dpda);
 	static automaton::SinglePopDPDA < > determinize(const automaton::SinglePopDPDA < > & dpda);
@@ -53,4 +58,6 @@ public:
 } /* namespace automaton */
+#include "DeterminizeNFAPart.hxx"
+
 #endif /* DETERMINIZE_H_ */

alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx → alib2algo/src/automaton/determinize/DeterminizeNFAPart.hxx

@@ -12,39 +12,40 @@
 #include <deque>
 #include <algorithm>
+#include <container/ObjectsSet.h>
+
 namespace automaton {
 namespace determinize {
-automaton::DFA<> Determinize::determinize ( const automaton::MultiInitialStateNFA < > & nfa ) {
+template < class SymbolType, class StateType >
+automaton::DFA < SymbolType, std::set < StateType > > Determinize::determinize ( const automaton::MultiInitialStateNFA < SymbolType, StateType > & nfa ) {
 	 // 1, 4
-	DefaultStateType initialState ( createDFAState ( nfa.getInitialStates ( ) ) );
-	automaton::DFA < > res ( initialState );
+	std::set < StateType > initialState = nfa.getInitialStates ( );
+	automaton::DFA < SymbolType, std::set < StateType > > res ( initialState );
 	res.setInputAlphabet ( nfa.getInputAlphabet ( ) );
 	 // 2
-	std::deque < DefaultStateType > todo;
+	std::deque < std::set < StateType > > todo;
 	todo.push_back ( std::move ( initialState ) );
 	do {
 		 // 3a, c
-		DefaultStateType state = std::move ( todo.front ( ) );
+		std::set < StateType > state = std::move ( todo.front ( ) );
 		todo.pop_front ( );
 		 // 3b
-		for ( const DefaultSymbolType & input : nfa.getInputAlphabet ( ) ) {
-			std::set < DefaultStateType > targetNFAStates;
-			for ( DefaultStateType nfaState : recreateNFAStates ( state ) ) {
+		for ( const SymbolType & input : nfa.getInputAlphabet ( ) ) {
+			std::set < StateType > dfaState;
+			for ( StateType nfaState : state ) {
 				auto iter = nfa.getTransitions ( ).find ( std::make_pair ( std::move ( nfaState ), input ) );
 				if ( iter != nfa.getTransitions ( ).end ( ) )
-					targetNFAStates.insert ( iter->second.begin ( ), iter->second.end ( ) );
+					dfaState.insert ( iter->second.begin ( ), iter->second.end ( ) );
 			}
-			DefaultStateType dfaState = createDFAState ( std::move ( targetNFAStates ) );
-
 			 // 4
 			bool existed = !res.addState ( dfaState );
@@ -56,48 +57,43 @@ automaton::DFA<> Determinize::determinize ( const automaton::MultiInitialStateNF
 	} while ( !todo.empty ( ) );
 	 // 5
-	const std::set<DefaultStateType>& finalLabels = nfa.getFinalStates();
-	for ( const DefaultStateType & dfaState : res.getStates ( ) ) {
-		const std::set < DefaultStateType > & nfaStates = recreateNFAStates ( dfaState );
-
-		if(!std::excludes(finalLabels.begin(), finalLabels.end(), nfaStates.begin(), nfaStates.end()))
+	const std::set < StateType > & finalLabels = nfa.getFinalStates();
+	for ( const std::set < StateType > & dfaState : res.getStates ( ) )
+		if ( ! std::excludes ( finalLabels.begin ( ), finalLabels.end ( ), dfaState.begin ( ), dfaState.end ( ) ) )
 			res.addFinalState ( dfaState );
-	}
 	return res;
 }
-auto DeterminizeMultiInitialStateNFA = Determinize::RegistratorWrapper < automaton::DFA<>, automaton::MultiInitialStateNFA < > > ( Determinize::determinize );
-
-automaton::DFA<> Determinize::determinize ( const automaton::NFA < > & nfa ) {
+template < class SymbolType, class StateType >
+automaton::DFA < SymbolType, std::set < StateType > > Determinize::determinize ( const automaton::NFA < SymbolType, StateType > & nfa ) {
 	 // 1, 4
-	DefaultStateType initialState ( createDFAState ( { nfa.getInitialState ( ) } ) );
-	automaton::DFA < > res ( initialState );
+	std::set < StateType > initialState;
+	initialState.insert ( nfa.getInitialState ( ) );
+	automaton::DFA < SymbolType, std::set < StateType > > res ( initialState );
 	res.setInputAlphabet ( nfa.getInputAlphabet ( ) );
 	 // 2
-	std::deque < DefaultStateType > todo;
+	std::deque < std::set < StateType > > todo;
 	todo.push_back ( std::move ( initialState ) );
 	do {
 		 // 3a, c
-		DefaultStateType state = std::move ( todo.front ( ) );
+		std::set < StateType > state = std::move ( todo.front ( ) );
 		todo.pop_front ( );
 		 // 3b
-		for ( const DefaultSymbolType & input : nfa.getInputAlphabet ( ) ) {
-			std::set < DefaultStateType > targetNFAStates;
-			for ( DefaultStateType nfaState : recreateNFAStates ( state ) ) {
+		for ( const SymbolType & input : nfa.getInputAlphabet ( ) ) {
+			std::set < StateType > dfaState;
+			for ( StateType nfaState : state ) {
 				auto iter = nfa.getTransitions ( ).find ( std::make_pair ( std::move ( nfaState ), input ) );
 				if ( iter != nfa.getTransitions ( ).end ( ) )
-					targetNFAStates.insert ( iter->second.begin ( ), iter->second.end ( ) );
+					dfaState.insert ( iter->second.begin ( ), iter->second.end ( ) );
 			}
-			DefaultStateType dfaState = createDFAState ( std::move ( targetNFAStates ) );
-
 			 // 4
 			bool existed = !res.addState ( dfaState );
@@ -109,19 +105,14 @@ automaton::DFA<> Determinize::determinize ( const automaton::NFA < > & nfa ) {
 	} while ( !todo.empty ( ) );
 	 // 5
-	const std::set<DefaultStateType>& finalLabels = nfa.getFinalStates();
-	for ( const DefaultStateType & dfaState : res.getStates ( ) ) {
-		const std::set < DefaultStateType > & nfaStates = recreateNFAStates ( dfaState );
-
-		if(!std::excludes(finalLabels.begin(), finalLabels.end(), nfaStates.begin(), nfaStates.end()))
+	const std::set < StateType > & finalLabels = nfa.getFinalStates();
+	for ( const std::set < StateType > & dfaState : res.getStates ( ) )
+		if ( ! std::excludes ( finalLabels.begin ( ), finalLabels.end ( ), dfaState.begin ( ), dfaState.end ( ) ) )
 			res.addFinalState ( dfaState );
-	}
 	return res;
 }
-auto DeterminizeNFA = Determinize::RegistratorWrapper < automaton::DFA<>, automaton::NFA < > > ( Determinize::determinize );
-
 } /* namespace determinize */
 } /* namespace automaton */

alib2algo/src/automaton/simplify/MinimizeBrzozowski.cpp

@@ -17,8 +17,8 @@ automaton::Automaton MinimizeBrzozowski::minimize(const automaton::Automaton& au
 	return res;
 }
-auto MinimizeBrzozowskiDFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < >, automaton::DFA < > >(MinimizeBrzozowski::minimize);
-auto MinimizeBrzozowskiNFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < >, automaton::NFA < > >(MinimizeBrzozowski::minimize);
+auto MinimizeBrzozowskiDFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::DFA < > >(MinimizeBrzozowski::minimize);
+auto MinimizeBrzozowskiNFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::NFA < > >(MinimizeBrzozowski::minimize);
 } /* namespace simplify */

alib2algo/src/automaton/simplify/MinimizeBrzozowski.h

@@ -29,18 +29,18 @@ public:
 	static automaton::Automaton minimize(const automaton::Automaton& dfa);
 	template < class SymbolType, class StateType >
-	static automaton::DFA < SymbolType, StateType > minimize(const automaton::DFA < SymbolType, StateType > & dfa);
+	static automaton::DFA < SymbolType, std::set < std::set < StateType > > > minimize(const automaton::DFA < SymbolType, StateType > & dfa);
 	template < class SymbolType, class StateType >
-	static automaton::DFA < SymbolType, StateType > minimize(const automaton::NFA < SymbolType, StateType > & nfa);
+	static automaton::DFA < SymbolType, std::set < std::set < StateType > > > minimize(const automaton::NFA < SymbolType, StateType > & nfa);
 };
 template < class SymbolType, class StateType >
-automaton::DFA < SymbolType, StateType > MinimizeBrzozowski::minimize(const automaton::DFA < SymbolType, StateType > & dfa) {
+automaton::DFA < SymbolType, std::set < std::set < StateType > > > MinimizeBrzozowski::minimize(const automaton::DFA < SymbolType, StateType > & dfa) {
 	return automaton::determinize::Determinize::determinize(automaton::transform::Reverse::convert(automaton::determinize::Determinize::determinize(automaton::transform::Reverse::convert(dfa))));
 }
 template < class SymbolType, class StateType >
-automaton::DFA < SymbolType, StateType > MinimizeBrzozowski::minimize(const automaton::NFA < SymbolType, StateType > & nfa) {
+automaton::DFA < SymbolType, std::set < std::set < StateType > > > MinimizeBrzozowski::minimize(const automaton::NFA < SymbolType, StateType > & nfa) {
 	return automaton::determinize::Determinize::determinize(automaton::transform::Reverse::convert(automaton::determinize::Determinize::determinize(automaton::transform::Reverse::convert(nfa))));
 }

alib2algo/src/stringology/exact/ExactFactorAutomaton.h

@@ -13,6 +13,7 @@
 #include <string/LinearString.h>
 #include <string/String.h>
 #include <core/multipleDispatch.hpp>
+#include <primitive/Unsigned.h>
 namespace stringology {

alib2algo/test-src/automaton/determinize/determinizeTest.cpp

@@ -33,7 +33,7 @@ void determinizeTest::testDeterminizeNFA() {
   automaton.addFinalState(DefaultStateType(3));
-  automaton::DFA<> determinized = automaton::determinize::Determinize::determinize(automaton);
+  automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > determinized = automaton::determinize::Determinize::determinize(automaton);
   CPPUNIT_ASSERT(determinized.getStates().size() == 3);

alib2algo/test-src/automaton/simplify/FSMSingleInitialStateTest.cpp

@@ -47,8 +47,8 @@ void FSMSingleInitialStateTest::testSingleInitialState() {
 	automaton3.addTransition(q1, b, q2);
 	automaton3.addTransition(q2, a, q3);
-	automaton::DFA<> dfa2 = automaton::simplify::Minimize::minimize(automaton::determinize::Determinize::determinize(automaton2));
-	automaton::DFA<> dfa3 = automaton::simplify::Minimize::minimize(automaton::determinize::Determinize::determinize(automaton3));
+	automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > dfa2 = automaton::simplify::Minimize::minimize(automaton::determinize::Determinize::determinize(automaton2));
+	automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > dfa3 = automaton::simplify::Minimize::minimize(automaton::determinize::Determinize::determinize(automaton3));
 	CPPUNIT_ASSERT(automaton::simplify::Normalize::normalize(dfa2) == automaton::simplify::Normalize::normalize(dfa3));
 }

alib2algo/test-src/automaton/simplify/minimizeBrzozowskiTest.cpp

@@ -29,8 +29,8 @@ void minimizeBrzozowskiTest::testMinimizeBrzozowski() {
   automaton.addFinalState(DefaultStateType(3));
   
-  automaton::DFA<> minimizedHopcroft = automaton::simplify::Minimize::minimize(automaton);
-  automaton::DFA<> minimizedBrzozowski = automaton::simplify::MinimizeBrzozowski::minimize(automaton);
+  automaton::DFA < > minimizedHopcroft = automaton::simplify::Minimize::minimize(automaton);
+  automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > > minimizedBrzozowski = automaton::simplify::MinimizeBrzozowski::minimize(automaton);
   CPPUNIT_ASSERT(minimizedHopcroft.getStates().size() == 3);
   CPPUNIT_ASSERT(automaton::simplify::Normalize::normalize(automaton::simplify::Trim::trim(minimizedHopcroft)) == automaton::simplify::Normalize::normalize(automaton::simplify::Trim::trim(minimizedBrzozowski)));

alib2algo/test-src/playTest.cpp

@@ -39,7 +39,7 @@ automaton::DFA < DefaultSymbolType, unsigned > playTest::mDFA(const automaton::N
 {
     automaton::NFA < >  nfa = automaton::simplify::EpsilonRemoverIncoming::remove(automaton);
     nfa = automaton::simplify::Trim::trim(nfa);
-    automaton::DFA<> dfa = automaton::determinize::Determinize::determinize(nfa);
+    automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > dfa = automaton::determinize::Determinize::determinize(nfa);
     dfa = automaton::simplify::Trim::trim(dfa);
     dfa = automaton::simplify::Minimize::minimize(dfa);
     automaton::DFA < DefaultSymbolType, unsigned > dfa2 = automaton::simplify::Normalize::normalize(dfa);

alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp

@@ -59,8 +59,8 @@ void re2faTest::testGlushkov() {
 	automaton::NFA < > nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
-	automaton::DFA<> dfa1 = automaton::determinize::Determinize::determinize(nfa1);
-	automaton::DFA<> dfa2 = automaton::determinize::Determinize::determinize(nfa2);
+	automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > dfa1 = automaton::determinize::Determinize::determinize(nfa1);
+	automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > dfa2 = automaton::determinize::Determinize::determinize(nfa2);
 	automaton::DFA< DefaultSymbolType, unsigned > mdfa1 = automaton::simplify::Normalize::normalize(automaton::simplify::Minimize::minimize(dfa1));
 	automaton::DFA< DefaultSymbolType, unsigned > mdfa2 = automaton::simplify::Normalize::normalize(automaton::simplify::Minimize::minimize(dfa2));

alib2algo_experimental/src/stringology/exact/SuffixAutomaton.cpp

@@ -17,7 +17,7 @@ automaton::Automaton SuffixAutomaton::naiveConstruct ( const string::String & pa
     return dispatch ( pattern.getData ( ) );
 }
-automaton::DFA<> SuffixAutomaton::naiveConstruct ( const string::LinearString < > & pattern ) {
+automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > SuffixAutomaton::naiveConstruct ( const string::LinearString < > & pattern ) {
     automaton::EpsilonNFA < > nfaSuffixAutomaton ( DefaultStateType ( 0 ) );
     nfaSuffixAutomaton.setInputAlphabet ( pattern.getAlphabet ( ) );
@@ -33,17 +33,17 @@ automaton::DFA<> SuffixAutomaton::naiveConstruct ( const string::LinearString <
     nfaSuffixAutomaton.addFinalState ( DefaultStateType ( i ) );
-    automaton::DFA<> minimalSuffixAutomaton = automaton::simplify::Minimize::minimize ( automaton::determinize::Determinize::determinize ( automaton::simplify::EpsilonRemoverIncoming::remove ( nfaSuffixAutomaton ) ) );
+    automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > minimalSuffixAutomaton = automaton::simplify::Minimize::minimize ( automaton::determinize::Determinize::determinize ( automaton::simplify::EpsilonRemoverIncoming::remove ( nfaSuffixAutomaton ) ) );
     // FIXME Trim? and is this even supposed to be here?
-    DefaultStateType failState = label::FailStateLabel::instance < DefaultStateType > ( );
+/*    DefaultStateType failState = label::FailStateLabel::instance < DefaultStateType > ( );
     auto transitionsToFailState = minimalSuffixAutomaton.getTransitionsToState ( failState );
     for ( const auto & transition : transitionsToFailState )
         minimalSuffixAutomaton.removeTransition ( transition.first.first, transition.first.second, transition.second );
-    minimalSuffixAutomaton.removeState ( failState );
+    minimalSuffixAutomaton.removeState ( failState );*/ // No it not supposed to be here
     return minimalSuffixAutomaton;
 }

alib2algo_experimental/src/stringology/exact/SuffixAutomaton.h

@@ -27,7 +27,7 @@ public:
      */
     static automaton::Automaton naiveConstruct ( const string::String & pattern );
-    static automaton::DFA<> naiveConstruct ( const string::LinearString < > & pattern );
+    static automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > > naiveConstruct ( const string::LinearString < > & pattern );
      /**
      * Linear time on-line construction of minimal suffix automaton for given pattern.