pymoo 0.6.1.5.dev0__cp39-cp39-musllinux_1_2_x86_64.whl

pymoo/core/result.py

@@ -0,0 +1,52 @@
+class Result:
+    """
+    The resulting object of an optimization run.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        self.opt = None
+        self.success = None
+        self.message = None
+
+        # ! other attributes to be set as well
+
+        # the problem that was solved
+        self.problem = None
+
+        # the archive stored during the run
+        self.archive = None
+
+        # the optimal solution for that problem
+        self.pf = None
+
+        # the algorithm that was used for optimization
+        self.algorithm = None
+
+        # the final population if it applies
+        self.pop = None
+
+        # directly the values of opt
+        self.X, self.F, self.CV, self.G, self.H = None, None, None, None, None
+
+        # all the timings that are stored of the run
+        self.start_time, self.end_time, self.exec_time = None, None, None
+
+        # the history of the optimization run is they were saved
+        self.history = []
+
+        # data stored within the algorithm
+        self.data = None
+
+    @property
+    def cv(self):
+        return self.CV[0]
+
+    @property
+    def f(self):
+        return self.F[0]
+
+    @property
+    def feas(self):
+        return self.cv <= 0

pymoo/core/sampling.py

@@ -0,0 +1,43 @@
+from abc import abstractmethod
+
+from pymoo.core.operator import Operator
+from pymoo.core.population import Population
+
+
+class Sampling(Operator):
+
+    def __init__(self) -> None:
+        """
+        This abstract class represents any sampling strategy that can be used to create an initial population or
+        an initial search point.
+        """
+        super().__init__()
+
+    def do(self, problem, n_samples, **kwargs):
+        """
+        Sample new points with problem information if necessary.
+
+        Parameters
+        ----------
+
+        problem : :class:`~pymoo.core.problem.Problem`
+            The problem to which points should be sampled. (lower and upper bounds, discrete, binary, ...)
+
+        n_samples : int
+            Number of samples
+
+        Returns
+        -------
+        pop : Population
+            The output population after sampling
+
+        """
+        val = self._do(problem, n_samples, **kwargs)
+        return Population.new("X", val)
+
+    @abstractmethod
+    def _do(self, problem, n_samples, **kwargs):
+        pass
+
+
+

pymoo/core/selection.py

@@ -0,0 +1,61 @@
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.operator import Operator
+
+
+class Selection(Operator):
+
+    def __init__(self, **kwargs) -> None:
+        """
+        This class is used to select parents for the mating or other evolutionary operators.
+        Several strategies can be used to increase the selection pressure.
+        """
+        super().__init__(**kwargs)
+
+    def do(self, problem, pop, n_select, n_parents, to_pop=True, **kwargs):
+        """
+        Choose from the population new individuals to be selected.
+
+        Parameters
+        ----------
+
+
+        problem: class
+            The problem to be solved. Provides information such as lower and upper bounds or feasibility
+            conditions for custom crossovers.
+
+        pop : :class:`~pymoo.core.population.Population`
+            The population which should be selected from. Some criteria from the design or objective space
+            might be used for the selection. Therefore, only the number of individual might be not enough.
+
+        n_select : int
+            Number of individuals to select.
+
+        n_parents : int
+            Number of parents needed to create an offspring.
+
+        to_pop : bool
+            Whether IF(!) the implementation returns only indices, it should be converted to individuals.
+
+        Returns
+        -------
+        parents : list
+            List of parents to be used in the crossover
+
+        """
+
+        ret = self._do(problem, pop, n_select, n_parents, **kwargs)
+
+        # if some selections return indices they are used to create the individual list
+        if to_pop and isinstance(ret, np.ndarray) and np.issubdtype(ret.dtype, np.integer):
+            ret = pop[ret]
+
+        return ret
+
+    @abstractmethod
+    def _do(self, problem, pop, n_select, n_parents, **kwargs):
+        pass
+
+

pymoo/core/solution.py

@@ -0,0 +1,10 @@
+from pymoo.core.individual import Individual
+from pymoo.core.population import Population
+
+
+class Solution(Individual):
+    pass
+
+
+class SolutionSet(Population):
+    pass

pymoo/core/survival.py

@@ -0,0 +1,103 @@
+from abc import abstractmethod
+
+import numpy as np
+
+from pymoo.core.population import Population
+
+
+# ---------------------------------------------------------------------------------------------------------
+# Survival
+# ---------------------------------------------------------------------------------------------------------
+
+
+class Survival:
+
+    def __init__(self, filter_infeasible=True):
+        super().__init__()
+        self.filter_infeasible = filter_infeasible
+
+    def do(self,
+           problem,
+           pop,
+           *args,
+           n_survive=None,
+           return_indices=False,
+           **kwargs):
+
+        # make sure the population has at least one individual
+        if len(pop) == 0:
+            return pop
+
+        if n_survive is None:
+            n_survive = len(pop)
+
+        n_survive = min(n_survive, len(pop))
+
+        # if the split should be done beforehand
+        if self.filter_infeasible and problem.has_constraints():
+
+            # split feasible and infeasible solutions
+            feas, infeas = split_by_feasibility(pop, sort_infeas_by_cv=True)
+
+            if len(feas) == 0:
+                survivors = Population()
+            else:
+                survivors = self._do(problem, pop[feas], *args, n_survive=min(len(feas), n_survive), **kwargs)
+
+            # calculate how many individuals are still remaining to be filled up with infeasible ones
+            n_remaining = n_survive - len(survivors)
+
+            # if infeasible solutions needs to be added
+            if n_remaining > 0:
+                survivors = Population.merge(survivors, pop[infeas[:n_remaining]])
+
+        else:
+            survivors = self._do(problem, pop, *args, n_survive=n_survive, **kwargs)
+
+        if return_indices:
+            H = {}
+            for k, ind in enumerate(pop):
+                H[ind] = k
+            return [H[survivor] for survivor in survivors]
+        else:
+            return survivors
+
+    @abstractmethod
+    def _do(self, problem, pop, *args, n_survive=None, **kwargs):
+        pass
+
+
+class ToReplacement(Survival):
+
+    def __init__(self, survival):
+        super().__init__(False)
+        self.survival = survival
+
+    def _do(self, problem, pop, off, **kwargs):
+        merged = Population.merge(pop, off)
+        I = self.survival.do(problem, merged, n_survive=len(merged), return_indices=True, **kwargs)
+        merged.set("__rank__", I)
+
+        for k in range(len(pop)):
+            if off[k].get("__rank__") < pop[k].get("__rank__"):
+                pop[k] = off[k]
+
+        return pop
+
+
+def split_by_feasibility(pop, sort_infeas_by_cv=True, sort_feas_by_obj=False, return_pop=False):
+    F, CV, b = pop.get("F", "CV", "FEAS")
+
+    feasible = np.where(b)[0]
+    infeasible = np.where(~b)[0]
+
+    if sort_infeas_by_cv:
+        infeasible = infeasible[np.argsort(CV[infeasible, 0])]
+
+    if sort_feas_by_obj:
+        feasible = feasible[np.argsort(F[feasible, 0])]
+
+    if not return_pop:
+        return feasible, infeasible
+    else:
+        return feasible, infeasible, pop[feasible], pop[infeasible]

pymoo/core/termination.py

@@ -0,0 +1,70 @@
+from abc import abstractmethod
+
+
+class Termination:
+
+    def __init__(self) -> None:
+        super().__init__()
+
+        # the algorithm can be forced to terminate by setting this attribute to true
+        self.force_termination = False
+
+        # the value indicating how much perc has been made
+        self.perc = 0.0
+
+    def update(self, algorithm):
+        """
+        Provide the termination criterion a current status of the algorithm to update the perc.
+
+        Parameters
+        ----------
+        algorithm : object
+            The algorithm object which is used to determine whether a run has terminated.
+        """
+
+        if self.force_termination:
+            progress = 1.0
+        else:
+            progress = self._update(algorithm)
+            assert progress >= 0.0, "Invalid progress was set by the TerminationCriterion."
+
+        self.perc = progress
+        return self.perc
+
+    def has_terminated(self):
+        return self.perc >= 1.0
+
+    def do_continue(self):
+        return not self.has_terminated()
+
+    def terminate(self):
+        self.force_termination = True
+
+    @abstractmethod
+    def _update(self, algorithm):
+        pass
+
+
+class NoTermination(Termination):
+
+    def _update(self, algorithm):
+        return 0.0
+
+
+class MultipleCriteria(Termination):
+
+    def __init__(self, *args) -> None:
+        super().__init__()
+        self.criteria = args
+
+
+class TerminateIfAny(MultipleCriteria):
+
+    def _update(self, algorithm):
+        return max([termination.update(algorithm) for termination in self.criteria])
+
+
+class TerminateIfAll(MultipleCriteria):
+
+    def _update(self, algorithm):
+        return min([termination.update(algorithm) for termination in self.criteria])