algo: continue using alphabet generator

alib2algo/src/grammar/generate/RandomGrammarFactory.cpp

 #include "RandomGrammarFactory.h"
 #include <registration/AlgoRegistration.hpp>
-namespace grammar::generate {
-
-namespace {
-	constexpr unsigned ENGLISH_ALPHABET_SIZE = 26;
-}
-
-grammar::CFG < std::string, std::string > grammar::generate::RandomGrammarFactory::generateCFG ( size_t nonterminalsCount, size_t terminalsCount, bool randomizedAlphabet, double density ) {
-	if ( terminalsCount > ENGLISH_ALPHABET_SIZE )
-		throw exception::CommonException("Too big terminals count.");
-
-	ext::deque < std::string > terminals;
-	for ( char i = 'a'; i <= 'z'; i ++ )
-		terminals.push_back ( std::string ( 1, i ) );
-
-	if(randomizedAlphabet)
-		shuffle ( terminals.begin ( ), terminals.end ( ), ext::random_devices::semirandom );
-
-	terminals.resize ( terminalsCount );
-
-	if ( nonterminalsCount > ENGLISH_ALPHABET_SIZE )
-		throw exception::CommonException("Too big nonterminals count.");
-
-	ext::deque < std::string > nonterminals;
-	for ( char i = 'A'; i <= 'Z'; i ++ )
-		nonterminals.push_back ( std::string ( 1, i ) );
-
-	if ( randomizedAlphabet )
-		shuffle ( nonterminals.begin ( ), nonterminals.end ( ), ext::random_devices::semirandom );
-
-	nonterminals.resize ( nonterminalsCount);
-
-	return grammar::generate::RandomGrammarFactory::randomCFG ( nonterminals, terminals, density );
-}
-
-} /* namespace grammar::generate */
-
 namespace {
 auto GenerateCFG1 = registration::AbstractRegister < grammar::generate::RandomGrammarFactory, grammar::CFG < >, ext::set < DefaultSymbolType >, ext::set < DefaultSymbolType >, double > ( grammar::generate::RandomGrammarFactory::generateCFG, abstraction::AlgorithmCategories::AlgorithmCategory::DEFAULT, "nonterminals", "terminals", "density" ).setDocumentation (
@@ -47,13 +11,4 @@ auto GenerateCFG1 = registration::AbstractRegister < grammar::generate::RandomGr
 @param density density of the rule set of the generated grammar\n\
 @return random context free grammar" );
-auto GenerateCFG2 = registration::AbstractRegister < grammar::generate::RandomGrammarFactory, grammar::CFG < std::string, std::string >, size_t, size_t, bool, double> ( grammar::generate::RandomGrammarFactory::generateCFG, abstraction::AlgorithmCategories::AlgorithmCategory::DEFAULT, "nonterminalsCount", "terminalsCount", "randomizedAlphabet", "density" ).setDocumentation (
-"Generates a random context free grammar.\n\
-\n\
-@param nonterminalsCount number of nonterminals in the generated grammar\n\
-@param terminalsSize the number of terminals used in the generated grammar\n\
-@param randomizedAlphabet selects random symbols from a-z range for terminal and A-Z for nonterminal alphabet if true\n\
-@param density density of the rule set of the generated grammar\n\
-@return random context free grammar" );
-
 } /* namespace */

alib2algo/src/grammar/generate/RandomGrammarFactory.h

@@ -33,21 +33,6 @@ public:
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > generateCFG ( ext::set < NonterminalSymbolType > nonterminals, ext::set < TerminalSymbolType > terminals, double density );
-	/**
-	 * Generates a random context free grammar.
-	 *
-	 * \tparam TerminalSymbolType the type of terminal symbols of the random grammar
-	 * \tparam NonterminalSymbolType the type of nonterminal symbols of the random grammar
-	 *
-	 * \param nonterminalsCount number of nonterminals in the generated grammar
-	 * \param terminalsSize the number of terminals used in the generated grammar
-	 * \param randomizedAlphabet selects random symbols from a-z range for terminal and A-Z for nonterminal alphabet if true
-	 * \param density density of the rule set of the generated grammar
-	 *
-	 * \return random context free grammar
-	 */
-	static grammar::CFG < std::string, std::string > generateCFG( size_t nonterminalsCount, size_t terminalsCount, bool randomizedAlphabet, double density );
-
 private:
 	template < class TerminalSymbolType, class NonterminalSymbolType >
 	static grammar::CFG < TerminalSymbolType, NonterminalSymbolType > randomCFG ( const ext::deque < NonterminalSymbolType > & nonterminals, const ext::deque < TerminalSymbolType > & terminals, double density );

alib2algo/src/regexp/generate/RandomRegExpFactory.cpp

@@ -9,35 +9,8 @@
 namespace regexp::generate {
-namespace {
-	constexpr unsigned ENGLISH_ALPHABET_SIZE = 26;
-}
-
-regexp::UnboundedRegExp < std::string > regexp::generate::RandomRegExpFactory::generateUnboundedRegExp( size_t leafNodes, size_t height, size_t alphabetSize, bool randomizedAlphabet ) {
-	if ( alphabetSize > ENGLISH_ALPHABET_SIZE )
-		throw exception::CommonException( "Too big alphabet." );
-
-	if ( alphabetSize <= 0 )
-		throw exception::CommonException( "Alphabet size must be greater than 0." );
-
-	ext::vector < std::string > symbols;
-	for ( char i = 'a'; i <= 'z'; i++ )
-		symbols.push_back ( std::string ( 1, i ) );
-
-	if ( randomizedAlphabet )
-		shuffle ( symbols.begin ( ), symbols.end ( ), ext::random_devices::semirandom );
-
-	ext::set < std::string > alphabet ( symbols.begin ( ), symbols.begin ( ) + alphabetSize );
-
-	return regexp::generate::RandomRegExpFactory::generateUnboundedRegExp ( leafNodes, height, alphabet );
-}
-
 template < class SymbolType >
 regexp::UnboundedRegExp < SymbolType > regexp::generate::RandomRegExpFactory::generateUnboundedRegExp( size_t leafNodes, size_t height, ext::set < SymbolType > alphabet) {
-
-	if ( alphabet.size() > ENGLISH_ALPHABET_SIZE )
-		throw exception::CommonException("Too big alphabet.");
-
 	if( alphabet.empty ( ) )
 		throw exception::CommonException( "Alphabet size must be greater than 0." );
@@ -143,17 +116,3 @@ ext::ptr_value < regexp::UnboundedRegExpElement < SymbolType > > regexp::generat
 }
 } /* namespace regexp::generate */
-
-namespace {
-
-auto GenerateUnboundedRegExp1 = registration::AbstractRegister < regexp::generate::RandomRegExpFactory, regexp::UnboundedRegExp < std::string >, size_t, size_t, size_t, bool > ( regexp::generate::RandomRegExpFactory::generateUnboundedRegExp, abstraction::AlgorithmCategories::AlgorithmCategory::DEFAULT, "leafNodes", "height", "alphabetSize", "randomizedAlphabet" ).setDocumentation (
-"Generates a random regular expression.\n\
-\n\
-@param leafNodes number of leaf nodes in the generated regexp\n\
-@param height the height of the generated regular expression\n\
-@param alphabetSize size of the alphabet (1-26)\n\
-@param randomizedAlphabet selects random symbols from a-z range if true\n\
-\n\
-@return random regular expression" );
-
-} /* namespace */

alib2algo/src/regexp/generate/RandomRegExpFactory.h

@@ -16,18 +16,6 @@ namespace generate {
  */
 class RandomRegExpFactory {
 public:
-	/**
-	 * Generates a random regular expression.
-	 *
-	 * \param leafNodes number of leaf nodes in the generated regexp
-	 * \param height the height of the generated regular expression
-	 * \param alphabetSize size of the alphabet (1-26)
-	 * \param randomizedAlphabet selects random symbols from a-z range if true
-	 *
-	 * \return random regular expression
-	 */
-	static regexp::UnboundedRegExp < std::string > generateUnboundedRegExp( size_t leafNodes, size_t height, size_t alphabetSize, bool randomizedAlphabet );
-
 	/**
 	 * Generates a random regular expression.
 	 *

tests/cppaql/normalizeTest.cpp

@@ -13,7 +13,7 @@ static constexpr size_t RANDOM_ITERATIONS = 50;
 std::string qGenerateCfg ( const std::string & var ) {
-	return ext::concat ( "execute grammar::generate::RandomGrammarFactory (int) ", rand ( ) % RAND_NONTERMINALS + 1, " (int) ", rand ( ) % RAND_TERMINALS + 1, " (bool) true (double) ", RAND_DENSITY, " | grammar::simplify::EpsilonRemover - | grammar::simplify::SimpleRulesRemover - > $", var );
+	return ext::concat ( "execute grammar::generate::RandomGrammarFactory <(alphabet::generate::GenerateAlphabet (int) ", rand ( ) % RAND_NONTERMINALS + 1, " true false) <(alphabet::generate::GenerateAlphabet (int) ", rand ( ) % RAND_TERMINALS + 1, " true true) (double) ", RAND_DENSITY, " | grammar::simplify::EpsilonRemover - | grammar::simplify::SimpleRulesRemover - > $", var );
 }
 TEST_CASE ( "Normalize test", "[integration]" ) {

tests/cppaql/regexpOptimizeTest.cpp

@@ -11,7 +11,7 @@ const double   ALPHABET_SIZE  = 2;
 const size_t   ITERATIONS = 100;
 std::string qGenRE ( ) {
-	return ext::concat ( "execute regexp::generate::RandomRegExpFactory (size_t)", rand ( ) % LEAF_NODES + 1, " (size_t)", rand ( ) % HEIGHT + 1, " (size_t)", ALPHABET_SIZE, " (bool)false" );
+	return ext::concat ( "execute regexp::generate::RandomRegExpFactory (size_t)", rand ( ) % LEAF_NODES + 1, " (size_t)", rand ( ) % HEIGHT + 1, "<(alphabet::generate::GenerateAlphabet (size_t)", ALPHABET_SIZE, " false false)" );
 }
 TEST_CASE ( "RE optimize test", "[integration]" ) {