def test_to_string(self): eprint(">> Continuum.to_string(self)") for i in range(self.__nb_unit_test): c = Continuum() self.assertEqual(c.to_string(), u"\u2205") c = Continuum.random(self.__min_value, self.__max_value) if c.is_empty(): self.assertEqual(c.to_string(), u"\u2205") out = "" if c.min_included(): out += "[" else: out += "]" out += str(c.get_min_value()) + "," + str(c.get_max_value()) if c.max_included(): out += "]" else: out += "[" self.assertEqual(c.to_string(), out) self.assertEqual(c.__str__(), out) self.assertEqual(c.__repr__(), out)
def random_system(self): # generates variables/domains nb_variables = random.randint(1, self.__max_variables) variables = ["x"+str(var) for var in range(nb_variables)] domains = [ Continuum.random(self.__min_value, self.__max_value, self.__min_domain_size) for var in variables ] return variables, domains
def random_rule(self, variables, domains): var = random.randint(0,len(variables)-1) var_domain = domains[var] val = Continuum.random(var_domain.get_min_value(), var_domain.get_max_value(), self.__min_continuum_size) min_size = random.randint(0, len(variables)) max_size = random.randint(min_size, len(variables)) return ContinuumRule.random(var, val, variables, domains, min_size, max_size)
def test_static_random(self): eprint(">> Continuum.random(min_value, max_value)") for i in range(self.__nb_unit_test): # Valid values min = random.uniform(self.__min_value, self.__max_value) max = random.uniform(min, self.__max_value) c = Continuum.random(min, max) self.assertTrue(c.get_min_value() >= min and c.get_min_value() <= max) self.assertTrue(isinstance(c.min_included(), bool)) self.assertFalse(c.is_empty()) # with min size min_size = 0 while min_size == 0: min_size = random.uniform(-100, 0) self.assertRaises(ValueError, Continuum.random, min, max, min_size) min_size = random.uniform(0, self.__max_value) if min_size >= (max - min): self.assertRaises(ValueError, Continuum.random, min, max, min_size) c = Continuum.random(min, max) self.assertTrue(c.get_min_value() >= min and c.get_min_value() <= max) self.assertTrue(isinstance(c.min_included(), bool)) self.assertFalse(c.is_empty()) # Invalid values min = random.uniform(self.__min_value, self.__max_value) max = random.uniform(self.__min_value, min - 0.001) self.assertRaises(ValueError, Continuum.random, min, max)
def random(head_variable, head_value, variables, domains, min_body_size, max_body_size): """ Generates a valid continuum rule of given size randomly. Args: head_variable: int id of the head variable head_value: Continuum range of values of the head variable variables: list of String labels of the variable of a dynamic system domains: list of pairs of (int, Continuum) domains of values of each variable min_body_size: int minimal number of conditions to appear in the generated rule max_body_size: int maximal number of conditions to appear in the generated rule Returns: ContinuumRule A random valid continuum rule """ if min_body_size > max_body_size: raise ValueError( "min_body_size must be inferior or equal to max_body_size") if min_body_size > len(variables): raise ValueError( "min_body_size can't exceed the number of variables") if max_body_size > len(variables): raise ValueError( "max_body_size can't exceed the number of variables") size = random.randint(min_body_size, max_body_size) locked = [] r = ContinuumRule(head_variable, head_value) while r.size() < size: var = random.randint(0, len(variables) - 1) val = Continuum.random(domains[var].get_min_value(), domains[var].get_max_value()) if var not in locked: r.set_condition(var, val) locked.append(var) return r
def test_size(self): eprint(">> Continuum.size(self)") for i in range(self.__nb_unit_test): # empty set c = Continuum() self.assertEqual(c.size(), 0.0) # regular c = Continuum.random(self.__min_value, self.__max_value) if not c.is_empty(): self.assertEqual(c.size(), c.get_max_value() - c.get_min_value())
def test_precision(self): print(">> ContinuumLogicProgram.precision(expected, predicted)") self.assertEqual(ContinuumLogicProgram.precision([],[]), 1.0) # Equal programs for i in range(self.__nb_unit_test): variables, domains = self.random_system() nb_states = random.randint(1,100) expected = [] predicted = [] for j in range(nb_states): s1 = [ random.uniform(d.get_min_value(),d.get_max_value()) for d in domains ] s2 = [ random.uniform(d.get_min_value(),d.get_max_value()) for d in domains ] s2_ = [ Continuum.random(d.get_min_value(), d.get_max_value()) for d in domains ] expected.append( (s1,s2) ) predicted.append( (s1,s2_) ) precision = ContinuumLogicProgram.precision(expected, predicted) error = 0 for j in range(len(expected)): s1, s2 = expected[j] s1_, s2_ = predicted[j] for k in range(len(s2)): if not s2_[k].includes(s2[k]): error += 1 total = nb_states * len(variables) self.assertEqual( precision, 1.0 - (error / total) ) #eprint("precision: ", precision) # error of size state_id = random.randint(0, len(expected)-1) modif = random.randint(1,len(expected[state_id])) expected[state_id] = ( expected[state_id][0][:-modif], expected[state_id][1] ) self.assertRaises(ValueError, ContinuumLogicProgram.precision, expected, predicted)
def test___init__(self): print(">> ContinuumLogicProgram.__init__(self, variables, domains, rules)") for i in range(self.__nb_unit_test): variables, domains = self.random_system() rules = [] for j in range(random.randint(0,self.__nb_rules)): r = self.random_rule(variables, domains) rules.append(r) p = ContinuumLogicProgram(variables, domains, rules) self.assertEqual(p.get_variables(), variables) self.assertEqual(p.get_domains(), domains) self.assertEqual(p.get_rules(), rules) modif = random.randint(1,len(variables)) self.assertRaises(ValueError, ContinuumLogicProgram, variables, domains[:-modif], rules) for var in range(0, modif): domains.append(Continuum.random(self.__min_value, self.__max_value, self.__min_domain_size)) self.assertRaises(ValueError, ContinuumLogicProgram, variables, domains, rules)
def test_set_upper_bound(self): eprint(">> Continuum.set_upper_bound(self, value, included)") for i in range(self.__nb_unit_test): # Empty set c = Continuum() self.assertRaises(TypeError, c.set_upper_bound, "string", True) self.assertRaises(TypeError, c.set_upper_bound, "string", False) self.assertRaises(TypeError, c.set_upper_bound, 0.5, 10) value = random.uniform(self.__min_value, self.__max_value) # extend with exclusion gives empty set, mistake expected from user # or both min and max will be changed and constructor must be used self.assertRaises(ValueError, c.set_upper_bound, value, False) c.set_upper_bound(value, True) # Empty set to one value interval self.assertEqual(c, Continuum(value, value, True, True)) # Regular continuum # over min value c = Continuum.random(self.__min_value, self.__max_value) value = random.uniform(self.__min_value, c.get_min_value()) while value == c.get_min_value(): value = random.uniform(self.__min_value, c.get_min_value()) self.assertRaises(ValueError, c.set_upper_bound, value, True) self.assertRaises(ValueError, c.set_upper_bound, value, False) # on min value c = Continuum.random(self.__min_value, self.__max_value) c_old = c.copy() value = c.get_min_value() if not c.max_included() or not c.min_included(): c.set_upper_bound(value, False) self.assertEqual(c, Continuum()) # continuum reduced to empty set else: c.set_upper_bound(value, True) self.assertEqual(c.get_max_value(), value) self.assertEqual(c.max_included(), True) self.assertEqual(c.get_max_value(), c.get_min_value()) self.assertEqual(c.get_min_value(), c_old.get_min_value()) self.assertEqual(c.min_included(), c_old.min_included()) # other valid value c = Continuum.random(self.__min_value, self.__max_value) c_old = c.copy() value = random.uniform(c.get_min_value(), self.__max_value) while value == c.get_min_value(): value = random.uniform(c.get_min_value(), self.__max_value) c.set_upper_bound(value, True) self.assertEqual(c.get_max_value(), value) self.assertEqual(c.max_included(), True) c = Continuum.random(self.__min_value, self.__max_value) c_old = c.copy() value = random.uniform(c.get_min_value(), self.__max_value) while value == c.get_min_value(): value = random.uniform(c.get_min_value(), self.__max_value) c.set_upper_bound(value, False) self.assertEqual(c.get_max_value(), value) self.assertEqual(c.max_included(), False)
def test__eq__(self): eprint(">> Continuum.__eq__(self, continuum)") for i in range(self.__nb_unit_test): # emptyset c = Continuum() self.assertTrue(Continuum() == Continuum()) self.assertTrue(c == Continuum()) self.assertTrue(c == c) self.assertFalse(Continuum() != Continuum()) self.assertFalse(c != Continuum()) self.assertFalse(c != c) c = Continuum.random(self.__min_value, self.__max_value) self.assertTrue(c == c) self.assertFalse(c != c) self.assertEqual(c == Continuum(), c.is_empty()) c_ = Continuum.random(self.__min_value, self.__max_value) if c.is_empty() and c_.is_empty(): self.assertTrue(c == c_) self.assertTrue(c != c_) if c.is_empty() != c_.is_empty(): self.assertFalse(c == c_) self.assertTrue(c != c_) if c.get_min_value() != c_.get_min_value(): self.assertFalse(c == c_) self.assertTrue(c != c_) if c.get_max_value() != c_.get_max_value(): self.assertFalse(c == c_) self.assertTrue(c != c_) if c.min_included() != c_.min_included(): self.assertFalse(c == c_) self.assertTrue(c != c_) if c.max_included() != c_.max_included(): self.assertFalse(c == c_) self.assertTrue(c != c_) # exaustive modifications if not c.is_empty(): c_ = c.copy() value = random.uniform(1, 100) c_.set_lower_bound(c.get_min_value() - value, True) self.assertFalse(c == c_) self.assertTrue(c != c_) c_.set_lower_bound(c.get_min_value() - value, False) self.assertFalse(c == c_) self.assertTrue(c != c_) c_ = c.copy() c_.set_lower_bound(c.get_min_value(), not c.min_included()) self.assertFalse(c == c_) self.assertTrue(c != c_) c_ = c.copy() value = random.uniform(1, 100) c_.set_upper_bound(c.get_min_value() + value, True) self.assertFalse(c == c_) self.assertTrue(c != c_) c_.set_upper_bound(c.get_min_value() + value, False) self.assertFalse(c == c_) self.assertTrue(c != c_) c_ = c.copy() c_.set_upper_bound(c.get_max_value(), not c.max_included()) self.assertFalse(c == c_) self.assertTrue(c != c_) # different type self.assertFalse(c == "test") self.assertFalse(c == 0) self.assertFalse(c == True) self.assertFalse(c == [])
def test_intersects(self): eprint(">> Continuum.intersects(self, continuum)") for i in range(self.__nb_unit_test): c = Continuum.random(self.__min_value, self.__max_value) c_ = Continuum() # emptyset self.assertFalse(c.intersects(c_)) self.assertFalse(c_.intersects(c)) self.assertFalse(c_.intersects(c_)) # stricly before c = Continuum.random(self.__min_value, self.__max_value) c_ = Continuum.random(c.get_min_value() - 100, c.get_min_value()) self.assertFalse(c.intersects(c_)) self.assertFalse(c_.intersects(c)) # touching on lower bound c = Continuum.random(self.__min_value, self.__max_value) c_ = Continuum.random(c.get_min_value() - 100, c.get_min_value()) c_.set_upper_bound(c.get_min_value(), True) self.assertEqual(c.intersects(c_), c.min_included()) self.assertEqual(c_.intersects(c), c.min_included()) c_.set_upper_bound(c.get_min_value(), False) self.assertFalse(c.intersects(c_)) self.assertFalse(c_.intersects(c)) # strictly after c = Continuum.random(self.__min_value, self.__max_value) c_ = Continuum.random(c.get_max_value(), c.get_max_value() + 100) self.assertFalse(c.intersects(c_)) self.assertFalse(c_.intersects(c)) # touching on lower bound c = Continuum.random(self.__min_value, self.__max_value) c_ = Continuum.random(c.get_max_value(), c.get_max_value() + 100) c_.set_lower_bound(c.get_max_value(), True) self.assertEqual(c.intersects(c_), c.max_included()) self.assertEqual(c_.intersects(c), c.max_included()) c_.set_lower_bound(c.get_max_value(), False) self.assertFalse(c.intersects(c_)) self.assertFalse(c_.intersects(c)) # same (not empty) c = Continuum.random(self.__min_value, self.__max_value) while c.is_empty(): c = Continuum.random(self.__min_value, self.__max_value) self.assertTrue(c.includes(c)) # smaller c_ = Continuum.random(c.get_min_value(), c.get_max_value()) while c_.get_min_value() == c.get_min_value() and c_.get_max_value( ) == c.get_max_value(): c_ = Continuum.random(c.get_min_value(), c.get_max_value()) self.assertTrue(c.intersects(c_)) self.assertTrue(c_.intersects(c)) # bigger c_ = Continuum.random(c.get_min_value() - 100, c.get_max_value() + 100) while c_.get_min_value() >= c.get_min_value() or c_.get_max_value( ) <= c.get_max_value(): c_ = Continuum.random(c.get_min_value() - 100, c.get_max_value() + 100) #eprint(c.to_string()) #eprint(c_.to_string()) self.assertTrue(c.intersects(c_)) self.assertTrue(c_.intersects(c))
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 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)