def test_should_compare_return_zero_if_both_solutions_have_the_same_attribute_value(self):
solution1 = Solution(1, 1)
solution2 = Solution(1, 1)
solution1.attributes["attribute"] = 1.0
solution2.attributes["attribute"] = 1.0
self.assertEqual(0, self.comparator.compare(solution1, solution2))
def test_should_ranking_of_a_population_with_five_solutions_work_properly(
self):
solution1 = Solution(2, 2)
solution2 = Solution(2, 2)
solution3 = Solution(2, 2)
solution4 = Solution(2, 2)
solution5 = Solution(2, 2)
solution1.objectives[0] = 1.0
solution1.objectives[1] = 0.0
solution2.objectives[0] = 0.5
solution2.objectives[1] = 0.5
solution3.objectives[0] = 0.0
solution3.objectives[1] = 1.0
solution4.objectives[0] = 0.6
solution4.objectives[1] = 0.6
solution5.objectives[0] = 0.7
solution5.objectives[1] = 0.5
solution_list = [solution1, solution2, solution3, solution4, solution5]
ranking = self.ranking.compute_ranking(solution_list)
self.assertEqual(2, self.ranking.get_number_of_subfronts())
self.assertEqual(3, len(self.ranking.get_subfront(0)))
self.assertEqual(2, len(self.ranking.get_subfront(1)))
self.assertEqual(solution1, ranking[0][0])
self.assertEqual(solution2, ranking[0][1])
self.assertEqual(solution3, ranking[0][2])
self.assertEqual(solution4, ranking[1][0])
self.assertEqual(solution5, ranking[1][1])
def test_should_comparator_return_1_if_solution_2_has_higher_constraint_violation_degree(self):
solution1 = Solution(1, 1, 1)
solution2 = Solution(1, 1, 1)
solution1.constraints[0] = -2
solution2.constraints[0] = -5
self.assertEqual(-1, self.comparator.compare(solution1, solution2))
def test_should_add_work_properly_case3(self):
"""
Case 3: add a non-dominated solution when the archive size is 3 must include the solution
"""
archive = CrowdingDistanceArchive[Solution](5)
solution1 = Solution(2, 2)
solution1.objectives = [1.0, 2.0]
solution2 = Solution(2, 2)
solution2.objectives = [0.0, 4.0]
solution3 = Solution(2, 2)
solution3.objectives = [1.5, 1.5]
solution4 = Solution(2, 2)
solution4.objectives = [1.6, 1.2]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.add(solution4)
self.assertEqual(4, archive.size())
self.assertTrue(solution1 in archive.get_solution_list())
self.assertTrue(solution2 in archive.get_solution_list())
self.assertTrue(solution3 in archive.get_solution_list())
self.assertTrue(solution4 in archive.get_solution_list())
def test_should_replacement_return_the_list_if_the_offspring_list_is_empty(self):
"""
5 1
4 2
3 3
2
1 4
0 1 2 3 4 5
"""
ranking = StrengthRanking()
density_estimator = KNearestNeighborDensityEstimator(1)
replacement = RankingAndDensityEstimatorReplacement(ranking, density_estimator)
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution_list = [solution1, solution2, solution3, solution4]
result_list = replacement.replace(solution_list, [])
self.assertEqual(4, len(result_list))
self.assertEqual(0, solution1.attributes["strength_ranking"])
self.assertEqual(0, solution2.attributes["strength_ranking"])
self.assertEqual(0, solution3.attributes["strength_ranking"])
self.assertEqual(0, solution4.attributes["strength_ranking"])
def test_should_the_crowding_distance_of_four_solutions_correctly_assigned(self):
solution1 = Solution(2, 2)
solution2 = Solution(2, 2)
solution3 = Solution(2, 2)
solution4 = Solution(2, 2)
solution1.objectives[0] = 0.0
solution1.objectives[1] = 1.0
solution2.objectives[0] = 1.0
solution2.objectives[1] = 0.0
solution3.objectives[0] = 0.5
solution3.objectives[1] = 0.5
solution4.objectives[0] = 0.75
solution4.objectives[1] = 0.75
solution_list = [solution1, solution2, solution3, solution4]
self.crowding.compute_density_estimator(solution_list)
value_from_solution1 = solution_list[0].attributes["crowding_distance"]
value_from_solution2 = solution_list[1].attributes["crowding_distance"]
value_from_solution3 = solution_list[2].attributes["crowding_distance"]
value_from_solution4 = solution_list[3].attributes["crowding_distance"]
self.assertEqual(float("inf"), value_from_solution1)
self.assertEqual(float("inf"), value_from_solution2)
self.assertGreater(value_from_solution3, value_from_solution4)
def test_should_add_work_properly_case6(self):
""" Case 6: add a non-dominated solution when the archive is full should not include
the solution if it has the highest distance crowding value.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
solution2 = Solution(2, 2)
solution2.objectives = [1.0, 2.0]
solution3 = Solution(2, 2)
solution3.objectives = [2.0, 1.5]
solution4 = Solution(2, 2)
solution4.objectives = [3.0, 0.0]
new_solution = Solution(2, 2)
new_solution.objectives = [1.1, 1.9]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.add(solution4)
archive.add(new_solution)
self.assertEqual(4, archive.size())
self.assertTrue(new_solution not in archive.solution_list)
def test_should_replacement_return_the_right_value_case1(self):
"""
5 1
4 2
3 3
2
1 4
0 1 2 3 4 5
List: 1,2,3 OffspringList: 4
Expected result: 4, 1, 3
"""
ranking = StrengthRanking()
density_estimator = KNearestNeighborDensityEstimator(1)
replacement = RankingAndDensityEstimatorReplacement(ranking, density_estimator)
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution_list = [solution1, solution2, solution3]
offspring_list = [solution4]
result_list = replacement.replace(solution_list, offspring_list)
self.assertEqual(3, len(result_list))
self.assertTrue(solution1 in result_list)
self.assertTrue(solution3 in result_list)
self.assertTrue(solution4 in result_list)
def test_should_the_density_estimator_sort_the_solution_list_considering_the_draws(
self):
"""
5 1
4 2
3 3
2
1 4
0 1 2 3 4 5
Expected result after sort: 4, 3, 1, 2
"""
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution_list = [solution1, solution2, solution3, solution4]
self.knn.compute_density_estimator(solution_list)
self.knn.sort(solution_list)
self.assertEqual(solution_list[0], solution4)
self.assertEqual(solution_list[1], solution3)
self.assertEqual(solution_list[2], solution1)
self.assertEqual(solution_list[3], solution2)
def test_should_the_density_estimator_compute_the_right_distances_case1(
self):
"""
5 1
4 2
3 3
2
1 4
0 1 2 3 4 5
"""
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution_list = [solution1, solution2, solution3, solution4]
self.knn.compute_density_estimator(solution_list)
self.assertEqual(sqrt(2), solution1.attributes["knn_density"])
self.assertEqual(sqrt(2), solution2.attributes["knn_density"])
self.assertEqual(sqrt(2), solution3.attributes["knn_density"])
self.assertEqual(sqrt(2 * 2 + 2 * 2),
solution4.attributes["knn_density"])
def test_should_the_density_estimator_sort_the_solution_list(self):
"""
5 1
4 2
3 3
2 5
1 4
0 1 2 3 4 5
List: 1,2,3,4,5
Expected result: 4, 1, 2, 5, 3
"""
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution5 = Solution(2, 2)
solution5.objectives = [3, 2]
solution_list = [solution1, solution2, solution3, solution4, solution5]
self.knn.compute_density_estimator(solution_list)
self.knn.sort(solution_list)
self.assertEqual(solution_list[0], solution4)
self.assertEqual(solution_list[1], solution1)
self.assertEqual(solution_list[2], solution2)
self.assertEqual(solution_list[3], solution5)
def test_should_add_work_properly_case7(self):
""" Case 7: add a non-dominated solution when the archive is full should remove all the dominated solutions.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
solution2 = Solution(2, 2)
solution2.objectives = [1.0, 2.0]
solution3 = Solution(2, 2)
solution3.objectives = [2.0, 1.5]
solution4 = Solution(2, 2)
solution4.objectives = [3.0, 0.0]
new_solution = Solution(2, 2)
new_solution.objectives = [-1.0, -1.0]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.add(solution4)
archive.add(new_solution)
self.assertEqual(1, archive.size())
self.assertTrue(new_solution in archive.solution_list)
def test_should_compute_density_estimator_work_properly_case3(self):
""" Case 3: The archive contains two solutions.
"""
archive = CrowdingDistanceArchive(4)
solution1 = Solution(2, 2)
solution1.objectives = [0.0, 3.0]
solution2 = Solution(2, 2)
solution2.objectives = [1.0, 2.0]
solution3 = Solution(2, 2)
solution3.objectives = [2.0, 1.5]
archive.add(solution1)
archive.add(solution2)
archive.add(solution3)
archive.compute_density_estimator()
self.assertEqual(3, archive.size())
self.assertEqual(float("inf"),
solution1.attributes["crowding_distance"])
self.assertEqual(float("inf"),
solution3.attributes["crowding_distance"])
self.assertTrue(
solution2.attributes["crowding_distance"] < float("inf"))
def test_should_ranking_assing_zero_to_all_the_solutions_if_they_are_nondominated(self):
"""
5 1
4 2
3 3
2
1 4
0 1 2 3 4 5
Points 1, 2, 3 and 4 are nondominated
"""
solution1 = Solution(2, 2)
solution1.objectives = [1, 5]
solution2 = Solution(2, 2)
solution2.objectives = [2, 4]
solution3 = Solution(2, 2)
solution3.objectives = [3, 3]
solution4 = Solution(2, 2)
solution4.objectives = [5, 1]
solution_list = [solution1, solution2, solution3, solution4]
ranking = self.ranking.compute_ranking(solution_list)
self.assertEqual(1, self.ranking.get_number_of_subfronts())
self.assertTrue(solution1 in ranking[0])
self.assertTrue(solution2 in ranking[0])
self.assertTrue(solution3 in ranking[0])
self.assertTrue(solution4 in ranking[0])
def test_should_compare_return_zero_if_the_second_solution_has_no_the_attribute(
self):
solution1 = Solution(1, 1)
solution2 = Solution(1, 1)
solution1.attributes["attribute"] = 1.0
self.assertEquals(0, self.comparator.compare(solution1, solution2))
def test_should_dominance_comparator_return_zero_if_the_two_solutions_have_one_objective_with_the_same_value(self):
solution = Solution(1, 1)
solution2 = Solution(1, 1)
solution.objectives = [1.0]
solution2.objectives = [1.0]
self.assertEqual(0, self.comparator.compare(solution, solution2))
def test_should_compare_work_properly_case_2(self):
"""Case 2: solution1.ranking > solution2.ranking"""
solution1 = Solution(1, 1)
solution2 = Solution(1, 1)
solution1.attributes["dominance_ranking"] = 2.0
solution2.attributes["dominance_ranking"] = 1.0
self.assertEqual(1, self.comparator.compare(solution1, solution2))
def test_should_dominance_comparator_return_minus_one_if_the_two_solutions_have_one_objective_and_the_first_one_is_lower(
self, ):
solution = Solution(1, 1)
solution2 = Solution(1, 1)
solution.objectives = [1.0]
solution2.objectives = [2.0]
self.assertEqual(-1, self.comparator.compare(solution, solution2))
def test_should_compare_works_properly_case2(self):
"""Case 2: solution1.attribute > solution2.attribute (lowest is best)"""
solution1 = Solution(1, 1)
solution2 = Solution(1, 1)
solution1.attributes["attribute"] = 1.0
solution2.attributes["attribute"] = 0.0
self.assertEqual(1, self.comparator.compare(solution1, solution2))
def test_should_dominance_comparator_work_properly_case_3(self):
"""Case d: solution1 has objectives [-1.0, 5.0, 9.0] and solution2 has [-2.0, 5.0, 10.0]"""
solution = Solution(1, 3)
solution2 = Solution(1, 3)
solution.objectives = [-1.0, 5.0, 9.0]
solution2.objectives = [-2.0, 5.0, 10.0]
self.assertEqual(0, self.comparator.compare(solution, solution2))
def test_should_comparator_return_0_if_the_solutions_have_the_same_constraint_violation_degree(self):
solution1 = Solution(1, 1, 2)
solution2 = Solution(1, 1, 2)
solution1.constraints[0] = -2
solution1.constraints[1] = -3
solution2.constraints[0] = -1
solution2.constraints[1] = -4
self.assertEqual(0, self.comparator.compare(solution1, solution2))
def test_should_compare_works_properly_case4(self):
"""Case 4: solution1.attribute > solution2.attribute (highest is best)"""
solution1 = Solution(1, 1)
solution2 = Solution(1, 1)
solution1.attributes["attribute"] = 1.0
solution2.attributes["attribute"] = 0.0
comparator = SolutionAttributeComparator("attribute", False)
self.assertEqual(-1, comparator.compare(solution1, solution2))
def test_should_execute_work_if_the_solution_list_contains_two_solutions_and_one_them_is_dominated(self):
solution1 = Solution(2, 2)
solution1.objectives = [1.0, 4.0]
solution2 = Solution(2, 2)
solution2.objectives = [0.0, 3.0]
solution_list = [solution1, solution2]
self.assertEqual(solution2, self.selection.execute(solution_list))
def test_should_execute_work_if_the_solution_list_contains_two_non_dominated_solutions(self):
solution1 = Solution(2, 2)
solution1.variables = [1.0, 2.0]
solution2 = Solution(2, 2)
solution2.variables = [0.0, 3.0]
solution_list = [solution1, solution2]
assert_that(any_of(solution1, solution2), self.selection.execute(solution_list))
def test_should_operator_raise_an_exception_if_the_list_of_comparators_is_empty(self):
selection = BinaryTournament2Selection[Solution]([])
solution1 = Solution(2, 2)
solution2 = Solution(2, 2)
solution_list = [solution1, solution2]
with self.assertRaises(Exception):
selection.execute(solution_list)
def test_should_execute_work_if_the_solution_list_contains_two_non_dominated_solutions(self):
solution1 = Solution(2, 2)
solution1.objectives = [1.0, 2.0]
solution2 = Solution(2, 2)
solution2.objectives = [0.0, 3.0]
solution_list = [solution1, solution2]
self.assertTrue(self.selection.execute(solution_list) in solution_list)
def test_should_feasibility_ratio_return_zero_if_all_the_solutions_in_a_list_are_unfeasible(
self) -> None:
solution1 = Solution(2, 2, 2)
solution2 = Solution(2, 2, 2)
solution1.constraints[0] = 0
solution1.constraints[1] = -1
solution2.constraints[0] = -2
solution2.constraints[1] = 0
self.assertEqual(0, feasibility_ratio([solution1, solution2]))
def test_should_feasibility_ratio_return_the_right_percentage_of_feasible_solutions(
self) -> None:
solution1 = Solution(2, 2, 1)
solution2 = Solution(2, 2, 1)
solution3 = Solution(2, 2, 1)
solution1.constraints[0] = -1
solution2.constraints[0] = 0
solution3.constraints[0] = -2
self.assertEqual(1 / 3,
feasibility_ratio([solution1, solution2, solution3]))
def test_should_execute_return_three_solutions_if_the_list_of_solutions_larger_than_three(
self):
selection = DifferentialEvolutionSelection[Solution]()
solution_list = [
Solution(1, 1),
Solution(1, 1),
Solution(1, 1),
Solution(1, 1)
]
self.assertEqual(3, len(selection.execute(solution_list)))
def test_should_the_crowding_distance_of_two_solutions_be_infinity(self):
solution1 = Solution(3, 3)
solution2 = Solution(3, 3)
solution_list = [solution1, solution2]
self.crowding.compute_density_estimator(solution_list)
value_from_solution1 = solution_list[0].attributes["crowding_distance"]
value_from_solution2 = solution_list[1].attributes["crowding_distance"]
self.assertEqual(float("inf"), value_from_solution1)
self.assertEqual(float("inf"), value_from_solution2)
