def create_solution(self) -> FloatSolution: new_solution = FloatSolution(self.number_of_variables, self.number_of_objectives, self.number_of_constraints, self.lower_bound, self.upper_bound) new_solution.variables = \ [random.uniform(self.lower_bound[i]*1.0, self.upper_bound[i]*1.0) for i in range(self.number_of_variables)] return new_solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: value = solution.variables[0] solution.objectives[0] = value**2 solution.objectives[1] = (value - 2)**2 return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: value = solution.variables[0] solution.objectives[0] = value ** 2 solution.objectives[1] = (value - 2) ** 2 return solution
def evaluate_constraints(self, solution: FloatSolution) -> None: constraints = [0.0 for _ in range(self.number_of_constraints)] alpha = solution.variables[0] beta = solution.variables[1] delta = solution.variables[2] gamma = solution.variables[3] constraints[0] = (alpha + beta - 1) - tolerance constraints[1] = -(alpha + beta - 1) - tolerance constraints[2] = (delta + gamma - 1) - tolerance constraints[3] = -(delta + gamma - 1) - tolerance overall_constraint_violation = 0.0 number_of_violated_constraints = 0.0 for constrain in constraints: if constrain > 0.0: overall_constraint_violation += constrain number_of_violated_constraints += 1 # print("{} {}".format(overall_constraint_violation, number_of_violated_constraints)) solution.attributes[ 'overall_constraint_violation'] = overall_constraint_violation solution.attributes[ 'number_of_violated_constraints'] = number_of_violated_constraints
def evaluate_constraints(self, solution: FloatSolution) -> None: constraints = [0.0 for _ in range(self.number_of_constraints)] rho = solution.variables[0] nu = solution.variables[1] e = solution.variables[2] t = solution.variables[3] v = solution.variables[4] d = solution.variables[5] r = solution.variables[6] constraints[0] = rho - 1 constraints[1] = r + d + t + v + e - 1 - tolerance constraints[2] = 1 - (r - d - v - t - e) - tolerance overall_constraint_violation = 0.0 number_of_violated_constraints = 0.0 for constrain in constraints: if constrain > 0.0: overall_constraint_violation += constrain number_of_violated_constraints += 1 # print("{} {}".format(overall_constraint_violation, number_of_violated_constraints)) solution.attributes[ 'overall_constraint_violation'] = overall_constraint_violation solution.attributes[ 'number_of_violated_constraints'] = number_of_violated_constraints
def evaluate(self, solution: FloatSolution) -> FloatSolution: solution.objectives[0] = solution.variables[0] solution.objectives[1] = solution.variables[1] self.__evaluate_constraints(solution) return solution
def create_solution(self) -> CompositeSolution: # INICIALIZAÇÂO DO PROBLEMA attributes_solution = IntegerSolution(self.int_lower_bound_attribute, self.int_upper_bound_attribute, self.number_of_objectives, self.number_of_constraints) labels_solution = IntegerSolution(self.int_lower_bound_label, self.int_upper_bound_label, self.number_of_objectives, self.number_of_constraints) points_solution = FloatSolution(self.lower_centroids, self.upper_centroids, self.number_of_objectives, self.number_of_constraints) if self.isSeed: attributes_solution.variables = self.antecedentes labels_solution.variables = self.consequentes points_solution.variables = self.centroids self.isSeed = False else: attributes_solution.variables = \ [random.randint(self.int_lower_bound_attribute[i], self.int_upper_bound_attribute[i]) for i in range(len(self.int_lower_bound_attribute))] labels_solution.variables = \ [random.randint(self.int_lower_bound_label[i], self.int_upper_bound_label[i]) for i in range(len(self.int_lower_bound_label))] points_solution.variables = \ [random.uniform(self.lower_centroids[i], self.upper_centroids[i]) for i in range(len(self.lower_centroids))] return CompositeSolution([attributes_solution, labels_solution, points_solution])
def create_initial_solutions(self) -> List[S]: if self.problem.config.iteration_round == 0: # print(self.problem.config.iteration_round, self.population_size) return [ self.population_generator.new(self.problem) for _ in range(self.population_size) ] # return [self.problem.create_solution() for _ in range(self.population_size)] ## random generator else: population = [ self.population_generator.new(self.problem) for _ in range(int(0.5 * self.population_size)) ] # existing_population = [] for i in range(self.population_size - int(0.5 * self.population_size)): new_solution = FloatSolution( self.problem.lower_bound, self.problem.upper_bound, self.problem.number_of_objectives, self.problem.number_of_constraints) new_solution.variables = self.initial_population[ self.problem.config.goal_selection_index][i] # print(i, self.initial_population[self.problem.config.goal_selection_index][i]) population.append(new_solution) return population
def test_should_the_solution_remain_unchanged_if_the_probability_is_zero(self): operator = Polynomial(0.0) solution = FloatSolution(2, 1, 0, [-5, -5, -5], [5, 5, 5]) solution.variables = [1.0, 2.0, 3.0] mutated_solution = operator.execute(solution) self.assertEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def test_should_the_solution_change_if_the_probability_is_one(self): operator = SimpleRandomMutation(1.0) solution = FloatSolution([-5, -5, -5], [5, 5, 5], 1) solution.variables = [1.0, 2.0, 3.0] mutated_solution = operator.execute(solution) self.assertNotEqual([1.0, 2.0, 3.0], mutated_solution.variables)
def lorenz_map(swarm_size, number_of_variables, number_of_objectives, number_of_constraints, lower_bound, upper_bound): #lorenz map initialization chaos_limits = { "x_high": 22.0, "x_low": -22.0, "y_high": 30.0, "y_low": -30.0, "z_high": 55.0, "z_low": 0.0 } lorenz_sets = number_of_variables // 3 + 1 chaos_set = {} for it in range(lorenz_sets): chaos_set["xs_list_" + str(it + 1)] = [] chaos_set["ys_list_" + str(it + 1)] = [] chaos_set["zs_list_" + str(it + 1)] = [] dt = 0.02 xs = np.empty((swarm_size + 1)) ys = np.empty((swarm_size + 1)) zs = np.empty((swarm_size + 1)) xs[0], ys[0], zs[0] = (np.random.rand(), np.random.rand(), np.random.rand()) for i in range(swarm_size): # Derivatives of the X, Y, Z state x_dot, y_dot, z_dot = lorenz(xs[i], ys[i], zs[i]) xs[i + 1] = xs[i] + (x_dot * dt) ys[i + 1] = ys[i] + (y_dot * dt) zs[i + 1] = zs[i] + (z_dot * dt) chaos_set["xs_list_" + str(it + 1)].extend(xs) chaos_set["ys_list_" + str(it + 1)].extend(ys) chaos_set["zs_list_" + str(it + 1)].extend(zs) choices = list(chaos_set.keys()) #print(chaos_set) random.shuffle(choices) result = [] for i in range(swarm_size): temp = [] for i_1 in range(number_of_variables): temp.append(((chaos_set[choices[i_1]][i] - chaos_limits[choices[i_1][0] + "_low"]) / (chaos_limits[choices[i_1][0] + "_high"] - chaos_limits[choices[i_1][0] + "_low"])) * (upper_bound[i_1] - lower_bound[i_1]) + lower_bound[i_1]) #print(chaos_set[choices[i_1]][i],chaos_limits[choices[i_1][0]+"_low"],(chaos_limits[choices[i_1][0]+"_high"],upper_bound[i_1],lower_bound[i_1]),((chaos_set[choices[i_1]][i] - chaos_limits[choices[i_1][0]+"_low"])/(chaos_limits[choices[i_1][0]+"_high"] - chaos_limits[choices[i_1][0]+"_low"])) * (upper_bound[i_1] - lower_bound[i_1]) + lower_bound[i_1]) #input() #print(chaos_set[sel_list[i_1][0]+ "s_list_" + str(sel_list[i_1][1])][i_1]) new_solution = FloatSolution(number_of_variables, number_of_objectives, number_of_constraints, lower_bound, upper_bound) #print(temp) #input() new_solution.variables = temp result.append(new_solution) #print(temp) #print(result) return result
def evaluate(self, solution: FloatSolution) -> FloatSolution: g = self.__eval_g(solution) h = self.__eval_h(solution.variables[0], g) solution.objectives[0] = solution.variables[0] solution.objectives[1] = h * g return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x1 = solution.variables[0] x2 = solution.variables[1] solution.objectives[0] = 2.0 + (x1 - 2.0) * (x1 - 2.0) + (x2 - 1.0) * (x2 - 1.0) solution.objectives[1] = 9.0 * x1 - (x2 - 1.0) * (x2 - 1.0) return solution
def test_should_dominance_comparator_return_minus_one_if_the_two_solutions_have_one_objective_and_the_first_one_is_lower(self): solution = FloatSolution(3, 1, 0, [], []) solution2 = FloatSolution(3, 1, 0, [], []) solution.objectives = [1.0] solution2.objectives = [2.0] self.assertEqual(-1, self.comparator.compare(solution, solution2))
def test_should_dominance_comparator_return_zero_if_the_two_solutions_have_one_objective_with_the_same_value(self): solution = FloatSolution(3, 1, 0, [], []) solution2 = FloatSolution(3, 1, 0, [], []) solution.objectives = [1.0] solution2.objectives = [1.0] self.assertEqual(0, self.comparator.compare(solution, solution2))
def evaluate(self, solution: FloatSolution) -> FloatSolution: n = self.number_of_variables solution.objectives[0] = 1 - exp(-sum([(x - 1.0 / n**0.5)**2 for x in solution.variables])) solution.objectives[1] = 1 - exp(-sum([(x + 1.0 / n**0.5)**2 for x in solution.variables])) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: g = self.__eval_g(solution, self.M - 1) solution.objectives[0] = self.__eval_f1(solution, g) solution.objectives[1] = self.__eval_fk(solution, g, 2) solution.objectives[2] = self.__eval_fm(solution, g) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: EvaluationResult = Evaluation.evaluateNetwork(self.network, solution.variables) solution.objectives[0] = EvaluationResult[0] solution.objectives[1] = EvaluationResult[1] # solution.objectives[0] = solution.variables[0] # solution.objectives[1] = h * g return solution
def test_should_the_solution_change_between_max_and_min_value(self): operator = SimpleRandom(1.0) solution = FloatSolution(4, 1, 0, [-1, 12, -3, -5], [1, 17, 3, -2]) solution.variables = [-7.0, 3.0, 12.0, 13.4] mutated_solution = operator.execute(solution) for i in range(solution.number_of_variables): self.assertGreaterEqual(mutated_solution.variables[i], solution.lower_bound[i]) self.assertLessEqual(mutated_solution.variables[i], solution.upper_bound[i])
def evaluate(self, solution: FloatSolution) -> FloatSolution: x = solution.variables solution.objectives[0] = 1.7057 * x[0] * (10 * self.g1(x) + 1) solution.objectives[1] = 1.7957 * (1 - sqrt(x[0])) * (10 * self.g2(x) + 1) self.evaluate_constraints(solution) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x = solution.variables solution.objectives[0] = x[0] + self.g1(x) solution.objectives[1] = 1 - sqrt(x[0]) + self.g2(x) self.evaluate_constraints(solution) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: g = self.__eval_g(solution, self.M - 1) ft = 1.0 + 100.0 * pow(sin(0.5 * pi * self.time), 4.0) solution.objectives[0] = self.__eval_f1(solution, g, ft) solution.objectives[1] = self.__eval_fk(solution, g, 2, ft) solution.objectives[2] = self.__eval_fm(solution, g, ft) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: g = self.__eval_g(solution, self.limitInfII) h = self.__eval_h(solution.variables[0], g) solution.objectives[0] = self.__eval_f(solution, self.limitInfI, self.limitSupI) solution.objectives[1] = g * h return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: solution.objectives[0] = (1.0 - exp(-4.0 * solution.variables[0]) * (sin(6.0 * pi * solution.variables[0]))**6.0) g = self.eval_g(solution) h = self.eval_h(solution.objectives[0], g) solution.objectives[1] = h * g return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x = solution.variables solution.objectives[0] = x[0] + 10 * self.g1(x) + 0.7057 solution.objectives[1] = 1 - x[0] * x[0] + 10 * self.g2(x) + 7057 self.evaluate_constraints(solution) return solution
def create_solution(self) -> FloatSolution: new_solution = FloatSolution( self.lower_bound, self.lower_bound, number_of_objectives=self.number_of_objectives) new_solution.variables[0] = random.uniform(self.lower_bound[0], self.upper_bound[0]) return new_solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x = solution.variables solution.objectives[0] = 4.0 * x[0] * x[0] + 4 * x[1] * x[1] solution.objectives[1] = (x[0] - 5.0) * (x[0] - 5.0) + (x[1] - 5.0) * ( x[1] - 5.0) self.__evaluate_constraints(solution) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x = solution.variables solution.objectives[0] = (1.7057 + self.g1(x)) * cos(0.5 * pi * x[0]) * cos(0.5 * pi + x[1]) solution.objectives[1] = (1.7057 + self.g1(x)) * cos(0.5 * pi * x[0]) * sin(0.5 * pi + x[1]) solution.objectives[2] = (1.7057 + self.g1(x)) * sin(0.5 * pi + x[0]) self.evaluate_constraints(solution) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: solution.objectives[0] = 1 - math.exp(-1 * sum([ math.pow((solution.variables[i] - (1 / math.sqrt(3))), 2.0) for i in range(self.number_of_variables) ])) solution.objectives[1] = 1 - math.exp(-1 * sum([ math.pow((solution.variables[i] + (1 / math.sqrt(3))), 2.0) for i in range(self.number_of_variables) ])) return solution
def create_solution(self): """ Creates a new solution based on the bounds and variables. """ new_solution = FloatSolution(self.lower_bound, self.upper_bound, self.number_of_objectives, self.number_of_constraints) new_solution.variables = np.random.uniform( self.lower_bound, self.upper_bound, self.number_of_variables ).tolist( ) if not self._initial_solutions else self._initial_solutions.pop() return new_solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: g = self.eval_g(solution) solution.objectives[ 0] = 0.5 * solution.variables[0] * solution.variables[1] * (1 + g) solution.objectives[1] = 0.5 * solution.variables[0] * ( 1 - solution.variables[1]) * (1 + g) solution.objectives[2] = 0.5 * (1 - solution.variables[0]) * (1 + g) return solution
def test_should_the_solution_change__if_the_probability_is_one(self): operator = PolynomialMutation(1.0) solution = FloatSolution([-5, -5, -5], [5, 5, 5], 2) solution.variables = [1.0, 2.0, 3.0] FloatSolution.lower_bound = [-5, -5, -5] FloatSolution.upper_bound = [5, 5, 5] mutated_solution = operator.execute(solution) self.assertNotEqual([1.0, 2.0, 3.0], mutated_solution.variables)
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 = FloatSolution(3, 3, 0, [], []) solution2 = FloatSolution(3, 3, 0, [], []) 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 evaluate(self, solution: FloatSolution) -> FloatSolution: alpha = solution.variables[0] beta = solution.variables[1] constant_factor = solution.variables[-1] gamma = (constant_factor * alpha * escape_velocity) / radius solution.variables[2] = gamma delta = solution.variables[3] solution.objectives[0] = f1([alpha, beta]) solution.objectives[1] = f2([gamma, delta]) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: fx = [0.0 for _ in range(self.number_of_objectives)] for i in range(self.number_of_variables - 1): xi = solution.variables[i] * solution.variables[i] xj = solution.variables[i + 1] * solution.variables[i + 1] aux = -0.2 * sqrt(xi + xj) fx[0] += -10 * exp(aux) fx[1] += pow(abs(solution.variables[i]), 0.8) + 5.0 * sin(pow(solution.variables[i], 3.0)) solution.objectives[0] = fx[0] solution.objectives[1] = fx[1] return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: x0 = solution.variables[0] x1 = solution.variables[1] f1 = (x0 - 2) * (x0 - 2) / 2.0 + (x1 + 1) * (x1 + 1) / 13.0 + 3.0 f2 = (x0 + x1 - 3.0) * (x0 + x1 - 3.0) / 36.0 + (-x0 + x1 + 2.0) * (-x0 + x1 + 2.0) / 8.0 - 17.0 f3 = (x0 + 2 * x1 - 1) * (x0 + 2 * x1 - 1) / 175.0 + (2 * x1 - x0) * (2 * x1 - x0) / 17.0 - 13.0 solution.objectives[0] = f1 solution.objectives[1] = f2 solution.objectives[2] = f3 return solution
def execute(self, solution: FloatSolution) -> FloatSolution: for i in range(solution.number_of_variables): rand = random.random() if rand <= self.probability: solution.variables[i] = solution.lower_bound[i] + \ (solution.upper_bound[i] - solution.lower_bound[i]) * random.random() return solution
def execute(self, solution: FloatSolution) -> FloatSolution: for i in range(solution.number_of_variables): rand = random.random() if rand <= self.probability: y = solution.variables[i] yl, yu = solution.lower_bound[i], solution.upper_bound[i] if yl == yu: y = yl else: delta1 = (y - yl) / (yu - yl) delta2 = (yu - y) / (yu - yl) rnd = random.random() mut_pow = 1.0 / (self.distribution_index + 1.0) if rnd <= 0.5: xy = 1.0 - delta1 val = 2.0 * rnd + (1.0 - 2.0 * rnd) * (pow(xy, self.distribution_index + 1.0)) deltaq = pow(val, mut_pow) - 1.0 else: xy = 1.0 - delta2 val = 2.0 * (1.0 - rnd) + 2.0 * (rnd - 0.5) * (pow(xy, self.distribution_index + 1.0)) deltaq = 1.0 - pow(val, mut_pow) y += deltaq * (yu - yl) if y < solution.lower_bound[i]: y = solution.lower_bound[i] if y > solution.upper_bound[i]: y = solution.upper_bound[i] solution.variables[i] = y return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: total = 0.0 for x in solution.variables: total += x * x solution.objectives[0] = total return solution
def read_front_from_file_as_solutions(file_path: str) -> List[S]: """ Reads a front from a file and returns a list of solution objects. :return: List of solution objects. """ front = [] if Path(file_path).is_file(): with open(file_path) as file: for line in file: vector = [float(x) for x in line.split()] solution = FloatSolution(2, 2, 0, [], []) solution.objectives = vector front.append(solution) else: raise Exception('Reference front file was not found at {}'.format(file_path)) return front
def test_should_copy_work_properly(self) -> None: solution = FloatSolution(2, 3, 2, [0.0, 0.5], [1.0, 2.0]) solution.variables = [1.24, 2.66] solution.objectives = [0.16, -2.34, 9.25] solution.attributes["attr"] = "value" new_solution = copy.copy(solution) self.assertEqual(solution.number_of_variables, new_solution.number_of_variables) self.assertEqual(solution.number_of_objectives, new_solution.number_of_objectives) self.assertEqual(solution.number_of_constraints, new_solution.number_of_constraints) self.assertEqual(solution.variables, new_solution.variables) self.assertEqual(solution.objectives, new_solution.objectives) self.assertEqual(solution.lower_bound, new_solution.lower_bound) self.assertEqual(solution.upper_bound, new_solution.upper_bound) self.assertIs(solution.lower_bound, solution.lower_bound) self.assertIs(solution.upper_bound, solution.upper_bound) self.assertEqual({}, new_solution.attributes)
def evaluate_constraints(self, solution: FloatSolution) -> None: constraints = [0.0 for _ in range(self.number_of_constraints)] x1 = solution.variables[0] x2 = solution.variables[1] constraints[0] = (x1 * x1 + x2 * x2 - 1.0 - 0.1 * cos(16.0 * atan(x1 / x2))) constraints[1] = -2.0 * ((x1 - 0.5) * (x1 - 0.5) + (x2 - 0.5) * (x2 - 0.5) - 0.5) overall_constraint_violation = 0.0 number_of_violated_constraints = 0.0 for constrain in constraints: if constrain < 0.0: overall_constraint_violation += constrain number_of_violated_constraints += 1 solution.attributes['overall_constraint_violation'] = overall_constraint_violation solution.attributes['number_of_violated_constraints'] = number_of_violated_constraints
def evaluate_constraints(self, solution: FloatSolution) -> None: constraints = [0.0 for _ in range(self.number_of_constraints)] x1 = solution.variables[0] x2 = solution.variables[1] constraints[0] = 1.0 - (x1 * x1 + x2 * x2) / 225.0 constraints[1] = (3.0 * x2 - x1) / 10.0 - 1.0 overall_constraint_violation = 0.0 number_of_violated_constraints = 0.0 for constrain in constraints: if constrain < 0.0: overall_constraint_violation += constrain number_of_violated_constraints += 1 solution.attributes['overall_constraint_violation'] = overall_constraint_violation solution.attributes['number_of_violated_constraints'] = number_of_violated_constraints
def evaluate(self, solution: FloatSolution) -> FloatSolution: k = self.number_of_variables - self.number_of_objectives + 1 g = sum([(x - 0.5) * (x - 0.5) for x in solution.variables[self.number_of_variables - k:]]) solution.objectives = [1.0 + g] * self.number_of_objectives for i in range(self.number_of_objectives): for j in range(self.number_of_objectives - (i + 1)): solution.objectives[i] *= cos(solution.variables[j] * 0.5 * pi) if i != 0: solution.objectives[i] *= sin(0.5 * pi * solution.variables[self.number_of_objectives - (i + 1)]) return solution
def execute(self, solution: FloatSolution) -> FloatSolution: for i in range(solution.number_of_variables): rand = random.random() if rand <= self.probability: tmp = (random.random() - 0.5) * self.perturbation tmp += solution.variables[i] if tmp < solution.lower_bound[i]: tmp = solution.lower_bound[i] elif tmp > solution.upper_bound[i]: tmp = solution.upper_bound[i] solution.variables[i] = tmp return solution
def test_should_dominance_comparator_work_properly_with_constrains_case_2(self): """ Case 2: solution1 has a lower degree of constraint violation than solution 2 """ solution1 = FloatSolution(3, 3, 0, [], []) solution2 = FloatSolution(3, 3, 0, [], []) solution1.attributes["overall_constraint_violation"] = -0.3 solution2.attributes["overall_constraint_violation"] = -0.1 solution1.objectives = [-1.0, 5.0, 9.0] solution2.objectives = [-2.0, 5.0, 10.0] self.assertEqual(1, self.comparator.compare(solution1, solution2))
def evaluate(self, solution: FloatSolution) -> FloatSolution: k = self.number_of_variables - self.number_of_objectives + 1 g = sum([(x - 0.5) * (x - 0.5) - cos(20.0 * pi * (x - 0.5)) for x in solution.variables[self.number_of_variables - k:]]) g = 100 * (k + g) solution.objectives = [(1.0 + g) * 0.5] * self.number_of_objectives for i in range(self.number_of_objectives): for j in range(self.number_of_objectives - (i + 1)): solution.objectives[i] *= solution.variables[j] if i != 0: solution.objectives[i] *= 1 - solution.variables[self.number_of_objectives - (i + 1)] return solution
def evaluate(self, solution: FloatSolution): solution.objectives[0] = 1.2 solution.objectives[1] = 2.3 return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: n = self.number_of_variables solution.objectives[0] = 1 - exp(-sum([(x - 1.0 / n ** 0.5) ** 2 for x in solution.variables])) solution.objectives[1] = 1 - exp(-sum([(x + 1.0 / n ** 0.5) ** 2 for x in solution.variables])) return solution
def evaluate(self, solution: FloatSolution) -> FloatSolution: solution.objectives[0] = solution.variables[0] solution.objectives[1] = solution.variables[1] return solution