def optimal_solution(self, k, l, pos_params): """Create one Pareto-optimal solution with given position parameters.""" # the result vector result = [] result.extend(pos_params) # set the distance parameters for i in range(k, k + l): result.append(0.35) # scale to the correct domains for i in range(k + l): result[i] *= 2.0 * (i + 1) ind = Individual() ind.phenome = result return ind
def get_optimal_solutions(self, max_number=100): """Return Pareto-optimal solutions. .. note:: The returned solutions do not yet contain the objective values. Parameters ---------- max_number : int, optional As the number of Pareto-optimal solutions is infinite, the returned set has to be restricted to a finite sample. Returns ------- solutions : list of Individual The Pareto-optimal solutions """ assert max_number > 1 solutions = [] for i in range(max_number): phenome = [0.0] * self.num_variables phenome[0] = float(i) / float(max_number - 1) solutions.append(Individual(phenome)) return solutions
def get_optimal_solutions(self, max_number=None): """Return globally optimal solutions. Parameters ---------- max_number : int, optional Potentially restrict the number of optima. Returns ------- optima : list of Individual """ # test peaks optima = [] max_height = -1.0 opt_phenomes = [] for peak in self.peaks: if peak.height > max_height: opt_phenomes = [peak] max_height = peak.height elif peak.height == max_height: opt_phenomes.append(peak) for phenome in opt_phenomes: optima.append(Individual(phenome=list(phenome))) if max_number is not None: optima = optima[:max_number] return optima
def get_optimal_solutions(self, max_number=None): """Return Pareto-optimal solutions. .. note:: The returned solutions do not yet contain the objective values. Parameters ---------- max_number : int, optional Optionally restrict the number of solutions. Returns ------- solutions : list of Individual The Pareto-optimal solutions """ assert max_number is None or max_number > 0 individuals = [] for i in range(self.num_variables + 1): opt = Individual([1] * i + [0] * (self.num_variables - i)) individuals.append(opt) if max_number is not None: individuals = individuals[:max_number] return individuals
def optimal_solution(self, k, l, pos_params): """Create one Pareto-optimal solution with given position parameters.""" result = [] result.extend(pos_params) # calculate the distance parameters for i in range(k, k + l): w = [1.0] * len(result) u = r_sum(result, w) tmp1 = abs(math.floor(0.5 - u) + 0.98 / 49.98) tmp2 = 0.02 + 49.98 * (0.98 / 49.98 - (1.0 - 2.0 * u) * tmp1) result.append(pow(0.35, pow(tmp2, -1.0))) # scale to the correct domains for i in range(k + l): result[i] *= 2.0 * (i + 1) ind = Individual() ind.phenome = result return ind
def optimal_solution(self, k, l, pos_params): """Create one Pareto-optimal solution with given position parameters.""" result = [] result.extend(pos_params) result.extend([0.0] * l) # calculate the distance parameters result[k + l - 1] = 0.35 for i in range(k + l - 2, k - 1, -1): result_sub = [] for j in range(i + 1, k + l): result_sub.append(result[j]) w = [1.0] * len(result_sub) tmp1 = r_sum(result_sub, w) result[i] = pow(0.35, pow(0.02 + 1.96 * tmp1, -1.0)) # scale to the correct domains for i in range(k + l): result[i] *= 2.0 * (i + 1) ind = Individual() ind.phenome = result return ind
def get_optimal_solutions(self, max_number=None): """Return the optimal solution. .. note:: The returned solution does not yet contain the objective values. Returns ------- solutions : list of Individual """ assert max_number is None or max_number > 0 opt = Individual([1] * self.num_variables) return [opt]
def get_locally_optimal_solutions(self, max_number=None): """Return locally optimal solutions (includes global ones). Parameters ---------- max_number : int, optional Potentially restrict the number of optima. Returns ------- optima : list of Individual """ get_active_peak = self.get_active_peak # test peaks local_optima = [] peaks = np.vstack(self.peaks) for i, peak in enumerate(peaks): if get_active_peak(peak) is self.peaks[i]: local_optima.append(Individual(phenome=list(peak))) if max_number is not None: local_optima = local_optima[:max_number] return local_optima
def get_optimal_solutions(self, max_number=None): return [Individual(self.offsets[0][:self.num_variables])]