def test_least_revision(self): eprint(">> ACEDIA.least_revision(rule, state_1, state_2)") for i in range(self.__nb_unit_test): variables, domains = self.random_system() state_1 = self.random_state(variables, domains) state_2 = self.random_state(variables, domains) # not matching #-------------- rule = self.random_rule(variables, domains) while rule.matches(state_1): rule = self.random_rule(variables, domains) self.assertRaises(ValueError, ACEDIA.least_revision, rule, state_1, state_2) # matching #-------------- rule = self.random_rule(variables, domains) while not rule.matches(state_1): rule = self.random_rule(variables, domains) head_var = rule.get_head_variable() target_val = state_2[rule.get_head_variable()] # Consistent head_value = Continuum() while not head_value.includes(target_val): head_value = Continuum.random( domains[head_var].get_min_value(), domains[head_var].get_max_value()) rule.set_head_value(head_value) self.assertRaises(ValueError, ACEDIA.least_revision, rule, state_1, state_2) # Empty set head rule.set_head_value(Continuum()) LR = ACEDIA.least_revision(rule, state_1, state_2) lg = rule.copy() lg.set_head_value(Continuum(target_val, target_val, True, True)) self.assertTrue(lg in LR) nb_valid_revision = 1 for var, val in rule.get_body(): state_value = state_1[var] # min rev ls = rule.copy() new_val = val.copy() new_val.set_lower_bound(state_value, False) if not new_val.is_empty(): ls.set_condition(var, new_val) self.assertTrue(ls in LR) nb_valid_revision += 1 # max rev ls = rule.copy() new_val = val.copy() new_val.set_upper_bound(state_value, False) if not new_val.is_empty(): ls.set_condition(var, new_val) self.assertTrue(ls in LR) nb_valid_revision += 1 self.assertEqual(len(LR), nb_valid_revision) #eprint(nb_valid_revision) # usual head head_value = Continuum.random(domains[head_var].get_min_value(), domains[head_var].get_max_value()) while head_value.includes(target_val): head_value = Continuum.random( domains[head_var].get_min_value(), domains[head_var].get_max_value()) rule.set_head_value(head_value) LR = ACEDIA.least_revision(rule, state_1, state_2) lg = rule.copy() head_value = lg.get_head_value() if target_val <= head_value.get_min_value(): head_value.set_lower_bound(target_val, True) else: head_value.set_upper_bound(target_val, True) lg.set_head_value(head_value) self.assertTrue(lg in LR) nb_valid_revision = 1 for var, val in rule.get_body(): state_value = state_1[var] # min rev ls = rule.copy() new_val = val.copy() new_val.set_lower_bound(state_value, False) if not new_val.is_empty(): ls.set_condition(var, new_val) self.assertTrue(ls in LR) nb_valid_revision += 1 # max rev ls = rule.copy() new_val = val.copy() new_val.set_upper_bound(state_value, False) if not new_val.is_empty(): ls.set_condition(var, new_val) self.assertTrue(ls in LR) nb_valid_revision += 1 self.assertEqual(len(LR), nb_valid_revision)
def test_includes(self): eprint(">> Continuum.includes(self, element)") for i in range(self.__nb_unit_test): # bad argument type c = Continuum.random(self.__min_value, self.__max_value) self.assertRaises(TypeError, c.includes, "test") # float argument #---------------- # empty set includes nothing c = Continuum() value = random.uniform(self.__min_value, self.__max_value) self.assertFalse(c.includes(value)) c = Continuum.random(self.__min_value, self.__max_value) # Before min value = c.get_min_value() while value == c.get_min_value(): value = random.uniform(c.get_min_value() - 100.0, c.get_min_value()) self.assertFalse(c.includes(value)) # on min bound self.assertEqual(c.includes(c.get_min_value()), c.min_included()) # Inside value = c.get_min_value() while value == c.get_min_value() or value == c.get_max_value(): value = random.uniform(c.get_min_value(), c.get_max_value()) self.assertTrue(c.includes(value)) # on max bound self.assertEqual(c.includes(c.get_max_value()), c.max_included()) # after max bound value = c.get_max_value() while value == c.get_max_value(): value = random.uniform(c.get_max_value(), c.get_max_value() + 100.0) self.assertFalse(c.includes(value)) # int argument #-------------- # empty set includes nothing c = Continuum() value = random.randint(int(self.__min_value), int(self.__max_value)) self.assertFalse(c.includes(value)) c = Continuum.random(self.__min_value, self.__max_value) while int(c.get_max_value()) - int(c.get_min_value()) <= 1: min = random.uniform(self.__min_value, self.__max_value) max = random.uniform(min, self.__max_value) c = Continuum.random(min, max) #eprint(c.to_string()) # Before min value = random.randint(int(c.get_min_value() - 100), int(c.get_min_value()) - 1) self.assertFalse(c.includes(value)) # on min bound self.assertEqual(c.includes(c.get_min_value()), c.min_included()) # Inside value = random.randint( int(c.get_min_value()) + 1, int(c.get_max_value()) - 1) #eprint(value) self.assertTrue(c.includes(value)) # on max bound self.assertEqual(c.includes(c.get_max_value()), c.max_included()) # after max bound value = random.randint( int(c.get_max_value()) + 1, int(c.get_max_value() + 100)) self.assertFalse(c.includes(value)) # continuum argument #-------------------- # 0) c is empty set c = Continuum() c_ = Continuum() self.assertTrue(c.includes(c_)) # empty set VS empty set c_ = Continuum.random(self.__min_value, self.__max_value) while c_.is_empty(): c_ = Continuum.random(self.__min_value, self.__max_value) self.assertFalse(c.includes(c_)) # empty set VS non empty # 1) c is non empty c = Continuum.random(self.__min_value, self.__max_value) self.assertTrue(c.includes(Continuum())) # non empty VS empty set self.assertTrue(c.includes(c)) # includes itself # 1.1) Lower bound over c_ = Continuum.random(c.get_min_value(), self.__max_value) while c_.is_empty(): c_ = Continuum.random(c.get_min_value(), self.__max_value) value = c.get_min_value() while value == c.get_min_value(): value = random.uniform(c.get_min_value() - 100, c.get_min_value()) c_.set_lower_bound(value, random.choice([True, False])) self.assertFalse(c.includes(c_)) # 1.2) on min bound c_ = Continuum.random(c.get_min_value(), self.__max_value) while c_.is_empty(): c_ = Continuum.random(c.get_min_value(), self.__max_value) c_.set_lower_bound(c.get_min_value(), random.choice([True, False])) if not c.min_included() and c_.min_included(): # one value over self.assertFalse(c.includes(c_)) # 1.3) upper bound over c_ = Continuum.random(self.__min_value, c.get_max_value()) while c_.is_empty(): c_ = Continuum.random(self.__min_value, c.get_max_value()) value = c.get_max_value() while value == c.get_max_value(): value = random.uniform(c.get_max_value(), c.get_max_value() + 100) c_.set_upper_bound(value, random.choice([True, False])) self.assertFalse(c.includes(c_)) # 1.4) on upper bound c_ = Continuum.random(self.__min_value, c.get_max_value()) while c_.is_empty(): c_ = Continuum.random(self.__min_value, c.get_max_value()) c_.set_upper_bound(c.get_max_value(), random.choice([True, False])) if not c.max_included() and c_.max_included(): # one value over self.assertFalse(c.includes(c_)) # 1.5) inside min = c.get_min_value() while min == c.get_min_value(): min = random.uniform(c.get_min_value(), c.get_max_value()) max = c.get_max_value() while max == c.get_max_value(): max = random.uniform(min, c.get_max_value()) c_ = Continuum(min, max, random.choice([True, False]), random.choice([True, False])) self.assertTrue(c.includes(c_)) self.assertFalse(c_.includes(c))
def random(variables, domains, rule_min_size, rule_max_size, epsilon, delay=1): """ Generate a epsilon-complete ContinuumLogicProgram with a random dynamics. For each variable of the system, each possible epsilon state of the system is matched by at least one rule. Args: variables: list of String variables of the represented system domains: list of Continuum domain of values that each variable can take rule_min_size: int minimal number of conditions in each rule rule_max_size: int maximal number of conditions in each rule epsilon: float in ]0,1] precision of the completness of the program delay: int maximal delay of the conditions of each rule Returns: ContinuumLogicProgram an epsilon-complete CLP with a random dynamics """ #eprint("Start random CLP generation: var ", len(variables), " delay: ", delay) extended_variables = variables.copy() extended_domains = domains.copy() # Delayed logic program: extend local herbrand base if delay > 1: for d in range(1,delay): extended_variables += [var+"_"+str(d) for var in variables] extended_domains += domains rules = [] states = ContinuumLogicProgram.states(extended_domains, epsilon) # aggregated reversed time serie of size delay for s in states: #eprint(s) for var in range(len(variables)): matching = False for r in rules: # check if matched if r.get_head_variable() == var and r.matches(s): matching = True break if not matching: # need new rule val = Continuum() while val.is_empty(): # Enumerate each possible value min = domains[var].get_min_value() max = domains[var].get_max_value() step = epsilon * (max - min) values = [min+(step*i) for i in range( int(1.0 / epsilon) )] if values[-1] != max: values.append(max) min = random.choice(values) max = random.choice(values) while min > max: min = random.choice(values) max = random.choice(values) val = Continuum(min, max, random.choice([True,False]), random.choice([True,False])) body_size = random.randint(rule_min_size, rule_max_size) new_rule = ContinuumRule(var, val, []) # Prevent cross-match # not necessarry, since next(state) assume determinism # Complete the rule body if needed while (new_rule.size() < body_size): # create body cond_var = random.randint(0, len(s)-1) if new_rule.has_condition(cond_var): continue # Enumerate each possible value min = extended_domains[cond_var].get_min_value() max = extended_domains[cond_var].get_max_value() step = epsilon * (max - min) values = [min+(step*i) for i in range( int(1.0 / epsilon) )] if values[-1] != max: values.append(max) cond_val = Continuum() while not cond_val.includes(s[cond_var]): min = random.choice(values) max = random.choice(values) while min > max: min = random.choice(values) max = random.choice(values) cond_val = Continuum(min, max, random.choice([True,False]), random.choice([True,False])) new_rule.set_condition(cond_var, cond_val) rules.append(new_rule) return ContinuumLogicProgram(variables, domains, rules)