def from_dict(rule_dict):
left = Symbol.from_dict(rule_dict['left'])
right1 = Symbol.from_dict(rule_dict['right1'])
right2 = None
if rule_dict['right2'] is not None:
right2 = Symbol.from_dict(rule_dict['right2'])
return sRule([left, right1, right2])
def setUp(self):
self.genetic_selection = _GeneticSelection()
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
self.rule_2 = Rule([self.symbol_B, self.symbol_x, self.symbol_C])
self.rule_3 = Rule([self.symbol_C, self.symbol_B, self.symbol_y])
self.rule_4 = Rule([self.symbol_D, self.symbol_D, self.symbol_C])
self.rule_5 = Rule([self.symbol_E, self.symbol_w])
self.rule_1.fitness = 9
self.rule_2.fitness = 12
self.rule_3.fitness = 15
self.rule_4.fitness = 6
self.rule_5.fitness = 3
self.rules = {self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5}
self.rules_list = [self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5]
def setUp(self):
self.symbols = [
Symbol("A", SymbolType.ST_TERMINAL),
Symbol("B", SymbolType.ST_UNIVERSAL),
Symbol("C", SymbolType.ST_NON_TERMINAL),
Symbol("D", SymbolType.ST_START)
]
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = NakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
self.rule_2 = Rule([self.symbol_B, self.symbol_x, self.symbol_C])
self.rule_3 = Rule([self.symbol_C, self.symbol_B, self.symbol_y])
self.rule_4 = Rule([self.symbol_D, self.symbol_D, self.symbol_C])
self.rule_5 = Rule([self.symbol_E, self.symbol_w])
self.rule_6 = Rule([self.symbol_E, self.symbol_D])
self.rules = [
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5,
self.rule_6
]
def setUp(self):
iteration = Iteration()
self.covering = StartStandardCovering()
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([self.left_symbol, self.first_right_symbol])
def __create_rule(symbols, fitness: float = None) -> Rule:
symbols = [Symbol(symbols[0], SymbolType.ST_NON_TERMINAL),
Symbol(symbols[1], SymbolType.ST_TERMINAL),
Symbol(symbols[2], SymbolType.ST_TERMINAL)]
rule = Rule(symbols)
if fitness:
rule.fitness = fitness
return rule
def setUp(self):
iteration = Iteration()
self.covering = StartCoveringPlus()
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = sRule.from_symbols(0.5, self.left_symbol,
self.first_right_symbol)
def __create_terminal_symbols__(self):
terminal_symbols = []
symbol_one = Symbol("o", SymbolType.ST_TERMINAL)
symbol_two = Symbol("t", SymbolType.ST_TERMINAL)
symbol_three = Symbol("s", SymbolType.ST_TERMINAL)
terminal_symbols.append(symbol_one)
terminal_symbols.append(symbol_two)
terminal_symbols.append(symbol_three)
return terminal_symbols
def __create_non_terminal_symbols(self):
non_terminal_symbols = []
symbol_one = Symbol("a", SymbolType.ST_NON_TERMINAL)
symbol_two = Symbol("b", SymbolType.ST_NON_TERMINAL)
symbol_three = Symbol("c", SymbolType.ST_NON_TERMINAL)
non_terminal_symbols.append(symbol_one)
non_terminal_symbols.append(symbol_two)
non_terminal_symbols.append(symbol_three)
return non_terminal_symbols
def setUp(self):
self.roulette_selection = RouletteSelection()
self.symbol_a = Symbol('a', SymbolType.ST_TERMINAL)
self.symbol_b = Symbol('b', SymbolType.ST_TERMINAL)
self.symbol_c = Symbol('c', SymbolType.ST_TERMINAL)
self.symbol_d = Symbol('d', SymbolType.ST_TERMINAL)
self.symbol_e = Symbol('e', SymbolType.ST_TERMINAL)
self.wheel_sections = [45, 30, 18, 9, 3]
self.symbol_statistics = [(self.symbol_a, 15), (self.symbol_b, 12), (self.symbol_c, 9), (self.symbol_d, 6),
(self.symbol_e, 3)]
def test_filter_non_terminal_to_terminal_terminal_rule(self):
symbols = [Symbol('x', SymbolType.ST_TERMINAL),
Symbol('y', SymbolType.ST_NON_TERMINAL),
Symbol('z', SymbolType.ST_NON_TERMINAL)]
rule = Rule(symbols)
result = self.crowding.filter_non_terminal_to_terminal_terminal_rule(self.rules)
self.assertEqual(result, set())
result = self.crowding.filter_non_terminal_to_terminal_terminal_rule(self.rules + [rule])
self.assertEqual(result, {rule})
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveNakamuraCovering(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.rule_1 = Rule([self.symbol_A, self.symbol_B, self.symbol_C])
def setUp(self):
iteration = Iteration()
self.crowding = Crowding()
self.crowding.set_iteration(iteration)
self.covering = FinalCoveringPlus(self.crowding)
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.second_right_symbol = Symbol('b', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = sRule.from_symbols(0.5, self.left_symbol,
self.first_right_symbol,
self.second_right_symbol)
def setUp(self):
iteration = Iteration()
self.crowding = Crowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveStandardCovering(self.crowding)
self.covering.set_iteration(iteration)
self.grammar = Grammar()
self.first_right_symbol = Symbol('a', SymbolType.ST_TERMINAL)
self.second_right_symbol = Symbol('b', SymbolType.ST_TERMINAL)
self.left_symbol = Symbol('x', SymbolType.ST_TERMINAL)
self.rule = Rule([
self.left_symbol, self.first_right_symbol, self.second_right_symbol
])
def setUp(self):
iteration = Iteration()
self.crowding = StandardCrowding()
self.crowding.set_iteration(iteration)
self.covering = AggressiveSmartCoveringWithTabu(self.crowding)
self.covering.set_iteration(iteration)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.statistics = {self.symbol_A: 3, self.symbol_B: 7}
def test_get_random_nonterminal_symbol_from(self):
grammar = Grammar()
symbol_1 = Symbol('a', SymbolType.ST_TERMINAL)
symbol_2 = Symbol('b', SymbolType.ST_TERMINAL)
grammar.nonTerminalSymbols = [symbol_1, symbol_2]
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertIsNotNone(result)
self.assertEqual(2, len(grammar.nonTerminalSymbols))
grammar.nonTerminalSymbols = []
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertIsNone(result)
grammar.nonTerminalSymbols = [symbol_1, symbol_2]
random.choice = MagicMock(return_value=symbol_1)
result = RandomUtils.get_random_nonterminal_symbol_from(grammar)
self.assertEqual(result, symbol_1)
def setUp(self):
self.genetic_algorithm = GeneticAlgorithm(Crowding(), None)
self.grammar = Grammar()
self.symbol_v = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_w = Symbol('w', SymbolType.ST_TERMINAL)
self.symbol_x = Symbol('x', SymbolType.ST_TERMINAL)
self.symbol_y = Symbol('y', SymbolType.ST_TERMINAL)
self.symbol_z = Symbol('z', SymbolType.ST_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('C', SymbolType.ST_NON_TERMINAL)
self.symbol_D = Symbol('D', SymbolType.ST_NON_TERMINAL)
self.symbol_E = Symbol('E', SymbolType.ST_NON_TERMINAL)
self.rule_1 = sRule.from_symbols(0.1, self.symbol_A, self.symbol_B,
self.symbol_C)
self.rule_2 = sRule.from_symbols(0.5, self.symbol_B, self.symbol_x,
self.symbol_C)
self.rule_3 = sRule.from_symbols(0.4, self.symbol_C, self.symbol_B,
self.symbol_y)
self.rule_4 = sRule.from_symbols(0.9, self.symbol_D, self.symbol_D,
self.symbol_C)
self.rule_5 = sRule.from_symbols(0.2, self.symbol_E, self.symbol_w)
self.rule_1.fitness = 9
self.rule_2.fitness = 12
self.rule_3.fitness = 15
self.rule_4.fitness = 6
self.rule_5.fitness = 3
self.rules = {
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
}
self.rules_list = [
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
]
self.grammar.get_non_terminal_rules = MagicMock(
return_value=self.rules)
self.random_decision = RandomUtils.make_random_decision_with_probability
self.random_non_terminal = RandomUtils.get_random_nonterminal_symbol_from
def test_symbol_sentence_init(self):
symbol1 = Symbol("I")
symbol2 = Symbol(" ")
symbol3 = Symbol("l")
symbol4 = Symbol("i")
symbol5 = Symbol("k")
symbol6 = Symbol("e")
symbols = [symbol1, symbol2, symbol3, symbol4, symbol5, symbol6]
sentence = "I like you"
grammar = Grammar()
grammar.nonTerminalSymbols = symbols
self.cyk_base = CYKBase()
self.cyk_base.grammar = grammar
self.cyk_base.symbols = symbols
self.cyk_base._init_symbol_sequence(sentence)
sequence = self.cyk_base.sequence
self.assertEqual(symbol1, sequence[0])
self.assertEqual(symbol2, sequence[1])
self.assertEqual(symbol3, sequence[2])
self.assertEqual(symbol4, sequence[3])
self.assertEqual(symbol5, sequence[4])
self.assertEqual(symbol6, sequence[5])
self.assertEqual(symbol2, sequence[6])
self.assertEqual(None, sequence[7])
self.assertEqual(None, sequence[8])
self.assertEqual(None, sequence[9])
pass
def __create_non_terminal_symbols(self):
return [
Symbol('a', SymbolType.ST_NON_TERMINAL),
Symbol('b', SymbolType.ST_NON_TERMINAL),
Symbol('c', SymbolType.ST_NON_TERMINAL),
Symbol('d', SymbolType.ST_NON_TERMINAL),
Symbol('e', SymbolType.ST_NON_TERMINAL),
Symbol('f', SymbolType.ST_NON_TERMINAL),
]
def test_find_symbol_by_value(self):
value = 'c'
symbol = self.grammar.find_symbol_by_value(value)
self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL))
def test_should_not_find_non_terminal_symbol_index(self):
symbol = Symbol("d", SymbolType.ST_NON_TERMINAL)
index = self.grammar.find_non_terminal_symbol_index(symbol)
self.assertEqual(index, -1)
def test_should_find_symbol_by_index_5(self):
index = 5
symbol = self.grammar.find_symbol_by_given_index(index)
self.assertEqual(symbol, Symbol("c", SymbolType.ST_NON_TERMINAL))
def test_should_find_third_non_terminal_symbol(self):
symbol = Symbol("c")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 5)
class TestSymbol(unittest.TestCase):
def setUp(self):
self.symbol = Symbol()
def test_is_terminal(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.assertTrue(self.symbol.is_terminal())
def test_is_terminal_failure(self):
self.symbol.symbol_type = SymbolType.ST_UNIVERSAL
self.assertFalse(self.symbol.is_terminal())
def test_is_non_terminal(self):
self.symbol.symbol_type = SymbolType.ST_NON_TERMINAL
self.assertTrue(self.symbol.is_non_terminal())
def test_is_non_terminal_failure(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.assertFalse(self.symbol.is_non_terminal())
def test_is_start(self):
self.symbol.symbol_type = SymbolType.ST_START
self.assertTrue(self.symbol.is_start())
def test_is_start_failure(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.assertFalse(self.symbol.is_start())
def test_is_universal(self):
self.symbol.symbol_type = SymbolType.ST_UNIVERSAL
self.assertTrue(self.symbol.is_universal())
def test_is_universal_failure(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.assertFalse(self.symbol.is_universal())
def test_two_symbols_equality(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
other_symbol = Symbol("a", SymbolType.ST_TERMINAL)
self.assertEqual(self.symbol, other_symbol)
def test_two_symbols_not_equal(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
other_symbol = Symbol("c", SymbolType.ST_UNIVERSAL)
self.assertNotEqual(self.symbol, other_symbol)
def test_two_symbols_not_equal_different_types(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
other_symbol = Symbol("a", SymbolType.ST_NON_TERMINAL)
self.assertNotEqual(self.symbol, other_symbol)
def test_two_symbols_not_equal_different_values(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
other_symbol = Symbol("b", SymbolType.ST_TERMINAL)
self.assertNotEqual(self.symbol, other_symbol)
def test_conversion_to_string(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
self.assertEqual(str(self.symbol), "a")
def test_two_symbols_not_equal_different_values(self):
self.symbol.symbol_type = SymbolType.ST_TERMINAL
self.symbol.value = "a"
other_symbol = Symbol("b", SymbolType.ST_TERMINAL)
self.assertNotEqual(self.symbol, other_symbol)
def test_should_find_second_terminal_symbol(self):
symbol = Symbol("t")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, 1)
def test_should_not_find_symbol_index(self):
symbol = Symbol("d")
symbol_idx = self.grammar.symbol_index(symbol)
self.assertEqual(symbol_idx, -1)
def setUp(self):
self.symbol = Symbol()
def setUp(self):
self.left = Symbol("S", SymbolType.ST_START)
self.rightTerminal = Symbol("R", SymbolType.ST_TERMINAL)
self.leftTerminal = Symbol("L", SymbolType.ST_TERMINAL)
self.leftNonTerminal = Symbol("L", SymbolType.ST_NON_TERMINAL)
self.rightNonTerminal = Symbol("R", SymbolType.ST_NON_TERMINAL)
def setUp(self):
settings = MagicMock()
settings.get_value = MagicMock(
side_effect=["TERMINALS", 0.5, 1.0, 1.0, 1.0, 1.0])
self.grammar = Grammar(settings)
self.symbol_a = Symbol('a', SymbolType.ST_TERMINAL)
self.symbol_S = Symbol('S', SymbolType.ST_NON_TERMINAL)
self.symbol_A = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_B = Symbol('B', SymbolType.ST_NON_TERMINAL)
self.symbol_C = Symbol('A', SymbolType.ST_NON_TERMINAL)
self.symbol_A1 = Symbol('A1', SymbolType.ST_NON_TERMINAL)
self.symbol_A2 = Symbol('A2', SymbolType.ST_NON_TERMINAL)
self.rule_1 = sRule.from_symbols(0.1, self.symbol_S, self.symbol_A,
self.symbol_B)
self.rule_2 = sRule.from_symbols(0.5, self.symbol_A, self.symbol_A,
self.symbol_B)
self.rule_3 = sRule.from_symbols(0.4, self.symbol_A, self.symbol_a)
self.rule_4 = sRule.from_symbols(0.9, self.symbol_B, self.symbol_B,
self.symbol_B)
self.rule_5 = sRule.from_symbols(0.2, self.symbol_B, self.symbol_a)
self.rules = {
self.rule_1, self.rule_2, self.rule_3, self.rule_4, self.rule_5
}
self.non_terminal_rules = {self.rule_1, self.rule_2, self.rule_4}
self.terminal_rules = {self.rule_3, self.rule_5}
self.grammar.rulesContainer.terminal_rules = self.terminal_rules
self.grammar.rulesContainer.non_terminal_rules = self.non_terminal_rules
self.grammar.rulesContainer.rules = self.rules
self.grammar.get_rules = MagicMock(return_value=self.rules)
self.grammar.get_non_terminal_rules = MagicMock(
return_value=self.non_terminal_rules)
settings.get_value = MagicMock(
side_effect=['RANDOM', 'False', 0.5, 20])
self.split_and_merge = SplitAndMerge(settings)
self.split_and_merge.iteration.add_rule = MagicMock()
self.split_and_merge.iteration.remove_crowding_rule = MagicMock()
self.merge_result = {
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A,
self.symbol_A),
sRule.from_symbols(0.1, self.symbol_A, self.symbol_A,
self.symbol_A),
sRule.from_symbols(0.1, self.symbol_A, self.symbol_a)
}
self.split_result = {
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_S, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A2,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_A1,
self.symbol_B),
sRule.from_symbols(0.1, self.symbol_A1, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_A2, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_B, self.symbol_a),
sRule.from_symbols(0.1, self.symbol_B, self.symbol_B,
self.symbol_B),
}
