diff --git a/alib2algo/src/conversions/rg2re/Algebraic.cpp b/alib2algo/src/conversions/rg2re/Algebraic.cpp
index 36bca86b616deb5cafb4b7365e4d31bc06aa9247..509e463059548b6c1f12cde6a86ff266e7345bf5 100644
--- a/alib2algo/src/conversions/rg2re/Algebraic.cpp
+++ b/alib2algo/src/conversions/rg2re/Algebraic.cpp
@@ -10,6 +10,7 @@
#include "../../equations/LeftRegularEquationSolver.h"
#include "../../equations/RightRegularEquationSolver.h"
+#include <exception/AlibException.h>
#include <regexp/unbounded/UnboundedRegExpElements.h>
namespace conversions
diff --git a/alib2algo/src/equations/LeftRegularEquationSolver.cpp b/alib2algo/src/equations/LeftRegularEquationSolver.cpp
index cc9fed801761292214289595d2801af941658e28..80051cc993ccc1645d214d9b621c5006fd108103 100644
--- a/alib2algo/src/equations/LeftRegularEquationSolver.cpp
+++ b/alib2algo/src/equations/LeftRegularEquationSolver.cpp
@@ -12,71 +12,71 @@
namespace equations {
-regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate( void ) {
+regexp::UnboundedRegExp LeftRegularEquationSolver::eliminate(void) {
regexp::RegExpOptimize opt;
- for( auto itA = m_symbolsByDepth.rbegin( ); itA != m_symbolsByDepth.rend( ); itA ++ ) {
- const alphabet::Symbol & a = * itA;
+ for(auto itA = nonterminalSymbolsByDepth.rbegin(); itA != nonterminalSymbolsByDepth.rend(); itA ++) {
+ const alphabet::Symbol& a = * itA;
/*
* Apply Arden's Lemma
* A = A0 + B1 + C2
* => A = 10*B + 20*C
*/
- regexp::UnboundedRegExpIteration loop( std::move( m_eqTransition[ a ][ a ] ) );
- opt.optimize( loop );
+ regexp::UnboundedRegExpIteration loop(std::move(equationTransition.find(std::make_pair(a, a))->second));
+ opt.optimize(loop);
// for all transitions from A apply Arden's Lemma
- for( auto itB = std::next( itA ) ; itB != m_symbolsByDepth.rend( ); itB ++ ) {
- const alphabet::Symbol & b = * itB;
+ for(auto itB = std::next(itA) ; itB != nonterminalSymbolsByDepth.rend(); itB ++) {
+ const alphabet::Symbol& b = * itB;
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( std::move( m_eqTransition[ a ][ b ] ) );
- concat.appendElement( loop );
+ concat.appendElement(std::move(equationTransition.find(std::make_pair(a, b))->second));
+ concat.appendElement(loop);
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( concat ) );
- m_eqTransition[ a ][ b ] = std::move( alt );
- opt.optimize( m_eqTransition[ a ][ b ] );
+ alt.appendElement(std::move(concat));
+ equationTransition.find(std::make_pair(a, b))->second = std::move(alt);
+ opt.optimize(equationTransition.find(std::make_pair(a, b))->second);
}
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( std::move( m_eqFinal[ a ] ) );
- concat.appendElement( std::move( loop ) );
+ concat.appendElement(std::move(equationFinal.find(a)->second));
+ concat.appendElement(std::move(loop));
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( concat ) );
- m_eqFinal[ a ] = std::move( alt );
- opt.optimize( m_eqFinal[ a ] );
+ alt.appendElement(std::move(concat));
+ equationFinal.find(a)->second = std::move(alt);
+ opt.optimize(equationFinal.find(a)->second);
/*
* eliminate A from rest of the equations using this pattern:
- * B->C = B->C + concatenate( B->A, A->C )
+ * B->C = B->C + concatenate(B->A, A->C)
*/
- for( auto itB = std::next( itA ); itB != m_symbolsByDepth.rend( ); itB ++ ) {
- const alphabet::Symbol & b = * itB;
+ for(auto itB = std::next(itA); itB != nonterminalSymbolsByDepth.rend(); itB ++) {
+ const alphabet::Symbol& b = * itB;
- for( auto itC = std::next( itA ); itC != m_symbolsByDepth.rend( ); itC ++ ) {
- const alphabet::Symbol & c = * itC;
+ for(auto itC = std::next(itA); itC != nonterminalSymbolsByDepth.rend(); itC ++) {
+ const alphabet::Symbol& c = * itC;
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( m_eqTransition[ a ][ c ] );
- concat.appendElement( m_eqTransition[ b ][ a ] );
+ concat.appendElement(equationTransition.find(std::make_pair(a, c))->second);
+ concat.appendElement(equationTransition.find(std::make_pair(b, a))->second);
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( m_eqTransition[ b ][ c ] ) );
- alt.appendElement( std::move( concat ) );
- m_eqTransition[ b ][ c ] = std::move( alt );
- opt.optimize( m_eqTransition[ b ][ c ] );
+ 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);
+ opt.optimize(equationTransition.find(std::make_pair(b, c))->second);
}
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( m_eqFinal[ a ] );
- concat.appendElement( std::move( m_eqTransition[ b ][ a ] ) );
+ concat.appendElement(equationFinal.find(a)->second);
+ concat.appendElement(std::move(equationTransition.find(std::make_pair(b, a))->second));
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( m_eqFinal[ b ] ) );
- alt.appendElement( std::move( concat ) );
- m_eqFinal[ b ] = std::move( alt );
- opt.optimize( m_eqFinal[ b ] );
+ alt.appendElement(std::move(equationFinal.find(b)->second));
+ alt.appendElement(std::move(concat));
+ equationFinal.find(b)->second = std::move(alt);
+ opt.optimize(equationFinal.find(b)->second);
}
}
- return opt.optimize( regexp::UnboundedRegExp( std::move ( m_eqFinal[ * m_symbolsByDepth.begin( ) ] ) ) );
+ return opt.optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
}
} /* namespace equations */
diff --git a/alib2algo/src/equations/RegularEquationSolver.cpp b/alib2algo/src/equations/RegularEquationSolver.cpp
index 74f8484fc9732b9d5051ee1ca8a349aa38c3ffe1..9ed3e952891a897861ab1ddfda3c5ddb23552c99 100644
--- a/alib2algo/src/equations/RegularEquationSolver.cpp
+++ b/alib2algo/src/equations/RegularEquationSolver.cpp
@@ -7,80 +7,127 @@
#include "RegularEquationSolver.h"
-#include "regexp/unbounded/UnboundedRegExpElements.h"
+#include <exception/AlibException.h>
+#include <algorithm>
namespace equations {
-regexp::UnboundedRegExp RegularEquationSolver::solve( const alphabet::Symbol & solveFor ) {
- if( ! isInSet( solveFor, m_symbols ) )
- throw exception::AlibException( "Trying to solve for symbol not present in equation system" );
+void RegularEquationSolver::setSymbols(const std::set<alphabet::Symbol>& newSymbols) {
+ std::set<alphabet::Symbol> removed, added;
+
+ std::set_difference(nonterminalSymbols.begin(), nonterminalSymbols.end(), newSymbols.begin(), newSymbols.end(), std::inserter(removed, removed.end()));
+ std::set_difference(newSymbols.begin(), newSymbols.end(), nonterminalSymbols.begin(), nonterminalSymbols.end(), std::inserter(added, added.end()));
- /*
- * Firstly, organize states by depth so we can output better looking
- * expressions. We need to solve equation system for automaton initial state,
- * so lets start with the deepest ones and walk towards initial one.
- */
- symbolsByDepth( solveFor );
+ for(const auto& symb : removed) {
+ removeSymbol(symb);
+ }
- return eliminate( );
+ for(const auto& symb : added) {
+ addSymbol(symb);
+ }
}
-void RegularEquationSolver::addSymbol( const alphabet::Symbol & symb ) {
- m_symbols.insert( symb );
+void RegularEquationSolver::removeSymbol(const alphabet::Symbol& symb) {
+ for(const auto& kv : equationTransition) {
+ const alphabet::Symbol& from = kv.first.first;
+ const alphabet::Symbol& to = kv.first.second;
+ const regexp::UnboundedRegExpAlternation& alt = kv.second;
+
+ if((from == symb || to == symb) && alt.getElements().size() != 0) {
+ throw exception::AlibException("Symbol '" + (std::string) symb + "' is in use.");
+ }
+ }
+
+ for(const auto& kv : equationFinal) {
+ const alphabet::Symbol& from = kv.first;
+ const regexp::UnboundedRegExpAlternation& alt = kv.second;
+
+ if(from == symb && alt.getElements().size() != 0) {
+ throw exception::AlibException("Symbol '" + (std::string) from + "' is in use.");
+ }
+ }
+
+
+ nonterminalSymbols.erase(nonterminalSymbols.find(symb));
+ equationFinal.erase(equationFinal.find(symb));
- for( const auto & s1 : m_symbols )
- {
- m_eqTransition[ symb ][ s1 ] = regexp::UnboundedRegExpAlternation { };
- if( s1 != symb )
- m_eqTransition[ s1 ][ symb ] = regexp::UnboundedRegExpAlternation { };
+ for(const auto& s : nonterminalSymbols) {
+ equationTransition.erase(equationTransition.find(std::make_pair(s, symb)));
+ equationTransition.erase(equationTransition.find(std::make_pair(symb, s)));
}
+ equationTransition.erase(equationTransition.find(std::make_pair(symb, symb)));
+}
+
+void RegularEquationSolver::addSymbol(const alphabet::Symbol& symb) {
+ for(const auto& s : nonterminalSymbols) {
+ equationTransition.insert(std::make_pair(std::make_pair(symb, s), regexp::UnboundedRegExpAlternation { }));
+ equationTransition.insert(std::make_pair(std::make_pair(s, symb), regexp::UnboundedRegExpAlternation { }));
+ }
+ equationTransition.insert(std::make_pair(std::make_pair(symb, symb), regexp::UnboundedRegExpAlternation { }));
- m_eqFinal[ symb ] = regexp::UnboundedRegExpAlternation { };
+ nonterminalSymbols.insert(symb);
+ equationFinal.insert(std::make_pair(symb, regexp::UnboundedRegExpAlternation { }));
}
-void RegularEquationSolver::addEquation( const alphabet::Symbol & from, const alphabet::Symbol & to, const regexp::UnboundedRegExpElement& eq ) {
- if( ! isInSet( from, m_symbols ) )
- throw exception::AlibException( "Symbol '" + (std::string) from + "' not in equation system." );
+void RegularEquationSolver::addEquation(const alphabet::Symbol& from, const alphabet::Symbol& to, const regexp::UnboundedRegExpElement& eq) {
+ if(nonterminalSymbols.count(from) == 0) {
+ throw exception::AlibException("Symbol from ('" + (std::string) from + "') is not in equation system.");
+ }
- if( ! isInSet( to, m_symbols ) )
- throw exception::AlibException( "Symbol '" + (std::string) to + "' not in equation system." );
+ if(nonterminalSymbols.count(to) == 0) {
+ throw exception::AlibException("Symbol to ('" + (std::string) to + "') is not in equation system.");
+ }
- m_eqTransition[ from ][ to ].appendElement( eq );
+ equationTransition.find(std::make_pair(from, to))->second.appendElement(eq);
}
-void RegularEquationSolver::addEquation( const alphabet::Symbol & from, const regexp::UnboundedRegExpElement& eq ) {
- if( ! isInSet( from, m_symbols ) )
- throw exception::AlibException( "Symbol '" + (std::string) from + "' not in equation system." );
+void RegularEquationSolver::addEquation(const alphabet::Symbol& from, const regexp::UnboundedRegExpElement& eq) {
+ if(nonterminalSymbols.count(from) == 0) {
+ throw exception::AlibException("Symbol from ('" + (std::string) from + "') is not in equation system.");
+ }
- m_eqFinal[ from ].appendElement( eq );
+ equationFinal.find(from)->second.appendElement(eq);
}
-void RegularEquationSolver::symbolsByDepth( const alphabet::Symbol & solveFor ) {
+void RegularEquationSolver::sortSymbolsByDepth(const alphabet::Symbol& solveFor) {
std::map<alphabet::Symbol, bool> visited;
std::queue<alphabet::Symbol> queue;
- for( const auto & symbol : m_symbols )
- visited[ symbol ] = false;
+ for(const auto& symbol : nonterminalSymbols) {
+ visited[symbol] = false;
+ }
- visited[ solveFor ] = true;
- queue.push( solveFor );
+ visited[solveFor] = true;
+ queue.push(solveFor);
- while( ! queue.empty( ) )
- {
- alphabet::Symbol s = queue.front( );
- queue.pop( );
+ while(! queue.empty()) {
+ alphabet::Symbol s = queue.front();
+ queue.pop();
- m_symbolsByDepth.push_back( s );
+ nonterminalSymbolsByDepth.push_back(s);
- auto map_s = m_eqTransition.find( s );
- for( auto it = map_s->second.begin( ); it != map_s->second.end( ); it ++ )
- {
- if( it->second.getElements().size() > 0 && visited[ it->first ] == false ) {
- visited[ it->first ] = true;
- queue.push( it->first );
+ for(const auto& kv : equationTransition) {
+ // find all transitions from current symbol that are non-empty, enqueue transition's target symbol
+ if(kv.first.first == s && visited[ kv.first.second ] == false && kv.second.getElements().size() > 0) {
+ visited[kv.first.second] = true;
+ queue.push(kv.first.second);
}
}
}
}
+regexp::UnboundedRegExp RegularEquationSolver::solve(const alphabet::Symbol& solveFor) {
+ if(nonterminalSymbols.count(solveFor) == 0) {
+ throw exception::AlibException("Symbol solveFor ('" + (std::string) solveFor + "') is not in equation system.");
+ }
+
+ /*
+ * Firstly, organize states by depth so we can output better looking
+ * expressions. We need to solve equation system for automaton's initial state,
+ * so lets start with the deepest ones and walk towards the initial one.
+ */
+ sortSymbolsByDepth(solveFor);
+ return eliminate();
+}
+
} /* namespace equations */
diff --git a/alib2algo/src/equations/RegularEquationSolver.h b/alib2algo/src/equations/RegularEquationSolver.h
index 9911783a3dee5af4ae796ed80193aed112118e91..1136d232e0d073c9c399fcf9e2571508e1c47ad7 100644
--- a/alib2algo/src/equations/RegularEquationSolver.h
+++ b/alib2algo/src/equations/RegularEquationSolver.h
@@ -8,19 +8,13 @@
#ifndef REGULAREQUATIONSOLVER_H_
#define REGULAREQUATIONSOLVER_H_
+#include <regexp/unbounded/UnboundedRegExpElements.h>
+#include <alphabet/Symbol.h>
+
#include <map>
#include <deque>
#include <queue>
-#include <alphabet/Symbol.h>
-#include <exception/AlibException.h>
-#include <regexp/unbounded/UnboundedRegExpElement.h>
-#include <regexp/unbounded/UnboundedRegExpAlternation.h>
-
-#include "common/macros.h"
-
-// #include "RegExpOptimize.h" //TODO uncomment when implemented
-
namespace equations {
/**
@@ -32,8 +26,24 @@ public:
* Adds nonterminal symbol into system.
*
* @param symb given symbol
+ * @
+ */
+ void addSymbol(const alphabet::Symbol& symbol);
+
+ /**
+ * Removes nonterminal symbol from equation system.
+ *
+ * @param symb given symbol
+ * @throws AlibException when symbol is in use
+ */
+ void removeSymbol(const alphabet::Symbol& symbol);
+
+ /**
+ * Sets nonterminal symbols of the equation system.
+ * @param symbol Symbols to set
+ * @throws AlibException
*/
- void addSymbol( const alphabet::Symbol & symb );
+ void setSymbols(const std::set<alphabet::Symbol>& symbols);
/**
* Adds equation in form FROM = eq TO
@@ -42,7 +52,7 @@ public:
* @param to symbol
* @param eq equation
*/
- void addEquation( const alphabet::Symbol & from, const alphabet::Symbol & to, const regexp::UnboundedRegExpElement& eq );
+ void addEquation(const alphabet::Symbol& from, const alphabet::Symbol& to, const regexp::UnboundedRegExpElement& eq);
/**
* Adds equation in form: FROM = eq
@@ -50,7 +60,7 @@ public:
* @param from
* @param eq
*/
- void addEquation( const alphabet::Symbol & from, const regexp::UnboundedRegExpElement& eq );
+ void addEquation(const alphabet::Symbol& from, const regexp::UnboundedRegExpElement& eq);
/**
* Solve expression system
@@ -58,40 +68,40 @@ public:
* @param solveFor will solve equation system for given symbol
* @return regexp
*/
- regexp::UnboundedRegExp solve( const alphabet::Symbol & solveFor );
+ regexp::UnboundedRegExp solve(const alphabet::Symbol& solveFor);
protected:
/**
* actual equations elimination
* @return pointer to solutions RegExp tree root
*/
- virtual regexp::UnboundedRegExp eliminate( void ) = 0;
+ virtual regexp::UnboundedRegExp eliminate(void) = 0;
/**
- * Runs BFS to determine depth of symbols in equation system and stores it in m_symbolsByDepth;
- * @see m_symbolsByDepth
+ * Runs BFS to determine depth of symbols in equation system and stores it in nonterminalSymbolsByDepth;
+ * @see nonterminalSymbolsByDepth
*/
- void symbolsByDepth( const alphabet::Symbol & solveFor );
+ void sortSymbolsByDepth(const alphabet::Symbol& solveFor);
/**
* @see symbolsByDepth
*/
- std::deque<alphabet::Symbol> m_symbolsByDepth;
+ std::deque<alphabet::Symbol> nonterminalSymbolsByDepth;
/**
* Stores transitions from nonterminal to nonterminal, eg A = 2A + 2B + 1C
*/
- std::map<alphabet::Symbol, std::map<alphabet::Symbol, regexp::UnboundedRegExpAlternation>> m_eqTransition;
+ std::map<std::pair<alphabet::Symbol, alphabet::Symbol>, regexp::UnboundedRegExpAlternation> equationTransition;
/**
* Stores equation not going to particular nonterminal, eg A = 01*
*/
- std::map<alphabet::Symbol, regexp::UnboundedRegExpAlternation> m_eqFinal;
+ std::map<alphabet::Symbol, regexp::UnboundedRegExpAlternation> equationFinal;
/**
* Set of symbols
*/
- std::set<alphabet::Symbol> m_symbols;
+ std::set<alphabet::Symbol> nonterminalSymbols;
};
} /* namespace equations */
diff --git a/alib2algo/src/equations/RightRegularEquationSolver.cpp b/alib2algo/src/equations/RightRegularEquationSolver.cpp
index b9d1dac2ea680a800396236f035b452b9d541d50..63b14225b7e5440ae3e7aff9ff78781872f25c7c 100644
--- a/alib2algo/src/equations/RightRegularEquationSolver.cpp
+++ b/alib2algo/src/equations/RightRegularEquationSolver.cpp
@@ -12,71 +12,71 @@
namespace equations {
-regexp::UnboundedRegExp RightRegularEquationSolver::eliminate( void ) {
+regexp::UnboundedRegExp RightRegularEquationSolver::eliminate(void) {
regexp::RegExpOptimize opt;
- for( auto itA = m_symbolsByDepth.rbegin( ); itA != m_symbolsByDepth.rend( ); itA ++ ) {
- const alphabet::Symbol & a = * itA;
+ for(auto itA = nonterminalSymbolsByDepth.rbegin(); itA != nonterminalSymbolsByDepth.rend(); itA ++) {
+ const alphabet::Symbol& a = * itA;
/*
* Apply Arden's Lemma
* A = 0A + 1B + 2C
* => A = 0*1B + 0*2C
*/
- regexp::UnboundedRegExpIteration loop( std::move( m_eqTransition[ a ][ a ] ) );
- opt.optimize( loop );
+ regexp::UnboundedRegExpIteration loop(std::move(equationTransition.find(std::make_pair(a, a))->second));
+ opt.optimize(loop);
// for all transitions from A apply Arden's Lemma
- for( auto itB = std::next( itA ) ; itB != m_symbolsByDepth.rend( ); itB ++ ) {
- const alphabet::Symbol & b = * itB;
+ for(auto itB = std::next(itA) ; itB != nonterminalSymbolsByDepth.rend(); itB ++) {
+ const alphabet::Symbol& b = * itB;
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( loop );
- concat.appendElement( std::move( m_eqTransition[ a ][ b ] ) );
+ concat.appendElement(loop);
+ concat.appendElement(std::move(equationTransition.find(std::make_pair(a,b))->second));
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( concat ) );
- m_eqTransition[ a ][ b ] = std::move( alt );
- opt.optimize( m_eqTransition[ a ][ b ] );
+ alt.appendElement(std::move(concat));
+ equationTransition.find(std::make_pair(a, b))->second = std::move(alt);
+ opt.optimize(equationTransition.find(std::make_pair(a, b))->second);
}
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( std::move( loop ) );
- concat.appendElement( std::move( m_eqFinal[ a ] ) );
+ concat.appendElement(std::move(loop));
+ concat.appendElement(std::move(equationFinal.find(a)->second));
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( concat ) );
- m_eqFinal[ a ] = std::move( alt );
- opt.optimize( m_eqFinal[ a ] );
+ alt.appendElement(std::move(concat));
+ equationFinal.find(a)->second = std::move(alt);
+ opt.optimize(equationFinal.find(a)->second);
/*
* eliminate A from rest of the equations using this pattern:
- * B->C = B->C + concatenate( B->A, A->C )
+ * B->C = B->C + concatenate(B->A, A->C)
*/
- for( auto itB = std::next( itA ); itB != m_symbolsByDepth.rend( ); itB ++ ) {
- const alphabet::Symbol & b = * itB;
+ for(auto itB = std::next(itA); itB != nonterminalSymbolsByDepth.rend(); itB ++) {
+ const alphabet::Symbol& b = * itB;
- for( auto itC = std::next( itA ); itC != m_symbolsByDepth.rend( ); itC ++ ) {
- const alphabet::Symbol & c = * itC;
+ for(auto itC = std::next(itA); itC != nonterminalSymbolsByDepth.rend(); itC ++) {
+ const alphabet::Symbol& c = * itC;
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( m_eqTransition[ b ][ a ] );
- concat.appendElement( m_eqTransition[ a ][ c ] );
+ concat.appendElement(equationTransition.find(std::make_pair(b, a))->second);
+ concat.appendElement(equationTransition.find(std::make_pair(a, c))->second);
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( m_eqTransition[ b ][ c ] ) );
- alt.appendElement( std::move( concat ) );
- m_eqTransition[ b ][ c ] = std::move( alt );
- opt.optimize( m_eqTransition[ b ][ c ] );
+ 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);
+ opt.optimize(equationTransition.find(std::make_pair(b, c))->second);
}
regexp::UnboundedRegExpConcatenation concat;
- concat.appendElement( std::move( m_eqTransition[ b ][ a ] ) );
- concat.appendElement( m_eqFinal[ a ] );
+ concat.appendElement(std::move(equationTransition.find(std::make_pair(b, a))->second));
+ concat.appendElement(equationFinal.find(a)->second);
regexp::UnboundedRegExpAlternation alt;
- alt.appendElement( std::move( m_eqFinal[ b ] ) );
- alt.appendElement( std::move( concat ) );
- m_eqFinal[ b ] = std::move( alt );
- opt.optimize( m_eqFinal[ b ] );
+ alt.appendElement(std::move(equationFinal.find(b)->second));
+ alt.appendElement(std::move(concat));
+ equationFinal.find(b)->second = std::move(alt);
+ opt.optimize(equationFinal.find(b)->second);
}
}
- return opt.optimize( regexp::UnboundedRegExp( std::move ( m_eqFinal[ * m_symbolsByDepth.begin( ) ] ) ) );
+ return opt.optimize(regexp::UnboundedRegExp(std::move( equationFinal.find(*nonterminalSymbolsByDepth.begin())->second)));
}
} /* namespace equations */
diff --git a/alib2algo/test-src/conversions/re2fa/re2faTest.cpp b/alib2algo/test-src/conversions/re2fa/re2faTest.cpp
index 3e0a368f99de1bd821eb792cb5321d02529733a9..4806de5eb3591f0f92beeb2f5de3ff19ed3767c4 100644
--- a/alib2algo/test-src/conversions/re2fa/re2faTest.cpp
+++ b/alib2algo/test-src/conversions/re2fa/re2faTest.cpp
@@ -83,10 +83,8 @@ void re2faTest::testBrzozowski() {
regexp::RegExp regexp1( parser.parseValue() );
automaton::Automaton nfa1 = conversions::re2fa::BrzozowskiDerivation::convert(regexp1);
- alib::DataFactory::toStdout(nfa1);
regexp::RegExp regexp2( conversions::fa2re::Algebraic::convert(static_cast<const automaton::NFA&>(nfa1.getData())) );
- alib::DataFactory::toStdout(regexp2);
automaton::Automaton nfa2 = conversions::re2fa::BrzozowskiDerivation::convert(regexp2);
@@ -98,8 +96,5 @@ void re2faTest::testBrzozowski() {
automaton::DFA mdfa2_2 = minimize::MinimizeDFA::minimize(mdfa2_1);
automaton::DFA mdfa2_3 = normalize::NormalizeDFA::normalize(mdfa2_2);
- alib::DataFactory::toStdout(mdfa1_3);
- alib::DataFactory::toStdout(mdfa2_3);
-
CPPUNIT_ASSERT( mdfa1_3 == mdfa2_3);
}