def update_current_subproblem_neighborhood(self, new_solution, population):
if self.phi_max < overall_constraint_violation_degree(new_solution):
self.phi_max = overall_constraint_violation_degree(new_solution)
permuted_neighbors_indexes = self.generate_permutation_of_neighbors(
self.current_subproblem)
replacements = 0
for i in range(len(permuted_neighbors_indexes)):
k = permuted_neighbors_indexes[i]
f1 = self.fitness_function.compute(
population[k].objectives, self.neighbourhood.weight_vectors[k])
f2 = self.fitness_function.compute(
new_solution.objectives, self.neighbourhood.weight_vectors[k])
cons1 = abs(overall_constraint_violation_degree(self.solutions[k]))
cons2 = abs(overall_constraint_violation_degree(new_solution))
if cons1 < self.epsilon_k and cons2 <= self.epsilon_k:
if f2 < f1:
population[k] = copy.deepcopy(new_solution)
replacements += 1
elif cons1 == cons2:
if f2 < f1:
population[k] = copy.deepcopy(new_solution)
replacements += 1
elif cons2 < cons1:
population[k] = copy.deepcopy(new_solution)
replacements += 1
if replacements >= self.max_number_of_replaced_solutions:
break
return population
def test_should_constraint_violation_degree_return_zero_if_the_solution_has_not_violated_constraints(
self) -> None:
solution = Solution(number_of_variables=2,
number_of_objectives=2,
number_of_constraints=2)
self.assertEqual(0, overall_constraint_violation_degree(solution))
def compare(self, solution1: Solution, solution2: Solution) -> int:
violation_degree_solution_1 = overall_constraint_violation_degree(solution1)
violation_degree_solution_2 = overall_constraint_violation_degree(solution2)
if violation_degree_solution_1 < 0 and violation_degree_solution_2 < 0:
if violation_degree_solution_1 > violation_degree_solution_2:
result = -1
elif violation_degree_solution_2 > violation_degree_solution_1:
result = 1
else:
result = 0
elif violation_degree_solution_1 == 0 and violation_degree_solution_2 < 0:
result = -1
elif violation_degree_solution_2 == 0 and violation_degree_solution_1 < 0:
result = 1
else:
result = 0
return result
def test_should_constraint_violation_degree_return_the_right_violation_degree(
self) -> None:
solution = Solution(number_of_variables=2,
number_of_objectives=2,
number_of_constraints=2)
solution.constraints[0] = -1
solution.constraints[1] = -2
self.assertEqual(-3, overall_constraint_violation_degree(solution))
def select_final_population(self, population: List[S], mu: int) -> List[S]:
population_pool = copy(population)
population_pool.sort(key=lambda s: (
overall_constraint_violation_degree(s), s.objectives[0]))
new_population = []
for i in range(mu):
new_population.append(population_pool[i])
return new_population
def replacement(self, population: List[S],
offspring_population: List[S]) -> List[S]:
population_pool = offspring_population
population_pool.sort(key=lambda s: (
overall_constraint_violation_degree(s), s.objectives[0]))
new_population = []
for i in range(self.population_size):
new_population.append(population_pool[i])
return new_population
def init_progress(self) -> None:
super().init_progress()
# for i in range(self.population_size):
# self.constraints[i] = get_overall_constraint_violation_degree(self.permutation[i])
self.constraints = [overall_constraint_violation_degree(self.solutions[i])
for i in range(0, self.population_size)]
sorted(self.constraints)
self.epsilon_zero = abs(self.constraints[int(ceil(0.05 * self.population_size))])
if self.phi_max < abs(self.constraints[0]):
self.phi_max = abs(self.constraints[0])
self.rk = feasibility_ratio(self.solutions)
self.epsilon_k = self.epsilon_zero
def replacement(self, population: List[S],
offspring_population: List[S]) -> List[S]:
population_pool = []
if self.elitist:
population_pool = population
population_pool.extend(offspring_population)
else:
population_pool.extend(offspring_population)
population_pool.sort(key=lambda s: (
overall_constraint_violation_degree(s), s.objectives[0]))
new_population = []
for i in range(self.mu):
new_population.append(population_pool[i])
return new_population
