def create_solution(self) -> PermutationSolution:
new_solution = PermutationSolution(
number_of_variables=self.number_of_variables,
number_of_objectives=self.number_of_objectives)
new_solution.variables = random.sample(
range(1, self.number_of_variables + 1), self.number_of_variables)
return new_solution
def execute(self, solution: PermutationSolution) -> PermutationSolution:
rand = random.random()
if rand <= self.probability:
pos_one, pos_two = random.sample(range(solution.number_of_variables - 1), 2)
solution.variables[pos_one], solution.variables[pos_two] = \
solution.variables[pos_two], solution.variables[pos_one]
return solution
def execute(self, solution: PermutationSolution) -> PermutationSolution:
Check.that(type(solution) is PermutationSolution, "Solution type invalid")
rand = random.random()
if rand <= self.probability:
pos_one, pos_two = random.sample(range(solution.number_of_variables - 1), 2)
solution.variables[pos_one], solution.variables[pos_two] = \
solution.variables[pos_two], solution.variables[pos_one]
return solution
def evaluate(self, solution: PermutationSolution) -> PermutationSolution:
distance_fitness = 0
cost_fitness = 0
for i in range(self.number_of_variables - 1):
x = solution.variables[i]
X = solution.variables[i]
y = solution.variables[i + 1]
Y = solution.variables[i + 1]
distance_fitness += self.distance_matrix[x][y]
cost_fitness += self.cost_matrix[X][Y]
first, last = solution.variables[0], solution.variables[-1]
First, Last = solution.variables[0], solution.variables[-1]
distance_fitness += self.distance_matrix[first][last]
cost_fitness += self.cost_matrix[First][Last]
solution.objectives[0] = distance_fitness
solution.objectives[1] = cost_fitness
return solution
def load_initial_solutions(self, warm_startup_info: Mapping,
problem: Problem) -> None:
self.warm_startup_info = warm_startup_info
if warm_startup_info and 'paths' in self.warm_startup_info.keys(
) and len(self.warm_startup_info['paths']) > 0:
from jmetal.util.generator import InjectorGenerator
one_sol_variables = self.warm_startup_info['paths'][0]
solution = PermutationSolution(
number_of_variables=problem.number_of_variables,
number_of_objectives=problem.number_of_objectives)
solution.variables = one_sol_variables
self._initial_solutions.append(problem.evaluate(solution))
for one_sol_variables in self.warm_startup_info['paths'][1:]:
solution = copy(solution)
solution.variables = one_sol_variables
self._initial_solutions.append(problem.evaluate(solution))
generator = InjectorGenerator(solutions=self._initial_solutions)
else:
from jmetal.util.generator import RandomGenerator
generator = RandomGenerator()
self._solution_generator = generator
def evaluate(self, solution: PermutationSolution) -> PermutationSolution:
fitness = 0
for i in range(self.number_of_variables - 1):
x = solution.variables[i]
y = solution.variables[i + 1]
fitness += self.distance_matrix[x][y]
first, last = solution.variables[0], solution.variables[-1]
fitness += self.distance_matrix[first][last]
solution.objectives[0] = fitness
return solution
def test_should_the_solution_remain_unchanged_if_the_probability_is_zero(self):
operator = PMXCrossover(0.0)
solution1 = PermutationSolution(number_of_variables=2, number_of_objectives=1)
solution1.variables[0] = [1, 2]
solution1.variables[1] = [2, 6]
solution2 = PermutationSolution(number_of_variables=2, number_of_objectives=1)
solution2.variables[0] = [2, 3]
solution2.variables[1] = [5, 3]
offspring = operator.execute([solution1, solution2])
self.assertEqual([1, 2], offspring[0].variables[0])
self.assertEqual([2, 6], offspring[0].variables[1])
self.assertEqual([2, 3], offspring[1].variables[0])
self.assertEqual([5, 3], offspring[1].variables[1])
def test_should_the_operator_work_with_two_solutions_with_two_variables(self, random_call):
operator = CXCrossover(1.0)
solution1 = PermutationSolution(number_of_variables=2, number_of_objectives=1)
solution1.variables[0] = [1, 2, 3, 4, 7]
solution1.variables[1] = [2, 6, 4, 5, 3]
solution2 = PermutationSolution(number_of_variables=2, number_of_objectives=1)
solution2.variables[0] = [2, 3, 4, 1, 9]
solution2.variables[1] = [5, 3, 2, 4, 6]
random_call.return_value = 0
offspring = operator.execute([solution1, solution2])
self.assertEqual([1, 2, 3, 4, 9], offspring[0].variables[0])
self.assertEqual([2, 3, 4, 5, 6], offspring[0].variables[1])
self.assertEqual([1, 2, 3, 4, 7], offspring[1].variables[0])
self.assertEqual([2, 6, 4, 5, 3], offspring[1].variables[1])
def test_should_the_solution_remain_unchanged_if_the_probability_is_zero(
self, random_call):
operator = CXCrossover(1.0)
solution1 = PermutationSolution(number_of_variables=2,
number_of_objectives=1)
solution1.variables[0] = [1, 2, 3, 4, 7]
solution1.variables[1] = [2, 6, 4, 5, 3]
solution2 = PermutationSolution(number_of_variables=2,
number_of_objectives=1)
solution2.variables[0] = [2, 3, 4, 1, 9]
solution2.variables[1] = [5, 3, 2, 4, 6]
random_call.return_value = 0
offspring = operator.execute([solution1, solution2])
self.assertEqual([1, 2, 3, 4, 9], offspring[0].variables[0])
self.assertEqual([2, 3, 4, 5, 6], offspring[0].variables[1])
self.assertEqual([1, 2, 3, 4, 7], offspring[1].variables[0])
self.assertEqual([2, 6, 4, 5, 3], offspring[1].variables[1])
def test_should_the_operator_work_with_permutation_at_the_beginning(self, random_call):
operator = PMXCrossover(1.0)
solution1 = PermutationSolution(number_of_variables=10, number_of_objectives=1)
solution1.variables = [i for i in range(10)]
solution2 = PermutationSolution(number_of_variables=10, number_of_objectives=1)
solution2.variables = [i for i in range(10, 20)]
random_call.side_effect = (0, 5)
offspring = operator.execute([solution1, solution2])
self.assertEqual([10, 11, 12, 13, 14, 5, 6, 7, 8, 9], offspring[0].variables)
self.assertEqual([0, 1, 2, 3, 4, 15, 16, 17, 18, 19], offspring[1].variables)
def execute(self, solution: PermutationSolution) -> PermutationSolution:
rand = random.random()
if rand <= self.probability:
point1 = random.randint(0, len(solution.variables))
point2 = random.randint(0, len(solution.variables) - 1)
if point2 >= point1:
point2 += 1
else:
point1, point2 = point2, point1
if point2 - point1 >= 20:
point2 = point1 + 20
values = solution.variables[point1:point2]
solution.variables[point1:point2] = random.sample(
values, len(values))
return solution
def execute(self, solution: PermutationSolution) -> PermutationSolution:
Check.that(
type(solution) is PermutationSolution, "Solution type invalid")
rand = random.random()
if rand <= self.probability:
if self.randMut == 1:
# pos_one, pos_two = random.sample(range(solution.number_of_variables - 1), 2)
# there is no use for the -1 above in the original algorithm
pos_one, pos_two = random.sample(
range(solution.number_of_variables), 2)
elif self.randMut == 2:
path = solution.variables
pos_one, pos_two, length = bestMutation2(
self.D, self.n, path, self.first)
solution.variables[pos_one], solution.variables[
pos_two] = solution.variables[pos_two], solution.variables[
pos_one]
return solution
def evaluate(self, solution: PermutationSolution) -> PermutationSolution:
self.metric.evaluate(
sort_update_actions(solution.variables, self.test_cases))
solution.objectives[0] = self.metric.fitness * -1.0
return solution
