minimize algorithm

aminimize/src/Minimize.cpp → alib2algo/src/minimize/dfa/MinimizeDFA.cpp

 /*
- * Minimize.cpp
+ * MinimizeDFA.cpp
  *
  *  Created on: Dec 9, 2013
  *      Author: honza
  */
-#include "Minimize.h"
+#include "MinimizeDFA.h"
 #include <map>
 #include <set>
@@ -13,23 +13,23 @@
 #include <iostream>
 #include "alphabet/Symbol.h"
-#include "automaton/FSM/TransitionFSM.h"
+#include "label/IntegerLabel.h"
+
+namespace minimize {
 automaton::State fromInteger(int number) {
-  std::stringstream ss;
-  ss << number;
-  return automaton::State(ss.str());
+	return automaton::State(label::Label(label::IntegerLabel(number)));
 }
-automaton::FSM Minimize::minimize(automaton::FSM& fsm) {
+automaton::DFA MinimizeDFA::minimize(const automaton::DFA& dfa) {
 	std::map<automaton::State, std::map<alphabet::Symbol, automaton::State > > refactor;
-	for(std::set<automaton::State>::const_iterator iter = fsm.getStates().begin(); iter != fsm.getStates().end(); iter++) {
+	for(std::set<automaton::State>::const_iterator iter = dfa.getStates().begin(); iter != dfa.getStates().end(); iter++) {
 		refactor.insert(std::pair<automaton::State, std::map<alphabet::Symbol, automaton::State> >(*iter, std::map<alphabet::Symbol, automaton::State>()));
 	}
 	
-	for(std::set<automaton::TransitionFSM>::const_iterator iter = fsm.getTransitions().begin(); iter != fsm.getTransitions().end(); iter++) {
-		refactor[iter->getFrom()].insert(std::pair<alphabet::Symbol, automaton::State>(iter->getInput(), iter->getTo()));
+	for(std::map<std::pair<automaton::State, alphabet::Symbol>, automaton::State>::const_iterator iter = dfa.getTransitions().begin(); iter != dfa.getTransitions().end(); iter++) {
+		refactor[iter->first.first].insert(std::pair<alphabet::Symbol, automaton::State>(iter->first.second, iter->second));
 	}
 	std::map<automaton::State, automaton::State> toEquvivalentStates1;//original state to equivalent state
@@ -38,11 +38,11 @@ automaton::FSM Minimize::minimize(automaton::FSM& fsm) {
 	std::map<automaton::State, automaton::State> toEquvivalentStates2;
 	std::map<std::pair<automaton::State, std::set<std::pair<alphabet::Symbol, automaton::State> > >, std::set<automaton::State> > minimizedTransitionFunction2;
 	
-	for(auto iter = fsm.getStates().begin(); iter != fsm.getStates().end(); iter++) {
-		if(fsm.getFinalStates().count(*iter) == 0) { // not a final state
-			toEquvivalentStates2.insert(std::pair<automaton::State, automaton::State>(*iter, automaton::State("0")));
+	for(auto iter = dfa.getStates().begin(); iter != dfa.getStates().end(); iter++) {
+		if(dfa.getFinalStates().count(*iter) == 0) { // not a final state
+			toEquvivalentStates2.insert(std::pair<automaton::State, automaton::State>(*iter, fromInteger(0)));
 		} else {
-			toEquvivalentStates2.insert(std::pair<automaton::State, automaton::State>(*iter, automaton::State("1")));
+			toEquvivalentStates2.insert(std::pair<automaton::State, automaton::State>(*iter, fromInteger(1)));
 		}
 	}
@@ -97,19 +97,25 @@ automaton::FSM Minimize::minimize(automaton::FSM& fsm) {
 	} while(minimizedTransitionFunction1.size() != minimizedTransitionFunction2.size());
-	automaton::FSM result;
-	for(auto iter = fsm.getInputAlphabet().begin(); iter != fsm.getInputAlphabet().end(); iter++) {
+	const automaton::State* initialState = NULL;
+	for(auto iter = minimizedTransitionFunction2.begin(); iter != minimizedTransitionFunction2.end(); iter++) {
+		if(iter->second.find(dfa.getInitialState()) != iter->second.end()) {
+			initialState = &(iter->first.first);
+			break;
+		}
+	}
+
+	automaton::DFA result(*initialState);
+
+	for(auto iter = dfa.getInputAlphabet().begin(); iter != dfa.getInputAlphabet().end(); iter++) {
 		result.addInputSymbol(*iter);
 	}
 	
 	for(auto iter = minimizedTransitionFunction2.begin(); iter != minimizedTransitionFunction2.end(); iter++) {
 		result.addState(iter->first.first);
-		if(fsm.getFinalStates().find(*(iter->second.begin())) != fsm.getFinalStates().end()) {//TODO improve using intersection
+		if(dfa.getFinalStates().find(*(iter->second.begin())) != dfa.getFinalStates().end()) {//TODO improve using intersection
 			result.addFinalState(iter->first.first);
 		}
-		if(iter->second.find(*(fsm.getInitialStates().begin())) != iter->second.end()) { //TODO improve using intersection
-			result.addInitialState(iter->first.first);
-		}
 	}
 	
 	for(auto iter = minimizedTransitionFunction2.begin(); iter != minimizedTransitionFunction2.end(); iter++) {
@@ -120,3 +126,5 @@ automaton::FSM Minimize::minimize(automaton::FSM& fsm) {
 	
 	return result;
 }
+
+} /* namespace minimize */

alib2algo/src/minimize/dfa/MinimizeDFA.h

+/*
+ * Minimize.h
+ *
+ *  Created on: Dec 9, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef MINIMIZE_DFA_H_
+#define MINIMIZE_DFA_H_
+
+#include "automaton/FSM/DFA.h"
+
+namespace minimize {
+
+class MinimizeDFA {
+public:
+	static automaton::DFA minimize(const automaton::DFA& dfa);
+
+};
+
+}
+
+#endif /* MINIMIZE_DFA_H_ */

alib2algo/test-src/minimize/minimizeTest.cpp

+#include <list>
+#include "minimizeTest.h"
+
+#include "label/StringLabel.h"
+#include "label/IntegerLabel.h"
+#include "label/Label.h"
+#include "alphabet/LabeledSymbol.h"
+
+#include "minimize/dfa/MinimizeDFA.h"
+
+#define CPPUNIT_IMPLY(x, y) CPPUNIT_ASSERT(!(x) || (y))
+
+CPPUNIT_TEST_SUITE_REGISTRATION( minimizeTest );
+
+void minimizeTest::setUp() {
+}
+
+void minimizeTest::tearDown() {
+}
+
+void minimizeTest::testMinimize() {
+  automaton::DFA automaton(automaton::State(label::Label(label::IntegerLabel(1))));
+
+  automaton.addState(automaton::State(label::Label(label::IntegerLabel(1))));
+  automaton.addState(automaton::State(label::Label(label::IntegerLabel(2))));
+  automaton.addState(automaton::State(label::Label(label::IntegerLabel(3))));
+  automaton.addInputSymbol(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel("a")))));
+  automaton.addInputSymbol(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel("b")))));
+  
+  automaton.addTransition(automaton::State(label::Label(label::IntegerLabel(1))), alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel("a")))), automaton::State(label::Label(label::IntegerLabel(2))));
+  automaton.addTransition(automaton::State(label::Label(label::IntegerLabel(2))), alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel("b")))), automaton::State(label::Label(label::IntegerLabel(1))));
+
+  automaton.addFinalState(automaton::State(label::Label(label::IntegerLabel(3))));
+  
+  automaton::DFA minimized = minimize::MinimizeDFA::minimize(automaton);
+
+  CPPUNIT_ASSERT(minimized.getStates().size() == 3);
+
+}

alib2algo/test-src/minimize/minimizeTest.h

+#ifndef RG2RG_TEST_H_
+#define RG2RG_TEST_H_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class minimizeTest : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( minimizeTest );
+  CPPUNIT_TEST( testMinimize );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void testMinimize();
+};
+
+#endif  // RG2RG_TEST_H_

aminimize/src/Minimize.h

-/*
- * Minimize.h
- *
- *  Created on: Dec 9, 2013
- *      Author: honza
- */
-
-#ifndef MINIMIZE_H_
-#define MINIMIZE_H_
-
-#include "automaton/FSM/FSM.h"
-
-class Minimize {
-public:
-	static automaton::FSM minimize(automaton::FSM& fsm);
-
-};
-
-#endif /* MINIMIZE_H_ */