def test_get_individual_data(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
# first population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 1]
p._costs = [4, 5, 6]
p._ev_time = [5, 6, 7]
mlc_repo.add_population(p)
# second population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 4, 2]
p._costs = [7, 4, 9]
p._ev_time = [8, 5, 10]
mlc_repo.add_population(p)
# check idividuals data loaded from the mlc_repo
self.assertEqual(mlc_repo.count_population(), 2)
# Individual 1 have two appearances in the first generation
data = mlc_repo.get_individual_data(1)
self.assertEqual(data.get_value(), "(root (+ 1 1))")
self.assertEqual(data.get_appearances(), 2)
self.assertEqual(data.get_cost_history(), {1: [(4.0, 5), (6.0, 7)]})
# Individual 2 have two appearances
data = mlc_repo.get_individual_data(2)
self.assertEqual(data.get_value(), "(root (+ 2 2))")
self.assertEqual(data.get_appearances(), 2)
self.assertEqual(data.get_cost_history(), {
1: [(5.0, 6)],
2: [(9.0, 10)]
})
# Individual 3 have one appearances
data = mlc_repo.get_individual_data(3)
self.assertEqual(data.get_value(), "(root (+ 3 3))")
self.assertEqual(data.get_appearances(), 1)
self.assertEqual(data.get_cost_history(), {2: [(7.0, 8)]})
# Individual 4 have one appearances
data = mlc_repo.get_individual_data(4)
self.assertEqual(data.get_value(), "(root (+ 4 4))")
self.assertEqual(data.get_appearances(), 1)
self.assertEqual(data.get_cost_history(), {2: [(4.0, 5)]})
# get individual data from invalid individual
try:
data = mlc_repo.get_individual_data(100)
self.assertTrue(False)
except KeyError, ex:
self.assertTrue(True)
def test_add_population(self):
mlc_repo = self.__get_new_repo()
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
self.assertEqual(mlc_repo.count_individual(), 3)
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 3]
p._costs = [4, 5, 6]
p._ev_time = [7, 8, 9]
p._gen_method = [10, 11, 12]
# add population to the mlc_repository
self.assertEqual(mlc_repo.count_population(), 0)
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 1)
# obtain population
p_from_repo = mlc_repo.get_population(1)
# check population content
self.assertEqual(p_from_repo._individuals, p._individuals)
self.assertEqual(p_from_repo._costs, p._costs)
self.assertEqual(p_from_repo._ev_time, p._ev_time)
self.assertEqual(p_from_repo._gen_method, p._gen_method)
def test_update_individual_cost_in_generation(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
# add first population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 1]
p._costs = [4, 5, 6]
p._ev_time = [5, 6, 7]
mlc_repo.add_population(p)
# add second population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 1, 2]
p._costs = [8, 9, 10]
p._ev_time = [11, 12, 13]
mlc_repo.add_population(p)
# update cost for individual 1
mlc_repo.update_individual_cost(1, 45, 46, generation=1)
# check cost update in the first population
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [1, 2, 1])
self.assertEqual(p._costs, [45, 5, 45])
self.assertEqual(p._ev_time, [46, 6, 46])
# check cost update in the second population
p = mlc_repo.get_population(2)
self.assertEqual(p._individuals, [2, 1, 2])
self.assertEqual(p._costs, [8, 9, 10])
self.assertEqual(p._ev_time, [11, 12, 13])
def test_get_individuals(self):
mlc_repo = self.__get_new_repo()
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
# get individuals
individual = mlc_repo.get_individual(1)
self.assertEqual(individual.get_value(), "(root (+ 1 1))")
individual = mlc_repo.get_individual(2)
self.assertEqual(individual.get_value(), "(root (+ 2 2))")
# get individual data
data = mlc_repo.get_individual_data(1)
self.assertEqual(data.get_appearances(), 0)
self.assertEqual(data.get_value(), "(root (+ 1 1))")
self.assertEqual(data.get_cost_history(), {})
data = mlc_repo.get_individual_data(2)
self.assertEqual(data.get_appearances(), 0)
self.assertEqual(data.get_value(), "(root (+ 2 2))")
self.assertEqual(data.get_cost_history(), {})
# invalid id
try:
individual = mlc_repo.get_individual(3)
self.assertTrue(False)
except KeyError:
self.assertTrue(True)
def test_remove_population_to_from_bad_values(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
mlc_repo.add_individual(Individual("(root (+ 5 5))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 1, 1]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 2, 2]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 3, 3]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 3)
# Remove all generations (1 to 3)
mlc_repo.remove_population_to(10)
self.assertEqual(mlc_repo.count_population(), 0)
def test_add_one_individual_incomplete_population(self):
base_creator = MixedRampedGauss()
creator = IndividualSelection({Individual("1+1"): [0]}, base_creator)
self.__fill_and_assert(fill_creator=creator,
expected_pop_indexes=[1],
expected_individuals={1: Individual("1+1")})
def test_reload_individuals_from_file(self):
with saved(Config.get_instance()) as config:
config.set("BEHAVIOUR", "save", "true")
config.set("BEHAVIOUR", "savedir", "test.db")
config.set("POPULATION", "sensor_spec", "false")
config.set("POPULATION", "sensors", "0")
config.set("OPTIMIZATION", "simplify", "false")
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 1, 2]
mlc_repo.add_population(p)
# check status
self.assertEqual(mlc_repo.count_individual(), 2)
self.assertEqual(mlc_repo.count_population(), 1)
# reload mlc_repository using another instance
mlc_repo = self.__get_new_repo()
self.assertEqual(mlc_repo.count_individual(), 2)
self.assertEqual(mlc_repo.count_population(), 1)
def test_add_individual(self):
mlc_repo = self.__get_new_repo()
# mlc repository is empty
self.assertEqual(mlc_repo.count_individual(), 0)
# add the first individual
indiv_id, exists = mlc_repo.add_individual(
Individual("(root (+ 1 1))"))
self.assertEqual(indiv_id, 1)
self.assertFalse(exists)
self.assertEqual(mlc_repo.count_individual(), 1)
# trying to add an Individual with the same value
indiv_id, exists = mlc_repo.add_individual(
Individual("(root (+ 1 1))"))
self.assertEqual(indiv_id, 1)
self.assertTrue(exists)
self.assertEqual(mlc_repo.count_individual(), 1)
# adds another individual
indiv_id, exists = mlc_repo.add_individual(
Individual("(root (+ 2 2))"))
self.assertEqual(indiv_id, 2)
self.assertFalse(exists)
self.assertEqual(mlc_repo.count_individual(), 2)
def test_remove_population_to(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
mlc_repo.add_individual(Individual("(root (+ 5 5))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 1, 1]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 2, 2]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 3, 3]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [4, 4, 4]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 4)
# remove generations 1 to 2
mlc_repo.remove_population_to(2)
self.assertEqual(mlc_repo.count_population(), 2)
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [3, 3, 3])
p = mlc_repo.get_population(2)
self.assertEqual(p._individuals, [4, 4, 4])
# New generation must be number 3
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [5, 5, 5]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 3)
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [3, 3, 3])
p = mlc_repo.get_population(2)
self.assertEqual(p._individuals, [4, 4, 4])
p = mlc_repo.get_population(3)
self.assertEqual(p._individuals, [5, 5, 5])
def test_cut_generation(self):
"""
Cut a generation using remove_population_from/remove_population_last
:return:
"""
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
mlc_repo.add_individual(Individual("(root (+ 5 5))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 1, 1]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 2, 2]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 3, 3]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [4, 4, 4]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [5, 5, 5]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 5)
# Cut population 4
mlc_repo.remove_population_from(4 + 1)
mlc_repo.remove_population_to(4 - 1)
# remove unused individuals
mlc_repo.remove_unused_individuals()
self.assertEqual(mlc_repo.count_population(), 1)
self.assertEqual(mlc_repo.count_individual(), 1)
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [4, 4, 4])
individual = mlc_repo.get_individual(4)
self.assertEqual(individual.get_value(), "(root (+ 4 4))")
def test_remove_population_to_clear_generations(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
mlc_repo.add_individual(Individual("(root (+ 5 5))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 1, 1]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 2, 2]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 3, 3]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 3)
# Remove all generations (1 to 3)
mlc_repo.remove_population_to(3)
self.assertEqual(mlc_repo.count_population(), 0)
# Insert populations again
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [3, 3, 3]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [4, 4, 4]
mlc_repo.add_population(p)
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [5, 5, 5]
mlc_repo.add_population(p)
self.assertEqual(mlc_repo.count_population(), 3)
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [3, 3, 3])
p = mlc_repo.get_population(2)
self.assertEqual(p._individuals, [4, 4, 4])
p = mlc_repo.get_population(3)
self.assertEqual(p._individuals, [5, 5, 5])
def test_crossover_same_level_4(self):
individual_1 = Individual("(root S0)", Config.get_instance())
individual_2 = Individual("(root S0)", Config.get_instance())
try:
new_ind_1, new_ind_2, _ = individual_1.crossover(individual_2)
self.assertFalse(True,
"crossover with individual type 4 should fail")
except OperationOverIndividualFail, ex:
self.assertTrue(True)
def test_compare(self):
individual_1 = Individual(
"(root (exp (tanh (- (tanh -8.049) (* 9.15 -6.848)))))")
individual_2 = Individual(
"(root (exp (tanh (- (tanh -8.049) (* 9.15 -6.848)))))")
self.assertTrue(individual_1.compare(individual_2))
individual_different = Individual(
"(root (cos (+ (sin (log -0.7648)) (exp (tanh 3.6284)))))")
self.assertFalse(individual_1.compare(individual_different))
def create(self, gen_size):
MLCRepository.get_instance().add_individual(
Individual("(root 1)"))
MLCRepository.get_instance().add_individual(
Individual("(root 2)"))
MLCRepository.get_instance().add_individual(
Individual("(root 3)"))
MLCRepository.get_instance().add_individual(
Individual("(root 4)"))
MLCRepository.get_instance().add_individual(
Individual("(root 5)"))
def test_remove_from_population(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
mlc_repo.add_individual(Individual("(root (+ 3 3))"))
mlc_repo.add_individual(Individual("(root (+ 4 4))"))
# add first population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 1]
mlc_repo.add_population(p)
# add second population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 3]
mlc_repo.add_population(p)
# add third population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [1, 2, 4]
mlc_repo.add_population(p)
# remove last population
mlc_repo.remove_population_from(2)
# last generation must be removed
self.assertEqual(mlc_repo.count_population(), 1)
# first generation exists
p = mlc_repo.get_population(1)
self.assertEqual(p._individuals, [1, 2, 1])
# all individuals exists and the third individual do not appear in any generation
self.assertEqual(mlc_repo.count_individual(), 4)
# remove unused individuals
deleted = mlc_repo.remove_unused_individuals()
self.assertEqual(deleted, 2)
self.assertEqual(mlc_repo.count_individual(), 2)
individual = mlc_repo.get_individual(1)
self.assertEqual(individual.get_value(), "(root (+ 1 1))")
individual = mlc_repo.get_individual(2)
self.assertEqual(individual.get_value(), "(root (+ 2 2))")
try:
individual = mlc_repo.get_individual(3)
self.assertTrue(False)
except KeyError:
self.assertTrue(True)
def test_crossover_same_level_0(self):
individual_1 = Individual("(root (cos 5.046))", Config.get_instance())
individual_2 = Individual("(root (cos 5.046))", Config.get_instance())
new_ind_1, new_ind_2, _ = individual_1.crossover(individual_2)
self._assert_individual(new_ind_1,
complexity=4,
value="(root (cos 5.046))",
formal="cos(5.046)")
self._assert_individual(new_ind_2,
complexity=4,
value="(root (cos 5.046))",
formal="cos(5.046)")
def test_reload_individuals_in_memory_loss_data(self):
mlc_repo = self.__get_new_repo()
# add individuals
mlc_repo.add_individual(Individual("(root (+ 1 1))"))
mlc_repo.add_individual(Individual("(root (+ 2 2))"))
# add population
p = Population(3, 0, Config.get_instance(), mlc_repo)
p._individuals = [2, 1, 2]
# reload mlc_repository using another instance
mlc_repo = self.__get_new_repo()
self.assertEqual(mlc_repo.count_individual(), 0)
self.assertEqual(mlc_repo.count_population(), 0)
def test_parameter_controls_mutate_hoist(self):
# save and restore original configuration
with saved(Config.get_instance()):
Config.get_instance().set("POPULATION", "controls", "5")
individual = Individual(
'(root (/ (exp (/ 8.2118 S0)) (* (* S0 (* 1.6755 -0.0699)) (log (exp -3.2288)))) (* (+ (sin -9.8591) (exp S0)) -9.4159) 0.0290 (* (log (* (+ -5.0573 -6.2191) S0)) (/ (cos (log S0)) (cos (tanh 2.2886)))) (log -8.6795))'
)
new_ind = individual.mutate(Individual.MutationType.HOIST)
self.assertEqual(
new_ind.get_value(),
"(root (log (exp -3.2288)) (* (+ (sin -9.8591) (exp S0)) -9.4159) 0.0290 (* (log (* (+ -5.0573 -6.2191) S0)) (/ (cos (log S0)) (cos (tanh 2.2886)))) (log -8.6795))"
)
new_ind = individual.mutate(Individual.MutationType.HOIST)
self.assertEqual(
new_ind.get_value(),
"(root (/ (exp (/ 8.2118 S0)) (* (* S0 (* 1.6755 -0.0699)) (log (exp -3.2288)))) (exp S0) 0.0290 (* (log (* (+ -5.0573 -6.2191) S0)) (/ (cos (log S0)) (cos (tanh 2.2886)))) (log -8.6795))"
)
new_ind = individual.mutate(Individual.MutationType.HOIST)
self.assertEqual(
new_ind.get_value(),
"(root (* S0 (* 1.6755 -0.0699)) (* (+ (sin -9.8591) (exp S0)) -9.4159) 0.0290 (* (log (* (+ -5.0573 -6.2191) S0)) (/ (cos (log S0)) (cos (tanh 2.2886)))) (log -8.6795))"
)
def test_generate_from_value(self):
individual = Individual(
"(root (exp (tanh (- (tanh -8.049) (* 9.15 -6.848)))))")
self.assertEquals(
individual.get_value(),
"(root (exp (tanh (- (tanh -8.049) (* 9.15 -6.848)))))")
self.assertEquals(individual.get_formal(),
"exp(tanh((tanh((-8.049)) - (9.15 .* (-6.848)))))")
self.assertEquals(individual.get_complexity(), 20)
def setUp(self):
set_logger("testing")
# Load randoms from file
random_file = './mlc/unit_matlab_randoms.txt'
RandomManager.clear_random_values()
RandomManager.load_random_values(random_file)
config = Config.get_instance()
config.read(
os.path.join(mlc_config_path.get_test_path(),
'mlc/individual/configuration.ini'))
self._individual_l0 = Individual("(root (cos 5.046))")
self._individual_l1 = Individual(
"(root (log (sin (exp (tanh 3.6284)))))")
self._individual_l2 = Individual(
"(root (cos (* (+ (* -1.912 -9.178) (cos S0)) 3.113)))")
self._individual_l3 = Individual(
"(root (log (/ (* (sin 4.37) (- -8.815 -3.902)) (log (+ 2.025 -8.685)))))"
)
self._individual_l4 = Individual("(root S0)")
def __load_individuals(self):
individuals = {}
conn = self.__get_db_connection()
cursor = conn.execute(stmt_get_all_individuals())
for row in cursor:
new_individual = Individual(str(row[1]),
SQLSaveFormal.from_sql(row[2]), row[3])
individuals[row[0]] = new_individual
cursor.close()
conn.commit()
return individuals
def test_crossover_same_level_2(self):
individual_1 = Individual(
"(root (cos (* (+ (* -1.912 -9.178) (cos S0)) 3.113)))",
Config.get_instance())
individual_2 = Individual(
"(root (cos (* (+ (* -1.912 -9.178) (cos S0)) 3.113)))",
Config.get_instance())
new_ind_1, new_ind_2, _ = individual_1.crossover(individual_2)
self._assert_individual(
new_ind_1,
complexity=8,
value="(root (cos (* (* -1.912 -9.178) 3.113)))",
formal="cos((((-1.912) .* (-9.178)) .* 3.113))")
self._assert_individual(
new_ind_2,
complexity=18,
value=
"(root (cos (* (+ (+ (* -1.912 -9.178) (cos S0)) (cos S0)) 3.113)))",
formal=
"cos((((((-1.912) .* (-9.178)) + cos(S0)) + cos(S0)) .* 3.113))")
def get_gen_creator(self):
"""
Return an IndividualSelection creator if the user added individuals
manually.
Return None if this was not the case
"""
if not self._individuals:
logger.info("[FIRST_INDIV] No individual")
return None
gen_method = Config.get_instance().get('GP', 'generation_method')
fill_creator = CreationFactory.make(gen_method)
# Creat the dictionary of individuals
indivs_dict = {}
for index in xrange(len(self._individuals)):
indiv = Individual(self._individuals[index])
indivs_dict[indiv] = [index]
return IndividualSelection(indivs_dict, fill_creator)
def test_parameter_controls_generate(self):
# save and restore original configuration
with saved(Config.get_instance()):
# random generation
Config.get_instance().set("POPULATION", "controls", "3")
individual = Individual.generate(individual_type=2,
config=Config.get_instance())
self.assertEqual(
individual.get_value(),
'(root (/ -3.0632 (cos -3.0973)) (exp (log (* (* S0 -0.8182) (sin -6.5057)))) (/ (/ -1.4169 (/ (* S0 S0) (cos -7.5988))) (log (cos (* S0 5.7489)))))'
)
formal_exp = individual.get_formal()
self.assertIsInstance(formal_exp, list)
self.assertEqual(len(formal_exp), 3)
self.assertEqual(formal_exp[0],
'(my_div((-3.0632),cos((-3.0973))))')
self.assertEqual(
formal_exp[1],
'exp(my_log(((S0 .* (-0.8182)) .* sin((-6.5057)))))')
self.assertEqual(
formal_exp[2],
'(my_div((my_div((-1.4169),(my_div((S0 .* S0),cos((-7.5988)))))),my_log(cos((S0 .* 5.7489)))))'
)
self.assertEqual(individual.get_complexity(), 46)
# generate individual with one control
Config.get_instance().set("POPULATION", "controls", "1")
individual = Individual("(root (cos (- 5.0161 (sin (log S0)))))",
Config.get_instance())
self.assertIsInstance(individual.get_formal(), str)
self.assertEqual(individual.get_formal(),
'cos((5.0161 - sin(my_log(S0))))')
self.assertEqual(individual.get_complexity(), 14)
# generate individual with 3 controls
Config.get_instance().set("POPULATION", "controls", "3")
individual = Individual(
'(root (exp 2.1314) (* (+ (sin -9.8591) (exp S0)) -9.4159) (exp (/ (/ 8.0187 -8.5969) S0)))',
Config.get_instance())
formal_exp = individual.get_formal()
self.assertIsInstance(formal_exp, list)
self.assertEqual(len(formal_exp), 3)
self.assertEqual(formal_exp[0], 'exp(2.1314)')
self.assertEqual(formal_exp[1],
'((sin((-9.8591)) + exp(S0)) .* (-9.4159))')
self.assertEqual(formal_exp[2],
'exp((my_div((my_div(8.0187,(-8.5969))),S0)))')
self.assertEqual(individual.get_complexity(), 29)
# generate individual with 5 controls
Config.get_instance().set("POPULATION", "controls", "5")
individual = Individual(
'(root (/ (exp (/ 8.2118 S0)) (* (* S0 (* 1.6755 -0.0699)) (log (exp -3.2288)))) S0 0.0290 (* (log (* (+ -5.0573 -6.2191) S0)) (/ (cos (log S0)) (cos (tanh 2.2886)))) (log -8.6795))',
Config.get_instance())
formal_exp = individual.get_formal()
self.assertIsInstance(formal_exp, list)
self.assertEqual(len(formal_exp), 5)
self.assertEqual(
formal_exp[0],
'(my_div(exp((my_div(8.2118,S0))),((S0 .* (1.6755 .* (-0.0699))) .* my_log(exp((-3.2288))))))'
)
self.assertEqual(formal_exp[1], 'S0')
self.assertEqual(formal_exp[2], '0.0290')
self.assertEqual(
formal_exp[3],
'(my_log((((-5.0573) + (-6.2191)) .* S0)) .* (my_div(cos(my_log(S0)),cos(tanh(2.2886)))))'
)
self.assertEqual(formal_exp[4], 'my_log((-8.6795))')
self.assertEqual(individual.get_complexity(), 64)
# generate individual with multiple simplifications
Config.get_instance().set("POPULATION", "controls", "3")
Config.get_instance().set("OPTIMIZATION", "simplify", "true")
individual = Individual(
'(root (exp 2.1314) (* (+ (sin -9.8591) (exp S0)) -9.4159) (exp (/ (/ 8.0187 -8.5969) S0)))',
Config.get_instance())
formal_exp = individual.get_formal()
self.assertIsInstance(formal_exp, list)
self.assertEqual(len(formal_exp), 3)
self.assertEqual(formal_exp[0], 'exp(2.1314)')
self.assertEqual(formal_exp[1],
'((sin((-9.8591)) + exp(S0)) .* (-9.4159))')
self.assertEqual(formal_exp[2],
'exp((my_div((my_div(8.0187,(-8.5969))),S0)))')