Skip to content
Snippets Groups Projects
Commit 657c17f7 authored by Jan Trávníček's avatar Jan Trávníček
Browse files

some more adaptations to template changes

parent 3f2da953
No related branches found
No related tags found
No related merge requests found
Pipeline #
Hide whitespace changes
Inline Side-by-side
Showing
with 169 additions and 173 deletions
alib2algo/src/automaton/convert/ToGrammar.h
+ 9
− 9
View file @ 657c17f7
...@@ -43,27 +43,27 @@ public: ...@@ -43,27 +43,27 @@ public:
/** /**
* Performs the conversion (@sa ToGrammarRightRG::convert). * Performs the conversion (@sa ToGrammarRightRG::convert).
* @tparam SymbolType Type for symbols. * @tparam SymbolType Type for symbols.
* @tparam StateAndNonterminalType Type for states. * @tparam StateType Type for states.
* @param automaton the automaton to convert * @param automaton the automaton to convert
* @return right regular grammar equivalent to the input @p automaton * @return right regular grammar equivalent to the input @p automaton
*/ */
template < class SymbolType, class StateAndNonterminalType > template < class SymbolType, class StateType >
static grammar::RightRG < SymbolType, StateAndNonterminalType > convert(const automaton::NFA < SymbolType, StateAndNonterminalType > & automaton); static grammar::RightRG < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
   
/** /**
* @overload * @overload
*/ */
template < class SymbolType, class StateAndNonterminalType > template < class SymbolType, class StateType >
static grammar::RightRG < SymbolType, StateAndNonterminalType > convert(const automaton::DFA < SymbolType, StateAndNonterminalType > & automaton); static grammar::RightRG < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
}; };
   
template < class SymbolType, class StateAndNonterminalType > template < class SymbolType, class StateType >
grammar::RightRG < SymbolType, StateAndNonterminalType > ToGrammar::convert(const automaton::NFA < SymbolType, StateAndNonterminalType > & automaton) { grammar::RightRG < SymbolType, StateType > ToGrammar::convert(const automaton::NFA < SymbolType, StateType > & automaton) {
return ToGrammarRightRG::convert ( automaton ); return ToGrammarRightRG::convert ( automaton );
} }
   
template < class SymbolType, class StateAndNonterminalType > template < class SymbolType, class StateType >
grammar::RightRG < SymbolType, StateAndNonterminalType > ToGrammar::convert(const automaton::DFA < SymbolType, StateAndNonterminalType > & automaton) { grammar::RightRG < SymbolType, StateType > ToGrammar::convert(const automaton::DFA < SymbolType, StateType > & automaton) {
return ToGrammarRightRG::convert ( automaton ); return ToGrammarRightRG::convert ( automaton );
} }
   
......
alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
+ 0
− 92
View file @ 657c17f7
...@@ -6,104 +6,12 @@ ...@@ -6,104 +6,12 @@
*/ */
   
#include "ToGrammarLeftRG.h" #include "ToGrammarLeftRG.h"
#include <alib/map>
#include <common/createUnique.hpp>
#include <alphabet/InitialSymbol.h>
#include <registration/AlgoRegistration.hpp> #include <registration/AlgoRegistration.hpp>
   
namespace automaton { namespace automaton {
   
namespace convert { namespace convert {
   
grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
// step 2
grammar::LeftRG < > grammar(alphabet::InitialSymbol::instance < DefaultSymbolType > ( ) );
// step 1
grammar.setTerminalAlphabet(automaton.getInputAlphabet());
for(const auto& state : automaton.getStates()) {
DefaultSymbolType nt = common::createUnique(DefaultSymbolType(state), grammar.getTerminalAlphabet(), grammar.getNonterminalAlphabet());
grammar.addNonterminalSymbol(nt);
nonterminalMap.insert(std::pair<DefaultStateType, DefaultSymbolType>(state, nt));
}
// step 3 - create set of P in G
for(const auto& transition : automaton.getTransitions()) {
const DefaultStateType& from = transition.first.first;
const DefaultSymbolType& input = transition.first.second;
for(const auto& to : transition.second)
{
// 3a
grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getInitialState() == from)
{
grammar.addRule(nonterminalMap.find(to)->second, input);
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), input);
}
}
}
if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
grammar.setGeneratesEpsilon(true);
return grammar;
}
grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
// step 2
grammar::LeftRG < > grammar(alphabet::InitialSymbol::instance < DefaultSymbolType > ( ) );
// step 1
grammar.setTerminalAlphabet(automaton.getInputAlphabet());
for(const auto& state : automaton.getStates()) {
DefaultSymbolType nt = common::createUnique(DefaultSymbolType(state), grammar.getTerminalAlphabet(), grammar.getNonterminalAlphabet());
grammar.addNonterminalSymbol(nt);
nonterminalMap.insert(std::pair<DefaultStateType, DefaultSymbolType>(state, nt));
}
// step 3 - create set of P in G
for(const auto& transition : automaton.getTransitions()) {
const DefaultStateType& from = transition.first.first;
const DefaultSymbolType& input = transition.first.second;
const DefaultStateType& to = transition.second;
// 3a
grammar.addRule(nonterminalMap.find(to)->second, ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(nonterminalMap.find(from)->second, input));
if(automaton.getInitialState() == from)
{
grammar.addRule(nonterminalMap.find(to)->second, input);
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), input);
}
}
if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
grammar.setGeneratesEpsilon(true);
return grammar;
}
auto ToGrammarLeftRGNFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::NFA < > & > ( ToGrammarLeftRG::convert ); auto ToGrammarLeftRGNFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::NFA < > & > ( ToGrammarLeftRG::convert );
auto ToGrammarLeftRGDFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::DFA < > & > ( ToGrammarLeftRG::convert ); auto ToGrammarLeftRGDFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::DFA < > & > ( ToGrammarLeftRG::convert );
   
......
alib2algo/src/automaton/convert/ToGrammarLeftRG.h
+ 97
− 5
View file @ 657c17f7
...@@ -29,6 +29,11 @@ ...@@ -29,6 +29,11 @@
#include <automaton/FSM/NFA.h> #include <automaton/FSM/NFA.h>
#include <automaton/FSM/DFA.h> #include <automaton/FSM/DFA.h>
   
#include <alib/map>
#include <common/createUnique.hpp>
#include <alphabet/InitialSymbol.h>
namespace automaton { namespace automaton {
   
namespace convert { namespace convert {
...@@ -40,17 +45,104 @@ class ToGrammarLeftRG { ...@@ -40,17 +45,104 @@ class ToGrammarLeftRG {
public: public:
/** /**
* Performs the conversion of the finite automaton to left regular grammar. * Performs the conversion of the finite automaton to left regular grammar.
* @param automaton a finite automaton to convert *
* @return left regular grammar equivalent to the source @p automaton. * \tparam SymbolType the type of input/terminal symbols of automaton and the resulting grammar
* \tparam StateType the type of states of the automaton and nonterminal symbols of the resulting grammar
*
* \param automaton a finite automaton to convert
*
* \return left regular grammar equivalent to the source @p automaton.
*/ */
static grammar::LeftRG < > convert(const automaton::NFA < > & automaton); template < class SymbolType, class StateType >
static grammar::LeftRG < SymbolType, StateType > convert(const automaton::NFA < SymbolType, StateType > & automaton);
   
/** /**
* @overload * \overload
*/ */
static grammar::LeftRG < > convert(const automaton::DFA < > & automaton); template < class SymbolType, class StateType >
static grammar::LeftRG < SymbolType, StateType > convert(const automaton::DFA < SymbolType, StateType > & automaton);
}; };
   
template < class SymbolType, class StateType >
grammar::LeftRG < SymbolType, StateType > ToGrammarLeftRG::convert(const automaton::NFA < SymbolType, StateType > & automaton) {
// step 2
grammar::LeftRG < SymbolType, StateType > grammar(alphabet::InitialSymbol::instance < StateType > ( ) );
// step 1
grammar.setTerminalAlphabet(automaton.getInputAlphabet());
for ( const auto & state : automaton.getStates ( ) ) {
grammar.addNonterminalSymbol ( state );
}
// step 3 - create set of P in G
for(const auto& transition : automaton.getTransitions()) {
const StateType& from = transition.first.first;
const SymbolType& input = transition.first.second;
for(const auto& to : transition.second) {
// 3a
grammar.addRule ( to, ext::make_pair ( from, input ) );
if ( automaton.getFinalStates ( ).count ( to ) > 0)
grammar.addRule ( grammar.getInitialSymbol ( ), ext::make_pair ( from, input ) );
if ( automaton.getInitialState ( ) == from ) {
grammar.addRule ( to, input );
if ( automaton.getFinalStates ( ).count ( to ) > 0 )
grammar.addRule ( grammar.getInitialSymbol ( ), input );
}
}
}
if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
grammar.setGeneratesEpsilon(true);
return grammar;
}
template < class SymbolType, class StateType >
grammar::LeftRG < SymbolType, StateType > ToGrammarLeftRG::convert ( const automaton::DFA < SymbolType, StateType > & automaton ) {
// step 2
grammar::LeftRG < SymbolType, StateType > grammar(alphabet::InitialSymbol::instance < StateType > ( ) );
// step 1
grammar.setTerminalAlphabet(automaton.getInputAlphabet());
for ( const auto & state : automaton.getStates ( ) ) {
grammar.addNonterminalSymbol ( state );
}
// step 3 - create set of P in G
for(const auto& transition : automaton.getTransitions()) {
const StateType& from = transition.first.first;
const SymbolType& input = transition.first.second;
const StateType& to = transition.second;
// 3a
grammar.addRule(to, ext::make_pair(from, input));
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), ext::make_pair(from, input));
if(automaton.getInitialState() == from)
{
grammar.addRule(to, input);
if(automaton.getFinalStates().count(to) > 0)
grammar.addRule(grammar.getInitialSymbol(), input);
}
}
if(automaton.getFinalStates().count(automaton.getInitialState()) > 0)
grammar.setGeneratesEpsilon(true);
return grammar;
}
} /* namespace convert */ } /* namespace convert */
   
} /* namespace automaton */ } /* namespace automaton */
......
alib2algo/src/automaton/convert/ToGrammarRightRG.h
+ 13
− 17
View file @ 657c17f7
...@@ -44,26 +44,27 @@ public: ...@@ -44,26 +44,27 @@ public:
* Performs the conversion of the finite automaton to right regular grammar. * Performs the conversion of the finite automaton to right regular grammar.
* *
* \tparam SymbolType the type of input/terminal symbols of automaton and the resulting grammar * \tparam SymbolType the type of input/terminal symbols of automaton and the resulting grammar
* \tparam StateNonterminalType the type of states of the automaton and nonterminal symbols of the resulting grammar * \tparam StateType the type of states of the automaton and nonterminal symbols of the resulting grammar
* *
* \param automaton a finite automaton to convert * \param automaton a finite automaton to convert
* *
* \return right regular grammar equivalent to the source @p automaton. * \return right regular grammar equivalent to the source @p automaton.
*/ */
template < class SymbolType, class StateNonterminalType > template < class SymbolType, class StateType >
static grammar::RightRG < SymbolType, StateNonterminalType > convert ( const automaton::NFA < SymbolType, StateNonterminalType > & automaton ); static grammar::RightRG < SymbolType, StateType > convert ( const automaton::NFA < SymbolType, StateType > & automaton );
   
/** /**
* \overload * \overload
*/ */
template < class SymbolType, class StateNonterminalType > template < class SymbolType, class StateType >
static grammar::RightRG < SymbolType, StateNonterminalType > convert ( const automaton::DFA < SymbolType, StateNonterminalType > & automaton ); static grammar::RightRG < SymbolType, StateType > convert ( const automaton::DFA < SymbolType, StateType > & automaton );
}; };
   
   
template < class SymbolType, class StateNonterminalType > template < class SymbolType, class StateType >
grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ( const automaton::NFA < SymbolType, StateNonterminalType > & automaton ) { grammar::RightRG < SymbolType, StateType > ToGrammarRightRG::convert ( const automaton::NFA < SymbolType, StateType > & automaton ) {
grammar::RightRG < SymbolType, StateNonterminalType > grammar ( automaton.getInitialState ( ) ); // step 3 - set start symbol of G
grammar::RightRG < SymbolType, StateType > grammar ( automaton.getInitialState ( ) );
   
grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) ); grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) );
grammar.setNonterminalAlphabet ( automaton.getStates ( ) ); grammar.setNonterminalAlphabet ( automaton.getStates ( ) );
...@@ -80,9 +81,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ...@@ -80,9 +81,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
} }
} }
   
// step 3 - set start symbol of G
grammar.setInitialSymbol(automaton.getInitialState());
// step 4 // step 4
if(automaton.getFinalStates().count(automaton.getInitialState())) if(automaton.getFinalStates().count(automaton.getInitialState()))
grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :)) grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :))
...@@ -90,9 +88,10 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ...@@ -90,9 +88,10 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
return grammar; return grammar;
} }
   
template < class SymbolType, class StateNonterminalType > template < class SymbolType, class StateType >
grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ( const automaton::DFA < SymbolType, StateNonterminalType > & automaton ) { grammar::RightRG < SymbolType, StateType > ToGrammarRightRG::convert ( const automaton::DFA < SymbolType, StateType > & automaton ) {
grammar::RightRG < SymbolType, StateNonterminalType > grammar ( automaton.getInitialState ( ) ); // step 3 - set start symbol of G
grammar::RightRG < SymbolType, StateType > grammar ( automaton.getInitialState ( ) );
   
grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) ); grammar.setTerminalAlphabet ( automaton.getInputAlphabet ( ) );
grammar.setNonterminalAlphabet ( automaton.getStates ( ) ); grammar.setNonterminalAlphabet ( automaton.getStates ( ) );
...@@ -108,9 +107,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert ...@@ -108,9 +107,6 @@ grammar::RightRG < SymbolType, StateNonterminalType > ToGrammarRightRG::convert
grammar.addRule(from, input); grammar.addRule(from, input);
} }
   
// step 3 - set start symbol of G
grammar.setInitialSymbol ( automaton.getInitialState ( ) );
// step 4 // step 4
if ( automaton.getFinalStates ( ).count ( automaton.getInitialState ( ) ) ) if ( automaton.getFinalStates ( ).count ( automaton.getInitialState ( ) ) )
grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :)) grammar.setGeneratesEpsilon(true); // okay this feature makes the algorithm a bit different but at the same time it simplifies the code :))
......
alib2algo/src/grammar/simplify/SimpleRulesRemover.h
+ 38
− 38
View file @ 657c17f7
...@@ -36,24 +36,24 @@ class SimpleRulesRemover { ...@@ -36,24 +36,24 @@ class SimpleRulesRemover {
static T removeNonEpsilonFree( const T & origGrammar ); static T removeNonEpsilonFree( const T & origGrammar );
   
public: public:
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::CFG < SymbolType > remove( const grammar::CFG < SymbolType > & grammar ); static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::EpsilonFreeCFG < SymbolType > remove( const grammar::EpsilonFreeCFG < SymbolType > & grammar ); static grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < SymbolType > remove( const grammar::GNF < SymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::CNF < SymbolType > remove( const grammar::CNF < SymbolType > & grammar ); static grammar::CNF < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::LG < SymbolType > remove( const grammar::LG < SymbolType > & grammar ); static grammar::LG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::LeftLG < SymbolType > remove( const grammar::LeftLG < SymbolType > & grammar ); static grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::LeftRG < SymbolType > remove( const grammar::LeftRG < SymbolType > & grammar ); static grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::RightLG < SymbolType > remove( const grammar::RightLG < SymbolType > & grammar ); static grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::RightRG < SymbolType > remove( const grammar::RightRG < SymbolType > & grammar ); static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > remove( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
}; };
   
template < class T, class TerminalSymbolType, class NonterminalSymbolType > template < class T, class TerminalSymbolType, class NonterminalSymbolType >
...@@ -82,14 +82,14 @@ T SimpleRulesRemover::removeNonEpsilonFree( const T & origGrammar ) { ...@@ -82,14 +82,14 @@ T SimpleRulesRemover::removeNonEpsilonFree( const T & origGrammar ) {
return grammar; return grammar;
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::CFG < SymbolType > SimpleRulesRemover::remove(const grammar::CFG < SymbolType > & origGrammar) { grammar::CFG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::CFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return removeNonEpsilonFree(origGrammar); return removeNonEpsilonFree(origGrammar);
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar::EpsilonFreeCFG < SymbolType > & origGrammar) { grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
grammar::EpsilonFreeCFG < SymbolType > grammar(origGrammar.getInitialSymbol()); grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > grammar(origGrammar.getInitialSymbol());
   
for( const auto & symbol : origGrammar.getNonterminalAlphabet() ) for( const auto & symbol : origGrammar.getNonterminalAlphabet() )
grammar.addNonterminalSymbol( symbol ); grammar.addNonterminalSymbol( symbol );
...@@ -98,7 +98,7 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar: ...@@ -98,7 +98,7 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar:
grammar.addTerminalSymbol( symbol ); grammar.addTerminalSymbol( symbol );
   
for( const auto & symbol : origGrammar.getNonterminalAlphabet() ) { for( const auto & symbol : origGrammar.getNonterminalAlphabet() ) {
ext::set<SymbolType> simpleRulesClosure = grammar::properties::NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle(origGrammar, symbol); ext::set < NonterminalSymbolType > simpleRulesClosure = grammar::properties::NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle ( origGrammar, symbol );
for( const auto & closureSymbol : simpleRulesClosure ) { for( const auto & closureSymbol : simpleRulesClosure ) {
auto rules = origGrammar.getRules().find(closureSymbol); auto rules = origGrammar.getRules().find(closureSymbol);
if(rules != origGrammar.getRules().end()) for( const auto& rawRule : rules->second ) { if(rules != origGrammar.getRules().end()) for( const auto& rawRule : rules->second ) {
...@@ -113,38 +113,38 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar: ...@@ -113,38 +113,38 @@ grammar::EpsilonFreeCFG < SymbolType > SimpleRulesRemover::remove(const grammar:
return grammar; return grammar;
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::CNF < SymbolType > SimpleRulesRemover::remove(const grammar::CNF < SymbolType > & origGrammar) { grammar::CNF < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::GNF < SymbolType > SimpleRulesRemover::remove(const grammar::GNF < SymbolType > & origGrammar) { grammar::GNF < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::LG < SymbolType > SimpleRulesRemover::remove(const grammar::LG < SymbolType > & origGrammar) { grammar::LG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return removeNonEpsilonFree(origGrammar); return removeNonEpsilonFree(origGrammar);
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::LeftLG < SymbolType > SimpleRulesRemover::remove(const grammar::LeftLG < SymbolType > & origGrammar) { grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return removeNonEpsilonFree(origGrammar); return removeNonEpsilonFree(origGrammar);
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::LeftRG < SymbolType > SimpleRulesRemover::remove(const grammar::LeftRG < SymbolType > & origGrammar) { grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::RightLG < SymbolType > SimpleRulesRemover::remove(const grammar::RightLG < SymbolType > & origGrammar) { grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return removeNonEpsilonFree(origGrammar); return removeNonEpsilonFree(origGrammar);
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::RightRG < SymbolType > SimpleRulesRemover::remove(const grammar::RightRG < SymbolType > & origGrammar) { grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > SimpleRulesRemover::remove(const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
......
alib2algo/src/grammar/simplify/ToGNF.h
+ 12
− 12
View file @ 657c17f7
...@@ -44,18 +44,18 @@ public: ...@@ -44,18 +44,18 @@ public:
static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert ( const grammar::EpsilonFreeCFG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class TerminalSymbolType, class NonterminalSymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::CNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < SymbolType > convert( const grammar::GNF < SymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class TerminalSymbolType, class NonterminalSymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class TerminalSymbolType, class NonterminalSymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::LeftLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::RightRG < SymbolType > convert( const grammar::LeftRG < SymbolType > & grammar ); static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class TerminalSymbolType, class NonterminalSymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar ); static grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, NonterminalSymbolType > > convert( const grammar::RightLG < TerminalSymbolType, NonterminalSymbolType > & grammar );
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
static grammar::RightRG < SymbolType > convert( const grammar::RightRG < SymbolType > & grammar ); static grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > convert( const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & grammar );
}; };
   
template < class TerminalSymbolType, class NonterminalSymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
...@@ -145,8 +145,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina ...@@ -145,8 +145,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
return convertInternal(grammar::simplify::LeftRecursionRemover::remove(origGrammar)); return convertInternal(grammar::simplify::LeftRecursionRemover::remove(origGrammar));
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::GNF < SymbolType > ToGNF::convert(const grammar::GNF < SymbolType > & origGrammar) { grammar::GNF < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::GNF < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
...@@ -160,8 +160,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina ...@@ -160,8 +160,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)))); return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::RightRG < SymbolType > ToGNF::convert(const grammar::LeftRG < SymbolType > & origGrammar) { grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::LeftRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return convert::ToGrammarRightRG::convert(origGrammar); return convert::ToGrammarRightRG::convert(origGrammar);
} }
   
...@@ -170,8 +170,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina ...@@ -170,8 +170,8 @@ grammar::GNF < TerminalSymbolType, ext::variant < TerminalSymbolType, Nontermina
return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)))); return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::LeftRecursionRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar))));
} }
   
template < class SymbolType > template < class TerminalSymbolType, class NonterminalSymbolType >
grammar::RightRG < SymbolType > ToGNF::convert(const grammar::RightRG < SymbolType > & origGrammar) { grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > ToGNF::convert(const grammar::RightRG < TerminalSymbolType, NonterminalSymbolType > & origGrammar) {
return origGrammar; return origGrammar;
} }
   
......
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