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 __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 add_rule(self, rule: Rule): if (self.aaa_rules_handling_type is not AaaRulesHandlingType.NO_AAA_RULES or not rule.is_non_terminal_to_terminal_terminal_rule()) and \ rule not in self.forbidden_rules: self.rules.add(rule) if rule.is_terminal(self.aaa_rules_handling_type): self.terminal_rules.add(rule) else: self.non_terminal_rules.add(rule)
def add_new_rule(self, grammar: Grammar, first_symbol: Symbol, second_symbol: Symbol = None) -> Rule: new_rule = Rule([grammar.get_start_symbol(), first_symbol]) new_rule.origin = RuleOrigin.COVERING grammar.add_rule(new_rule) self.iteration.add_covering_rule(new_rule) return new_rule
def test_rule_is_effective(self): grammar = Grammar() grammar.get_rules = MagicMock(return_value=self.rules) rule = Rule([self.symbol_C, self.symbol_B, self.symbol_x]) result = self.covering.rule_is_effective(grammar, rule.left) self.assertTrue(result) rule = Rule([self.symbol_E, self.symbol_B, self.symbol_x]) result = self.covering.rule_is_effective(grammar, rule.left) self.assertFalse(result)
def add_new_rule(self, grammar: Grammar, first_symbol: Symbol, second_symbol: Symbol = None) -> Rule: new_rule = Rule([ RandomUtils.get_random_nonterminal_symbol_from(grammar), first_symbol, second_symbol ]) new_rule.origin = RuleOrigin.COVERING self.crowding.add_rule(grammar, new_rule) self.iteration.add_covering_rule(new_rule) return new_rule
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 mutate(self, rule: Rule, grammar: Grammar) -> 'MutationReport': report = MutationReport() left = self.mutate_symbol(rule.left, grammar) report.was_left_symbol_mutated = (left == rule.left) right1 = self.mutate_symbol(rule.right1, grammar) report.was_first_right_symbol_mutated = (right1 == rule.right1) right2 = self.mutate_symbol(rule.right2, grammar) report.was_second_right_symbol_mutated = (right2 == rule.right2) rule.left, rule.right1, rule.right2 = left, right1, right2 return report
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 = 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.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 test_descriptions_generation(self): rule = Rule([self.left, self.rightTerminal]) rule.fitness = 1 rule.profit = 2 rule.usages_in_invalid_parsing = 3 rule.usages_in_proper_parsing = 4 rule.debt = 5 rule.age = 6 descriptions = RulesService.get_description_string_for_rule(rule) self.assertEqual(descriptions[0], "fitness (f): 1") self.assertEqual(descriptions[1], "proper usages (u_p): 4") self.assertEqual(descriptions[2], "invalid usages (u_n): 3") self.assertEqual(descriptions[3], "profit (p): 2") self.assertEqual(descriptions[4], "debt (d): 5") self.assertEqual(descriptions[5], "age: 6")
def test_count_group_similarity(self): RulesService.similarities_between_rules = MagicMock(side_effect=[32, 16, 64, 8, 4]) result = self.crowding.count_group_similarity(Rule(), self.rules) self.assertEqual(result, 124)
def test_rule_equality(self): rule = Rule([self.left, self.rightTerminal]) rule2 = Rule([self.left, self.rightTerminal]) self.assertEqual(rule, rule2)
def test_rule_not_equal_different_types(self): rule = Rule([self.left, self.rightTerminal]) rule2 = Rule([self.left, self.rightNonTerminal]) self.assertNotEqual(rule, rule2)
def test_is_non_terminal_to_terminal_terminal_rule(self): rule = Rule([self.left, self.rightTerminal, self.rightTerminal]) self.assertTrue(rule.is_non_terminal_to_terminal_terminal_rule())
def test_is_non_terminal_to_terminal_terminal_rule_failure(self): rule = Rule([self.left, self.rightTerminal]) self.assertFalse(rule.is_non_terminal_to_terminal_terminal_rule())
def test_is_non_terminal_two_right_symbols(self): rule = Rule([self.left, self.leftNonTerminal, self.rightNonTerminal]) self.assertTrue(rule.is_non_terminal())
def test_is_start(self): rule = Rule([self.left, self.rightTerminal]) self.assertTrue(rule.is_start())
def test_rules_similar_three_points(self): rule = Rule([self.left, self.rightNonTerminal, self.rightTerminal]) rule2 = Rule([self.left, self.rightNonTerminal, self.rightTerminal]) similarities = RulesService.similarities_between_rules(rule, rule2) self.assertEqual(similarities, 3)
def invert_rule(self, rule: Rule) -> None: if rule.right2: rule.right1, rule.right2 = rule.right2, rule.right1
def test_sort_rules_used_in_invalid_parsing(self): rules_container = RulesContainer() rule1 = Rule() rule1.usages_in_invalid_parsing = 1 rule1.fitness = 0.3 rule2 = Rule() rule2.usages_in_invalid_parsing = 2 rule2.fitness = 0.29 rule3 = Rule() rule3.usages_in_invalid_parsing = 3 rule3.fitness = 0.28 rule4 = Rule() rule4.usages_in_invalid_parsing = 4 rule4.fitness = 0.27 rule5 = Rule() rule5.usages_in_invalid_parsing = 5 rule5.fitness = 0.26 rule6 = Rule() rule6.usages_in_invalid_parsing = 6 rule6.fitness = 0.25 invalid_parsing_rules = [rule1, rule2, rule3, rule4, rule5, rule6] sorted_rules = rules_container.sort_rules_used_in_invalid_parsing( invalid_parsing_rules) self.assertEqual(sorted_rules[0].fitness, rule6.fitness) self.assertEqual(sorted_rules[1].fitness, rule5.fitness) self.assertEqual(sorted_rules[2].fitness, rule4.fitness) self.assertEqual(sorted_rules[3].fitness, rule3.fitness) self.assertEqual(sorted_rules[4].fitness, rule2.fitness) self.assertEqual(sorted_rules[5].fitness, rule1.fitness)
def get_rule_rand_non_terminal_rule(left: Symbol, right1: Symbol, right2: Symbol): return Rule([left, right1, right2])
def test_select_rules_not_used_in_parsing(self): rules_container = RulesContainer() rule1 = Rule() rule1.usages_in_invalid_parsing = 1 rule2 = Rule() rule2.usages_in_invalid_parsing = 0 rule3 = Rule() rule3.usages_in_invalid_parsing = 0 rule4 = Rule() rule4.usages_in_invalid_parsing = 0 rule5 = Rule() rule5.usages_in_invalid_parsing = 2 rule6 = Rule() rule6.usages_in_invalid_parsing = 3 non_terminal_rules = [rule1, rule2, rule3, rule4, rule5, rule6] rules_container.non_terminal_rules = non_terminal_rules invalid_usages_rules = rules_container.select_rules_used_in_invalid_parsing( ) self.assertEqual(len(invalid_usages_rules), 3) self.assertEqual(invalid_usages_rules[0].usages_in_invalid_parsing, rule1.usages_in_invalid_parsing) self.assertEqual(invalid_usages_rules[1].usages_in_invalid_parsing, rule5.usages_in_invalid_parsing) self.assertEqual(invalid_usages_rules[2].usages_in_invalid_parsing, rule6.usages_in_invalid_parsing)