Skip to content
Snippets Groups Projects
Commit 3142d60d authored by Tomáš Pecka's avatar Tomáš Pecka
Browse files

GlushkovRTE: Algo V3

parent 39e6aa17
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
aconversions2/src/ConversionHandler.cpp
+ 1
− 1
View file @ 3142d60d
......@@ -352,7 +352,7 @@ void ConversionHandler::convertRTEtoPDA ( void ) {
break;
}
case GLUSHKOV_RTE_V3: {
automaton::NPDA < > automaton = rte::convert::ToPostfixPushdownAutomatonGlushkovV3::convert ( rte );
automaton::Automaton automaton = rte::convert::ToPostfixPushdownAutomatonGlushkovV3::convert ( rte );
 
measurements::end ( );
measurements::start ( "Output write", measurements::Type::AUXILIARY );
......
alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.cpp
+ 170
− 38
View file @ 3142d60d
......@@ -7,17 +7,16 @@
 
#include "ToPostfixPushdownAutomatonGlushkovV3.h"
 
#include "alphabet/BottomOfTheStackSymbol.h"
#include "alphabet/EndSymbol.h"
#include <automaton/Automaton.h>
#include <alphabet/BottomOfTheStackSymbol.h>
#include <alphabet/EndSymbol.h>
 
#include "global/GlobalData.h"
#include <global/GlobalData.h>
#include <registration/AlgoRegistration.hpp>
 
#include "../glushkov/GlushkovFollowV3.h"
#include "../glushkov/GlushkovIndexate.h"
#include "../glushkov/GlushkovFirst.h"
#include <registration/AlgoRegistration.hpp>
 
namespace rte {
 
......@@ -27,13 +26,6 @@ automaton::Automaton ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::
return dispatch ( rte.getData ( ) );
}
 
/*
std::vector < DefaultSymbolType > phi ( const std::vector < std::ranked_symbol < > > & follow ) {
return std::transform < DefaultSymbolType > ( follow, []( const std::ranked_symbol < > & symbol ) { return DefaultSymbolType ( alphabet::RankedSymbol < > ( symbol ) ); } );
}
*/
template < class SymbolType, class RankType >
bool ToPostfixPushdownAutomatonGlushkovV3::isSubstSymbolPresent ( const std::set < std::ranked_symbol < SymbolType, RankType > > & container, const TAlphabet < SymbolType, RankType > & substAlphabet ) {
std::vector < std::ranked_symbol < > > intersection;
......@@ -75,8 +67,8 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
DefaultStateType q = DefaultStateType ( 'q' );
DefaultStateType f = DefaultStateType ( 'f' );
 
auto bots = std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >::template from < alphabet::BottomOfTheStackSymbol > ( );
automaton::NPDA < SymbolType, DefaultEpsilonType, std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >, DefaultStateType > automaton ( q, bots );
auto BotS = std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >::template from < alphabet::BottomOfTheStackSymbol > ( );
automaton::NPDA < SymbolType, DefaultEpsilonType, std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >, DefaultStateType > automaton ( q, BotS );
 
automaton.addState ( f );
automaton.addFinalState ( f );
......@@ -86,13 +78,22 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
 
automaton.addInputSymbol ( alphabet::EndSymbol::instance < DefaultSymbolType > ( ) );
 
// step 4; create pushdown store alphabet; it consists of elements of indexed RTE alphabet and BotS symbol
/*
// step 4; create pushdown store alphabet;
// simple
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) )
automaton.addPushdownStoreSymbol ( DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) );
*/
automaton.addPushdownStoreSymbol ( std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > ( { symb } ) );
 
/* DEBUG */
// complex
for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) {
for ( const std::set < std::ranked_symbol < > > & symb : followTuple ) {
automaton.addPushdownStoreSymbol ( std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > ( symb ) );
}
}
}
/* DEBUG */
if ( common::GlobalData::verbose ) {
std::cerr << "RTE:" << std::endl;
 
......@@ -108,46 +109,177 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
 
std::cerr << std::endl;
 
for ( const auto & kv : followSet ) {
// std::map < std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > > followSet;
for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
std::cerr << "Follow(RTE, " << kv.first << "):" << std::endl;
 
if ( kv.second.empty ( ) )
std::cerr << "\t" << "{}" << std::endl;
 
for ( const auto & follow : kv.second ) {
for ( const auto & symbol : follow )
std::cerr << "\t" << symbol << std::endl;
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
std::cerr << " \t - FollowTuple:" << std::endl;
for ( const std::set < std::ranked_symbol < > > & child : followTuple )
std::cerr << "\t\t - " << child << std::endl;
 
std::cerr << std::endl;
}
 
std::cerr << std::endl;
}
std::cerr << "---------------------------------------------------------" << std::endl;
std::cerr << "PDA:" << std::endl;
std::cerr << "pds symbols" << std::endl;
for ( const auto & symb : automaton.getPushdownStoreAlphabet ( ) )
std::cerr << "\t" << symb << std::endl;
std::cerr << std::endl;
}
/* DEBUG END */
 
/*
/* TRANSITIONS */
// Pattern 3
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) ) {
std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > push;
push.push_back( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, push );
if ( common::GlobalData::verbose ) {
std::cerr << "1: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
"\t" << "[]" << std::endl <<
"\t ->" << std::endl <<
"\t" << push << std::endl << std::endl;
}
}
}
// Pattern 2
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) )
automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, { DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) } );
else;
//for ( const std::vector < std::ranked_symbol < > > & follow : followSet[symb] ) {
//std::vector < DefaultSymbolType > fstring = phi ( follow );
//std::reverse ( fstring.begin ( ), fstring.end ( ) );
//automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), fstring, q, { DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) } );
//}
if ( symb.getRank ( ) != primitive::Unsigned ( 0 ) ) {
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : followSet [ symb ] ) { //tuple = vector < set < symb > >
std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop, push;
/*
for ( const auto & e : symbFollowTuple )
pop.push_back ( e );
std::reverse ( pop.begin ( ), pop.end ( ) ); // <------------ WTF. CRASHES HERE
*/
for ( const auto & e : followTuple )
pop.insert ( pop.begin ( ), e );
push.push_back( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), pop, q, push );
if ( common::GlobalData::verbose ) {
std::cerr << "2: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
"\t" << pop << std::endl <<
"\t ->" << std::endl <<
"\t" << push << std::endl << std::endl;
}
}
}
}
 
// Pattern 1
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
// 1a
if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) ) {
/* If symb \in some symbolSet of followSet [ i ], then symb | \varepsilon -> symbolSet */
for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
for ( const std::set < std::ranked_symbol < > > & symbolSet : followTuple ) {
if ( symbolSet.count ( symb ) ) {
std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > push;
push.push_back( symbolSet );
automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, push );
if ( common::GlobalData::verbose ) {
std::cerr << "1a: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
"\t" << "[ ]" << std::endl <<
"\t ->" << std::endl <<
"\t" << push << std::endl << std::endl;
}
}
}
}
}
} else { // 1b
/* If symb \in some symbolSet of followSet [ i ], then symb | followTuple -> symbolSet */
for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
for ( const std::set < std::ranked_symbol < > > & symbolSet : followTuple ) {
if ( symbolSet.count ( symb ) ) {
std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop, push;
for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & symbFollowTuple : followSet [ symb ] ) {
/*
for ( const auto & e : symbFollowTuple )
pop.push_back ( e );
std::reverse ( pop.begin ( ), pop.end ( ) ); // <------------ WTF. CRASHES HERE
*/
for ( const auto & e : symbFollowTuple )
pop.insert ( pop.begin ( ), e );
push.push_back( symbolSet );
automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), pop, q, push );
if ( common::GlobalData::verbose ) {
std::cerr << "1b: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
"\t" << pop << std::endl <<
"\t ->" << std::endl <<
"\t" << push << std::endl << std::endl;
}
}
}
}
}
}
}
}
*/
 
/*
if ( common::GlobalData::verbose ) {
std::cerr << "transitions:" << std::endl;
for ( const auto & transitionKV : automaton.getTransitions ( ) ) {
// const std::map <
// std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >,
// std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > >
// >
const auto & input = std::get < 1 > ( transitionKV.first );
const auto & pop = std::get < 2 > ( transitionKV.first );
for ( const auto & transitionRHS : transitionKV.second ) {
const auto & push = transitionRHS.second;
std::cerr << "\t" << input << " | " << std::endl;
if ( pop.size( ) == 0 )
std::cerr << "\t\t" << "[]" << std::endl;
for ( const auto & e : pop )
std::cerr << "\t\t" << e << std::endl;
std::cerr << "\t\t" << " --> " << std::endl;
for ( const auto & e : push )
std::cerr << "\t\t" << e << std::endl;
}
}
std::cerr << std::endl;
}
// Final
for ( const std::ranked_symbol < > & symb : firstSet ) {
std::vector < DefaultSymbolType > pop;
pop.push_back ( DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) );
pop.push_back ( alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop;
pop.push_back ( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
pop.push_back ( BotS );
automaton.addTransition ( q, alphabet::EndSymbol::instance < DefaultSymbolType > ( ), pop, f, { } );
}
*/
/* TRANSITIONS END */
 
return automaton;
}
......
alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.h
+ 2
− 1
View file @ 3142d60d
......@@ -16,7 +16,8 @@
#include <rte/RTE.h>
#include <rte/formal/FormalRTE.h>
 
// #include <rte/unbounded/UnboundedRegExp.h>
#include <container/ObjectsVariant.h>
#include <container/ObjectsSet.h>
 
namespace rte {
 
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment