rename InputSymbols to InputAlphabet and similairly

alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp

@@ -59,7 +59,7 @@ automaton::ExtendedNFA ToRegExpStateElimination::eliminateState(const automaton:
 	automaton::ExtendedNFA newAutomaton(extendedAutomaton.getInitialState()); // sure that q is neither initial nor final (follows from step 2 - extending ExtendedNFA)
 	newAutomaton.setStates(extendedAutomaton.getStates());
 	newAutomaton.removeState(q); // preserve all states but q (the one to eliminate)
-	newAutomaton.setInputSymbols(extendedAutomaton.getInputAlphabet());
+	newAutomaton.setInputAlphabet(extendedAutomaton.getInputAlphabet());
 	newAutomaton.setFinalStates(extendedAutomaton.getFinalStates());
 	for(const auto& p: newAutomaton.getStates())

alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx

@@ -19,13 +19,13 @@ automaton::DPDA Determinize::determinize(const automaton::InputDrivenNPDA& nfa)
 	// 1, 4
 	automaton::State initialState(createDFAState({nfa.getInitialState()}));
 	automaton::DPDA res(initialState, nfa.getInitialSymbol());
-	res.setInputSymbols(nfa.getInputAlphabet());
-	res.setStackSymbols(nfa.getStackAlphabet());
-	
+	res.setInputAlphabet(nfa.getInputAlphabet());
+	res.setStackAlphabet(nfa.getStackAlphabet());
+
 	// 2
 	std::deque<automaton::State> todo;
 	todo.push_back(initialState);
-	
+
 	do {
 		// 3a, c
 		automaton::State state = todo.front();
@@ -52,7 +52,7 @@ automaton::DPDA Determinize::determinize(const automaton::InputDrivenNPDA& nfa)
 			if(!existed) todo.push_back(dfaState);
 		}
 	} while(!todo.empty());
-	
+
 	// 5
 	for (const auto& dfaState : res.getStates()) {
 		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
@@ -60,7 +60,7 @@ automaton::DPDA Determinize::determinize(const automaton::InputDrivenNPDA& nfa)
 			res.addFinalState(dfaState);
 		}
 	}
-	
+
 	return res;
 }

alib2algo/src/automaton/determinize/DeterminizeNFAPart.cxx

@@ -20,12 +20,12 @@ automaton::DFA Determinize::determinize(const automaton::MultiInitialStateNFA& n
 	// 1, 4
 	automaton::State initialState(createDFAState(nfa.getInitialStates()));
 	automaton::DFA res(initialState);
-	res.setInputSymbols(nfa.getInputAlphabet());
-	
+	res.setInputAlphabet(nfa.getInputAlphabet());
+
 	// 2
 	std::deque<automaton::State> todo;
 	todo.push_back(initialState);
-	
+
 	do {
 		// 3a, c
 		automaton::State state = todo.front();
@@ -51,7 +51,7 @@ automaton::DFA Determinize::determinize(const automaton::MultiInitialStateNFA& n
 			if(!existed) todo.push_back(dfaState);
 		}
 	} while(!todo.empty());
-	
+
 	// 5
 	for (const auto& dfaState : res.getStates()) {
 		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
@@ -59,7 +59,7 @@ automaton::DFA Determinize::determinize(const automaton::MultiInitialStateNFA& n
 			res.addFinalState(dfaState);
 		}
 	}
-	
+
 	return res;
 }
@@ -67,12 +67,12 @@ automaton::DFA Determinize::determinize(const automaton::NFA& nfa) {
 	// 1, 4
 	automaton::State initialState(createDFAState({nfa.getInitialState()}));
 	automaton::DFA res(initialState);
-	res.setInputSymbols(nfa.getInputAlphabet());
-	
+	res.setInputAlphabet(nfa.getInputAlphabet());
+
 	// 2
 	std::deque<automaton::State> todo;
 	todo.push_back(initialState);
-	
+
 	do {
 		// 3a, c
 		automaton::State state = todo.front();
@@ -98,7 +98,7 @@ automaton::DFA Determinize::determinize(const automaton::NFA& nfa) {
 			if(!existed) todo.push_back(dfaState);
 		}
 	} while(!todo.empty());
-	
+
 	// 5
 	for (const auto& dfaState : res.getStates()) {
 		std::set<automaton::State> nfaStates = recreateNFAStates(dfaState);
@@ -106,7 +106,7 @@ automaton::DFA Determinize::determinize(const automaton::NFA& nfa) {
 			res.addFinalState(dfaState);
 		}
 	}
-	
+
 	return res;
 }

alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx

@@ -24,7 +24,7 @@ void addRetTransition(const automaton::State& from, const std::variant<string::E
 	deterministic.addState(from);
 	deterministic.addState(to);
 	deterministic.addStackSymbol(dvpdaSymbol);
-	
+
 	deterministic.addReturnTransition(from, input, dvpdaSymbol, to);
 }
@@ -156,7 +156,7 @@ void local(const automaton::State& state, const std::variant<string::Epsilon, al
 			}
 		}
 	}
-	
+
 	addLocalTransition(state, input, automaton::State(packToStateLabel(std::move(S1))), deterministic);
 }
@@ -198,7 +198,7 @@ automaton::RealTimeHeightDeterministicDPDA Determinize::determinize(const automa
 	label::Label initialLabel = packToStateLabel(createIdentity(retrieveLabels(n.getInitialStates())));
 	automaton::RealTimeHeightDeterministicDPDA d(automaton::State(initialLabel), n.getBottomOfTheStackSymbol());
-	d.setInputSymbols(n.getInputAlphabet());
+	d.setInputAlphabet(n.getInputAlphabet());
 	for(;;) {
 		std::set<std::pair<automaton::State, alphabet::Symbol>> stateSymbols = existsDirtyStateSymbol(d, n);
@@ -243,7 +243,7 @@ automaton::RealTimeHeightDeterministicDPDA Determinize::determinize(const automa
 			d.addFinalState(state);
 		}
 	}
-	
+
 	return d;
 }

alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx

@@ -23,7 +23,7 @@ void addRetTransition(const automaton::State& from, const alphabet::Symbol& inpu
 	deterministic.addState(from);
 	deterministic.addState(to);
 	deterministic.addStackSymbol(dvpdaSymbol);
-	
+
 	deterministic.addReturnTransition(from, input, dvpdaSymbol, to);
 }
@@ -155,18 +155,18 @@ void local(const automaton::State& state, const alphabet::Symbol& input, const a
 			}
 		}
 	}
-	
+
 	addLocalTransition(state, input, automaton::State(packToStateLabel(std::move(S1))), deterministic);
 }
 automaton::VisiblyPushdownDPDA Determinize::determinize(const automaton::VisiblyPushdownNPDA& n) {
 	label::Label initialLabel = packToStateLabel(createIdentity(retrieveLabels(n.getInitialStates())));
-	
+
 	automaton::VisiblyPushdownDPDA d(automaton::State(initialLabel), n.getBottomOfTheStackSymbol());
-	d.setCallInputSymbols(n.getCallInputAlphabet());
-	d.setLocalInputSymbols(n.getLocalInputAlphabet());
-	d.setReturnInputSymbols(n.getReturnInputAlphabet());
-	
+	d.setCallInputAlphabet(n.getCallInputAlphabet());
+	d.setLocalInputAlphabet(n.getLocalInputAlphabet());
+	d.setReturnInputAlphabet(n.getReturnInputAlphabet());
+
 	for(;;) {
 		std::set<std::pair<automaton::State, alphabet::Symbol>> stateSymbols = existsDirtyStateSymbol(d, n);
 		std::set<automaton::State> states = existsDirtyState(d, n);
@@ -201,7 +201,7 @@ automaton::VisiblyPushdownDPDA Determinize::determinize(const automaton::Visibly
 			d.addFinalState(state);
 		}
 	}
-	
+
 	return d;
 }

alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.cpp

@@ -31,11 +31,8 @@ automaton::NFA EpsilonRemoverIncoming::remove(const automaton::NFA& origFSM)
 automaton::NFA EpsilonRemoverIncoming::remove( const automaton::EpsilonNFA & origFSM ) {
 	automaton::NFA fsm(origFSM.getInitialState());
-	for( const auto & state : origFSM.getStates() )
-		fsm.addState( state );
-
-	for( const auto & symbol : origFSM.getInputAlphabet() )
-		fsm.addInputSymbol( symbol );
+	fsm.setStates( origFSM.getStates() );
+	fsm.setInputAlphabet( origFSM.getInputAlphabet() );
 	/**
 	 * Step 1 from Melichar 2.41

alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.cpp

@@ -30,15 +30,9 @@ automaton::NFA EpsilonRemoverOutgoing::remove(const automaton::NFA& origFSM)
 automaton::MultiInitialStateNFA EpsilonRemoverOutgoing::remove( const automaton::EpsilonNFA & origFSM ) {
 	automaton::MultiInitialStateNFA fsm;
-
-	for( const auto & state : origFSM.getStates() )
-		fsm.addState( state );
-
-	for( const auto & state : origFSM.getFinalStates() )
-		fsm.addFinalState( state );
-
-	for( const auto & symbol : origFSM.getInputAlphabet() )
-		fsm.addInputSymbol( symbol );
+	fsm.setStates( origFSM.getStates() );
+	fsm.setFinalStates( origFSM.getFinalStates() );
+	fsm.setInputAlphabet( origFSM.getInputAlphabet() );
 	/**
 	 * Step 1 from Melichar 2.41

alib2algo/src/automaton/simplify/Minimize.cpp

@@ -33,7 +33,7 @@ automaton::Automaton Minimize::minimize(const automaton::Automaton& automaton) {
 automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 	if(dfa.getFinalStates().size() == 0) {
 		automaton::DFA result(automaton::State(0));
-		result.setInputSymbols(dfa.getInputAlphabet());
+		result.setInputAlphabet(dfa.getInputAlphabet());
 		return result;
 	}
@@ -42,7 +42,7 @@ automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 	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::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));
 	}
@@ -52,7 +52,7 @@ automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 	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 = 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, automaton::State(0)));
@@ -68,22 +68,22 @@ automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 		for(auto iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++) {
 			transitionFunction.insert(std::pair<alphabet::Symbol, automaton::State>(iter2->first, toEquvivalentStates2.find(iter2->second)->second));
 		}
-		
+
 		std::pair<automaton::State, std::set<std::pair<alphabet::Symbol, automaton::State> > > key(from, transitionFunction);
-		
+
 		if(minimizedTransitionFunction2.find(key) == minimizedTransitionFunction2.end()) {
 			minimizedTransitionFunction2.insert(std::pair<std::pair<automaton::State, std::set<std::pair<alphabet::Symbol, automaton::State> > >, std::set<automaton::State> >(key, std::set<automaton::State>()));
 		}
 		minimizedTransitionFunction2[key].insert(iter->first);
 	}
-	
+
 	do {
 		toEquvivalentStates1 = toEquvivalentStates2;
 		minimizedTransitionFunction1 = minimizedTransitionFunction2;
 		toEquvivalentStates2.clear();
 		minimizedTransitionFunction2.clear();
-		
+
 		int number = 0;
 		for(auto iter = minimizedTransitionFunction1.begin(); iter != minimizedTransitionFunction1.end(); iter++) {
 			for(auto iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++) {
@@ -95,19 +95,18 @@ automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 		for(auto iter = refactor.begin(); iter != refactor.end(); iter++) {
 			automaton::State from = toEquvivalentStates2.find(iter->first)->second;
 			std::set<std::pair<alphabet::Symbol, automaton::State> > transitionFunction;
-			
+
 			for(auto iter2 = iter->second.begin(); iter2 != iter->second.end(); iter2++) {
 				transitionFunction.insert(std::pair<alphabet::Symbol, automaton::State>(iter2->first, toEquvivalentStates2.find(iter2->second)->second));
 			}
-			
+
 			std::pair<automaton::State, std::set<std::pair<alphabet::Symbol, automaton::State> > > key(from, transitionFunction);
-			
+
 			if(minimizedTransitionFunction2.find(key) == minimizedTransitionFunction2.end()) {
 				minimizedTransitionFunction2.insert(std::pair<std::pair<automaton::State, std::set<std::pair<alphabet::Symbol, automaton::State> > >, std::set<automaton::State> >(key, std::set<automaton::State>()));
 			}
 			minimizedTransitionFunction2[key].insert(iter->first);
-			
 		}
 	} while(minimizedTransitionFunction1.size() != minimizedTransitionFunction2.size());
@@ -122,23 +121,21 @@ automaton::DFA Minimize::minimize(const automaton::DFA& dfa) {
 	automaton::DFA result(*initialState);
-	for(auto iter = dfa.getInputAlphabet().begin(); iter != dfa.getInputAlphabet().end(); iter++) {
-		result.addInputSymbol(*iter);
-	}
-	
+	result.setInputAlphabet(dfa.getInputAlphabet());
+
 	for(auto iter = minimizedTransitionFunction2.begin(); iter != minimizedTransitionFunction2.end(); iter++) {
 		result.addState(iter->first.first);
 		if(dfa.getFinalStates().find(*(iter->second.begin())) != dfa.getFinalStates().end()) {
 			result.addFinalState(iter->first.first);
 		}
 	}
-	
+
 	for(auto iter = minimizedTransitionFunction2.begin(); iter != minimizedTransitionFunction2.end(); iter++) {
 		for(auto iter2 = iter->first.second.begin(); iter2 != iter->first.second.end(); iter2++) {
 			result.addTransition(iter->first.first, iter2->first, iter2->second);
 		}
 	}
-	
+
 	return result;
 }

alib2algo/src/automaton/simplify/Normalize.cpp

@@ -61,7 +61,7 @@ automaton::DFA Normalize::normalize(const automaton::DFA& fsm) {
 	automaton::DFA result(automaton::State(normalizationData.find(fsm.getInitialState())->second));
-	result.setInputSymbols(fsm.getInputAlphabet());
+	result.setInputAlphabet(fsm.getInputAlphabet());
 	for(auto iter = fsm.getStates().begin(); iter != fsm.getStates().end(); iter++) {
 		result.addState(automaton::State(normalizationData.find(*iter)->second));
@@ -130,8 +130,7 @@ automaton::DPDA Normalize::normalize(const automaton::DPDA& pda) {
 	}
 	automaton::DPDA result(automaton::State(normalizationDataState.find(pda.getInitialState())->second), alphabet::symbolFrom(normalizationDataSymbol.find(pda.getInitialSymbol())->second));
-
-	result.setInputSymbols(pda.getInputAlphabet());
+	result.setInputAlphabet(pda.getInputAlphabet());
 	for(auto iter = pda.getStackAlphabet().begin(); iter != pda.getStackAlphabet().end(); iter++) {
 		result.addStackSymbol(alphabet::symbolFrom(normalizationDataSymbol.find(*iter)->second));

alib2algo/src/automaton/simplify/Rename.cpp

@@ -42,7 +42,7 @@ automaton::DFA Rename::rename(const automaton::DFA& fsm) {
 	automaton::DFA result(automaton::State(renamingData.find(fsm.getInitialState())->second));
-	result.setInputSymbols(fsm.getInputAlphabet());
+	result.setInputAlphabet(fsm.getInputAlphabet());
 	for(auto iter = fsm.getStates().begin(); iter != fsm.getStates().end(); iter++) {
 		result.addState(automaton::State(renamingData.find(*iter)->second));
@@ -76,7 +76,7 @@ automaton::DPDA Rename::rename(const automaton::DPDA& pda) {
 	automaton::DPDA result(automaton::State(renamingDataState.find(pda.getInitialState())->second), alphabet::symbolFrom(renamingDataSymbol.find(pda.getInitialSymbol())->second));
-	result.setInputSymbols(pda.getInputAlphabet());
+	result.setInputAlphabet(pda.getInputAlphabet());
 	for(auto iter = pda.getStackAlphabet().begin(); iter != pda.getStackAlphabet().end(); iter++) {
 		result.addStackSymbol(alphabet::symbolFrom(renamingDataSymbol.find(*iter)->second));

alib2algo/src/automaton/simplify/SingleInitialState.cpp

@@ -41,11 +41,11 @@ automaton::NFA SingleInitialState::convert(const automaton::MultiInitialStateNFA
 	automaton::State q0(label::Label(label::LabelSetLabel(std::move(labelSet))));
 	automaton::NFA res(q0);
-	res.setInputSymbols(automaton.getInputAlphabet());
+	res.setInputAlphabet(automaton.getInputAlphabet());
 	for(const auto& q : automaton.getStates())
 		res.addState(q);
-	// step 2 
+	// step 2
 	for(const auto& q : automaton.getInitialStates()) {
 		for(const auto& kv: automaton.getTransitionsFromState(q)) {
 			for(const auto& to : kv.second) {

alib2algo/src/automaton/transform/PDAToRHPDA.cpp

@@ -34,12 +34,13 @@ automaton::RealTimeHeightDeterministicDPDA PDAToRHPDA::convert( const automaton:
 	RealTimeHeightDeterministicDPDA res(q0, alphabet::Symbol { alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK } );
-	res.setInputSymbols(pda.getInputAlphabet());
-	res.setStates(pda.getStates());
+	res.setInputAlphabet(pda.getInputAlphabet());
+	for(const auto& state : pda.getStates())
+		res.addState(state);
 	res.setFinalStates(pda.getFinalStates());
 	std::set<alphabet::Symbol> stackSymbols = pda.getStackAlphabet();
 	stackSymbols.insert( alphabet::Symbol { alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK } );
-	res.setStackSymbols(stackSymbols);
+	res.setStackAlphabet(stackSymbols);
 	res.addCallTransition(q0, pda.getInitialState(), pda.getInitialSymbol());
@@ -95,12 +96,12 @@ automaton::RealTimeHeightDeterministicDPDA PDAToRHPDA::convert( const automaton:
 automaton::RealTimeHeightDeterministicNPDA PDAToRHPDA::convert( const automaton::NPDA & pda ) {
 	RealTimeHeightDeterministicNPDA res(alphabet::Symbol { alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK } );
-	res.setInputSymbols(pda.getInputAlphabet());
+	res.setInputAlphabet(pda.getInputAlphabet());
 	res.setStates(pda.getStates());
 	res.setFinalStates(pda.getFinalStates());
 	std::set<alphabet::Symbol> stackSymbols = pda.getStackAlphabet();
 	stackSymbols.insert( alphabet::Symbol { alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK } );
-	res.setStackSymbols(stackSymbols);
+	res.setStackAlphabet(stackSymbols);
 	automaton::State q0 = automaton::createUniqueState(automaton::State("q0"), res.getStates());
 	res.addState(q0);

alib2algo/src/automaton/transform/RHPDAToPDA.cpp

@@ -96,9 +96,8 @@ automaton::DPDA RHPDAToPDA::convert( const automaton::RealTimeHeightDeterministi
 	automaton::DPDA res(toState, pushes[0]);
-	res.setInputSymbols(pda.getInputAlphabet());
-	
-	res.setStackSymbols(pda.getStackAlphabet());
+	res.setInputAlphabet(pda.getInputAlphabet());
+	res.setStackAlphabet(pda.getStackAlphabet());
 	res.removeStackSymbol(alphabet::Symbol { alphabet::BottomOfTheStackSymbol::BOTTOM_OF_THE_STACK });
 	for(const auto& st : readingTransitions) {
@@ -217,9 +216,8 @@ automaton::NPDA RHPDAToPDA::convert( const automaton::RealTimeHeightDeterministi
 	automaton::NPDA res(toState, pushes[0]);
-	res.setInputSymbols(pda.getInputAlphabet());
-
-	res.setStackSymbols(pda.getStackAlphabet());
+	res.setInputAlphabet(pda.getInputAlphabet());
+	res.setStackAlphabet(pda.getStackAlphabet());
 	for(const auto& st : readingTransitions) {
 		for(const auto& to : st.second) {

alib2algo/src/automaton/transform/ReverseFSM.cpp

@@ -31,9 +31,8 @@ automaton::MultiInitialStateNFA ReverseFSM::convert(const automaton::DFA& automa
 	res.setStates(automaton.getStates());
 	res.addFinalState(automaton.getInitialState());
-	for(const auto& q : automaton.getFinalStates())
-		res.addInitialState(q);
-	res.setInputSymbols(automaton.getInputAlphabet());
+	res.setInitialStates( automaton.getFinalStates() );
+	res.setInputAlphabet(automaton.getInputAlphabet());
 	for(const auto& t : automaton.getTransitions())
 		res.addTransition(t.second, t.first.second, t.first.first);
@@ -47,9 +46,8 @@ automaton::MultiInitialStateNFA ReverseFSM::convert(const automaton::NFA& automa
 	res.setStates(automaton.getStates());
 	res.addFinalState(automaton.getInitialState());
-	for(const auto& q : automaton.getFinalStates())
-		res.addInitialState(q);
-	res.setInputSymbols(automaton.getInputAlphabet());
+	res.setInitialStates( automaton.getFinalStates() );
+	res.setInputAlphabet(automaton.getInputAlphabet());
 	for(const auto& t : automaton.getTransitions())
 		for(const auto& q : t.second)
@@ -63,11 +61,9 @@ automaton::MultiInitialStateNFA ReverseFSM::convert(const automaton::MultiInitia
 	automaton::MultiInitialStateNFA res;
 	res.setStates(automaton.getStates());
-	for(const auto& q : automaton.getInitialStates())
-		res.addFinalState(q);
-	for(const auto& q : automaton.getFinalStates())
-		res.addInitialState(q);
-	res.setInputSymbols(automaton.getInputAlphabet());
+	res.setFinalStates(automaton.getInitialStates());
+	res.setInitialStates( automaton.getFinalStates() );
+	res.setInputAlphabet(automaton.getInputAlphabet());
 	for(const auto& t : automaton.getTransitions())
 		for(const auto& q : t.second)

alib2algo/src/grammar/convert/ToAutomaton.cpp

@@ -39,7 +39,7 @@ automaton::NFA ToAutomaton::convert(const grammar::LeftRG& grammar)
 	const automaton::State q0 = automaton::createUniqueState(automaton::State("q0"), states);
 	states.insert(q0);
 	automaton::NFA automaton(q0);
-	automaton.setInputSymbols(grammar.getTerminalAlphabet());
+	automaton.setInputAlphabet(grammar.getTerminalAlphabet());
 	automaton.setStates(states);
 	// step 3
@@ -88,7 +88,7 @@ automaton::NFA ToAutomaton::convert(const grammar::RightRG& grammar)
 	automaton::NFA automaton(stateMap.find(grammar.getInitialSymbol())->second);
 	automaton.setStates(states);
-	automaton.setInputSymbols(grammar.getTerminalAlphabet());
+	automaton.setInputAlphabet(grammar.getTerminalAlphabet());
 	// step 3
 	for(const auto& rule : grammar.getRules())

alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp

@@ -90,7 +90,7 @@ automaton::NFA ToAutomatonDerivation::convert(const T& regexp)
 		automaton.addState(r.second);
 	}
-	automaton.setInputSymbols(regexp.getAlphabet());
+	automaton.setInputAlphabet(regexp.getAlphabet());
 	for(const auto& r : Q)
 	{

alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp

@@ -34,8 +34,7 @@ automaton::NFA ToAutomatonGlushkov::convert(const regexp::UnboundedRegExp& regex
 	automaton::NFA automaton( q0 );
 	// step 1
-	for( auto const& symbol : regexp.getAlphabet( ) )
-		automaton.addInputSymbol( symbol );
+	automaton.setInputAlphabet(regexp.getAlphabet());
 	// steps 2, 3, 4
 	std::set<regexp::GlushkovPair> pairs;

alib2algo/src/regexp/convert/ToAutomatonThompson.cpp

@@ -26,7 +26,7 @@ automaton::EpsilonNFA ToAutomatonThompson::convert(const T& regexp)
 	std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> out(automaton::EpsilonNFA(automaton::State(0)), 1, nullptr, nullptr);
 	automaton::EpsilonNFA& automaton = std::get<0>(out);
-	automaton.setInputSymbols(regexp.getAlphabet());
+	automaton.setInputAlphabet(regexp.getAlphabet());
 	regexp.getRegExp().Accept((void*) &out, ToAutomatonThompson::TO_AUTOMATON_THOMPSON);

alib2algo/src/stringology/exact/ExactMatchingAutomaton.cpp

@@ -26,7 +26,7 @@ automaton::Automaton ExactMatchingAutomaton::construct(const string::String& pat
 automaton::NFA ExactMatchingAutomaton::construct(const string::LinearString& pattern) {
 	automaton::NFA res(automaton::State(0));
-	res.setInputSymbols(pattern.getAlphabet());
+	res.setInputAlphabet(pattern.getAlphabet());
 	for(const alphabet::Symbol& symbol : pattern.getAlphabet()) {
 		res.addTransition(automaton::State(0), symbol, automaton::State(0));
 	}

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

@@ -31,7 +31,7 @@ void FSMSingleInitialStateTest::testSingleInitialState() {
 	automaton1.setStates({q0, q1, q2, q3});
 	automaton1.setInitialStates({q0, q1, q2});
 	automaton1.setFinalStates({q3});
-	automaton1.setInputSymbols({a, b});
+	automaton1.setInputAlphabet({a, b});
 	automaton1.addTransition(q0, a, q1);
 	automaton1.addTransition(q1, b, q2);
 	automaton1.addTransition(q2, a, q3);
@@ -41,7 +41,7 @@ void FSMSingleInitialStateTest::testSingleInitialState() {
 	automaton::NFA automaton3(q);
 	automaton3.setStates({q, q1, q2, q3});
 	automaton3.setFinalStates({q3});
-	automaton3.setInputSymbols({a, b});
+	automaton3.setInputAlphabet({a, b});
 	automaton3.addTransition(q, a, q3);
 	automaton3.addTransition(q, b, q2);
 	automaton3.addTransition(q, a, q1);