pymoo 0.6.1.5.dev0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

pymoo/problems/single/griewank.py

@@ -0,0 +1,18 @@
+import numpy as np
+import pymoo.gradient.toolbox as anp
+from pymoo.core.problem import Problem
+
+
+class Griewank(Problem):
+    def __init__(self, n_var=2):
+        super().__init__(n_var=n_var, n_obj=1, xl=-600, xu=600, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = 1 + 1 / 4000 * anp.sum(anp.power(x, 2), axis=1) \
+                  - anp.prod(anp.cos(x / anp.sqrt(anp.arange(1, x.shape[1] + 1))), axis=1)
+
+    def _calc_pareto_front(self):
+        return 0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 0)

pymoo/problems/single/himmelblau.py

@@ -0,0 +1,15 @@
+from pymoo.core.problem import Problem
+
+
+class Himmelblau(Problem):
+    def __init__(self, **kwargs):
+        super().__init__(n_var=2, n_obj=1, xl=-6, xu=6, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = (x[:, 0] ** 2 + x[:, 1] - 11) ** 2 + (x[:, 0] + x[:, 1] ** 2 - 7) ** 2
+
+    def _calc_pareto_front(self):
+        return 0
+
+    def _calc_pareto_set(self):
+        return [[3.0, 2.0], [-2.805118, 3.131312], [-3.779310, -3.283186], [3.584428, -1.848126]]

pymoo/problems/single/knapsack.py

@@ -0,0 +1,48 @@
+import numpy as np
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Knapsack(Problem):
+    def __init__(self,
+                 n_items,  # number of items that can be picked up
+                 W,  # weights for each item
+                 P,  # profit of each item
+                 C,  # maximum capacity
+                 ):
+        super().__init__(n_var=n_items, n_obj=1, n_ieq_constr=1, xl=0, xu=1, vtype=bool)
+
+        self.W = W
+        self.P = P
+        self.C = C
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = -np.sum(self.P * x, axis=1)
+        out["G"] = (np.sum(self.W * x, axis=1) - self.C)
+
+
+class MultiObjectiveKnapsack(Knapsack):
+    def __init__(self, *args):
+        super().__init__(*args)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = - np.sum(self.P * x, axis=1)
+        f2 = np.sum(x, axis=1)
+
+        out["F"] = np.column_stack([f1, f2])
+        out["G"] = (np.sum(self.W * x, axis=1) - self.C)
+
+
+def create_random_knapsack_problem(n_items, seed=1, variant="single"):
+    np.random.seed(seed)
+    P = np.random.randint(1, 100, size=n_items)
+    W = np.random.randint(1, 100, size=n_items)
+    C = int(np.sum(W) / 10)
+
+    if variant == "single":
+        problem = Knapsack(n_items, W, P, C)
+    else:
+        problem = MultiObjectiveKnapsack(n_items, W, P, C)
+
+    return problem

pymoo/problems/single/mopta08.py

@@ -0,0 +1,26 @@
+import os
+import subprocess
+
+import numpy as np
+
+from pymoo.core.problem import ElementwiseProblem
+
+
+class MOPTA08(ElementwiseProblem):
+    def __init__(self, exec):
+        super().__init__(n_var=124, n_obj=1, n_ieq_constr=68, xl=0, xu=1, vtype=float)
+        self.exec = exec
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        inputs = os.linesep.join([str(e) for e in x])
+        res = subprocess.run(self.exec, input=inputs, text=True, stdout=subprocess.PIPE)
+        val = np.array([float(e) for e in res.stdout.split()])
+        out["F"] = val[0]
+        out["G"] = val[1:]
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return 222.74
+
+
+
+

pymoo/problems/single/multimodal.py

@@ -0,0 +1,20 @@
+import pymoo.gradient.toolbox as anp
+
+from pymoo.core.problem import Problem
+
+
+class MultiModalSimple1(Problem):
+    def __init__(self, n_var=1):
+        super().__init__(n_var=n_var, n_obj=1, xl=0, xu=1, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = 1 - anp.exp(-x ** 2) * anp.sin(2 * anp.pi * x) ** 2
+
+
+class MultiModalSimple2(Problem):
+    def __init__(self, n_var=1):
+        super().__init__(n_var=n_var, n_obj=1, xl=-1, xu=0, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        x = - x
+        out["F"] = 1.1 - anp.exp(-2 * x) * anp.sin(5 * anp.pi * x) ** 2

pymoo/problems/single/pressure_vessel.py

@@ -0,0 +1,30 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class PressureVessel(Problem):
+    def __init__(self):
+        super().__init__(n_var=4, n_obj=1, n_ieq_constr=4, vtype=float)
+        self.xl = np.array([1, 1, 10.0, 10.0])
+        self.xu = np.array([99, 99, 200.0, 200.0])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+
+        d1, d2, r, L = x[:, 0]*0.0625, x[:, 1]*0.0625, x[:, 2], x[:, 3]
+
+        out["F"] = 0.6224*d1*r*L + 1.7781*d2*r**2 + 3.1661*d1**2*L + 19.84*d1**2*r
+
+        g1 = (-d1 + 0.0193*r)/3
+        g2 = (-d2 + 0.00954*r)/3
+        g3 = (-anp.pi * r ** 2 * L - 4 * anp.pi / 3 * r ** 3 + 1296000) / 1296000
+        g4 = (L - 240)/240
+
+        out["G"] = anp.column_stack([g1, g2, g3, g4])
+
+    def _calc_pareto_front(self):
+        return 5.8853e+03
+
+    def _calc_pareto_set(self):
+        return [13, 7, 42.0984456, 176.6366]

pymoo/problems/single/rastrigin.py

@@ -0,0 +1,20 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Rastrigin(Problem):
+    def __init__(self, n_var=2, A=10.0):
+        super().__init__(n_var=n_var, n_obj=1, xl=-5, xu=5, vtype=float)
+        self.A = A
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        z = anp.power(x, 2) - self.A * anp.cos(2 * anp.pi * x)
+        out["F"] = self.A * self.n_var + anp.sum(z, axis=1)
+
+    def _calc_pareto_front(self):
+        return 0.0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 0)

pymoo/problems/single/rosenbrock.py

@@ -0,0 +1,22 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Rosenbrock(Problem):
+    def __init__(self, n_var=2):
+        super().__init__(n_var=n_var, n_obj=1, n_ieq_constr=0, xl=-2.048, xu=2.048, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        l = []
+        for i in range(x.shape[1] - 1):
+            val = 100 * (x[:, i + 1] - x[:, i] ** 2) ** 2 + (1 - x[:, i]) ** 2
+            l.append(val)
+        out["F"] = anp.sum(anp.column_stack(l), axis=1)
+
+    def _calc_pareto_front(self):
+        return 0.0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 1.0)

pymoo/problems/single/schwefel.py

@@ -0,0 +1,18 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Schwefel(Problem):
+    def __init__(self, n_var=2):
+        super().__init__(n_var=n_var, n_obj=1, n_ieq_constr=0, xl=-500, xu=500, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = 418.9829 * self.n_var - anp.sum(x * anp.sin(anp.sqrt(anp.abs(x))), axis=1)
+
+    def _calc_pareto_front(self):
+        return 0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 420.9687)

pymoo/problems/single/simple.py

@@ -0,0 +1,13 @@
+import pymoo.gradient.toolbox as anp
+
+from pymoo.core.problem import Problem
+
+
+class SimpleMultiModal01(Problem):
+
+    def __init__(self):
+        super().__init__(n_var=2, n_obj=1, n_ieq_constr=0, xl=0, xu=1, vtype=float)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        x, y = X[:, 0], X[:, 1]
+        out["F"] = - anp.exp(-9 * abs(x * y)) * anp.sin(3 * anp.pi * x) ** 2 * anp.sin(3 * anp.pi * y) ** 2

pymoo/problems/single/sphere.py

@@ -0,0 +1,19 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Sphere(Problem):
+
+    def __init__(self, n_var=10):
+        super().__init__(n_var=n_var, n_obj=1, n_ieq_constr=0, xl=-0, xu=1, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = anp.sum(anp.square(x - 0.5), axis=1)
+
+    def _calc_pareto_front(self):
+        return 0.0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 0.5)

pymoo/problems/single/traveling_salesman.py

@@ -0,0 +1,79 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from scipy.spatial.distance import cdist
+
+from pymoo.core.problem import ElementwiseProblem
+
+
+class TravelingSalesman(ElementwiseProblem):
+
+    def __init__(self, cities, **kwargs):
+        """
+        A two-dimensional traveling salesman problem (TSP)
+
+        Parameters
+        ----------
+        cities : numpy.array
+            The cities with 2-dimensional coordinates provided by a matrix where city is represented by a row.
+
+        """
+        n_cities, _ = cities.shape
+
+        self.cities = cities
+        self.D = cdist(cities, cities)
+
+        super(TravelingSalesman, self).__init__(
+            n_var=n_cities,
+            n_obj=1,
+            xl=0,
+            xu=n_cities,
+            vtype=int,
+            **kwargs
+        )
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out['F'] = self.get_route_length(x)
+
+    def get_route_length(self, x):
+        n_cities = len(x)
+        dist = 0
+        for k in range(n_cities - 1):
+            i, j = x[k], x[k + 1]
+            dist += self.D[i, j]
+
+        last, first = x[-1], x[0]
+        dist += self.D[last, first]  # back to the initial city
+        return dist
+
+
+def create_random_tsp_problem(n_cities, grid_width=100.0, grid_height=None, seed=None):
+    if seed is not None:
+        np.random.seed(seed)
+    grid_height = grid_height if grid_height is not None else grid_width
+    cities = np.random.random((n_cities, 2)) * [grid_width, grid_height]
+    return TravelingSalesman(cities)
+
+
+def visualize(problem, x, fig=None, ax=None, show=True, label=True):
+    with plt.style.context('ggplot'):
+
+        if fig is None or ax is None:
+            fig, ax = plt.subplots()
+
+        # plot cities using scatter plot
+        ax.scatter(problem.cities[:, 0], problem.cities[:, 1], s=250)
+        if label:
+            # annotate cities
+            for i, c in enumerate(problem.cities):
+                ax.annotate(str(i), xy=c, fontsize=10, ha="center", va="center", color="white")
+
+        # plot the line on the path
+        for i in range(len(x)):
+            current = x[i]
+            next_ = x[(i + 1) % len(x)]
+            ax.plot(problem.cities[[current, next_], 0], problem.cities[[current, next_], 1], 'r--')
+
+        fig.suptitle("Route length: %.4f" % problem.get_route_length(x))
+
+        if show:
+            fig.show()

pymoo/problems/single/zakharov.py

@@ -0,0 +1,19 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Zakharov(Problem):
+    def __init__(self, n_var=2):
+        super().__init__(n_var=n_var, n_obj=1, xl=-10, xu=10, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        a = anp.sum(0.5 * anp.arange(1, self.n_var + 1) * x, axis=1)
+        out["F"] = anp.sum(anp.square(x), axis=1) + anp.square(a) + anp.power(a, 4)
+
+    def _calc_pareto_front(self):
+        return 0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 0)

pymoo/problems/static.py

@@ -0,0 +1,14 @@
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+
+
+class StaticProblem(Meta, Problem):
+
+    def __init__(self, problem, **kwargs):
+        super().__init__(problem)
+        self.kwargs = kwargs
+
+    def _evaluate(self, _, out, *args, **kwargs):
+        for K, V in self.kwargs.items():
+            out[K] = V
+

pymoo/problems/util.py

@@ -0,0 +1,42 @@
+import copy
+import os
+import types
+
+import numpy as np
+
+
+def decompose(problem, decomposition, weights, return_copy=True):
+    if return_copy:
+        problem = copy.deepcopy(problem)
+
+    problem._multi_evaluate = problem._evaluate
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        self._multi_evaluate(x, out, *args, **kwargs)
+        out["F"] = decomposition.do(out["F"], weights, _type="many_to_one")
+
+    problem._evaluate = types.MethodType(_evaluate, problem)
+    problem.n_obj = 1
+
+    return problem
+
+
+def load_pareto_front_from_file(fname):
+    current_dir = os.path.dirname(os.path.realpath(__file__))
+    fname = os.path.join(current_dir, "pf", "%s" % fname)
+    if os.path.isfile(fname):
+        pf = np.loadtxt(fname)
+        return pf[pf[:, 0].argsort()]
+
+
+def binomial(n, k):
+    if 0 <= k <= n:
+        ntok = 1
+        ktok = 1
+        for t in range(1, min(k, n - k) + 1):
+            ntok *= n
+            ktok *= t
+            n -= 1
+        return ntok // ktok
+    else:
+        return 0

pymoo/problems/zero_to_one.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+from pymoo.util.normalization import denormalize, normalize
+
+
+class ZeroToOne(Meta, Problem):
+
+    def __init__(self, problem):
+        super().__init__(problem)
+        assert self.xl is not None and self.xu is not None, "Both, xl and xu, must be set to redefine the problem!"
+        self.xl, self.xu = np.zeros(self.n_var), np.ones(self.n_var)
+
+    def do(self, X, return_values_of, *args, **kwargs):
+        Xp = self.normalize(X)
+
+        out = super().do(Xp, return_values_of, *args, **kwargs)
+        out["__X__"] = X
+
+        return out
+
+    def denormalize(self, x):
+        return denormalize(x, self.__object__.xl, self.__object__.xu)
+
+    def normalize(self, x):
+        return normalize(x, self.__object__.xl, self.__object__.xu)

pymoo/termination/__init__.py

@@ -0,0 +1,23 @@
+
+def get_termination(name, *args, **kwargs):
+    from pymoo.termination.default import DefaultMultiObjectiveTermination, DefaultSingleObjectiveTermination
+    from pymoo.termination.max_eval import MaximumFunctionCallTermination
+    from pymoo.termination.max_gen import MaximumGenerationTermination
+    from pymoo.termination.max_time import TimeBasedTermination
+    from pymoo.termination.fmin import MinimumFunctionValueTermination
+
+    TERMINATION = {
+        "n_eval": MaximumFunctionCallTermination,
+        "n_evals": MaximumFunctionCallTermination,
+        "n_gen": MaximumGenerationTermination,
+        "n_iter": MaximumGenerationTermination,
+        "fmin": MinimumFunctionValueTermination,
+        "time": TimeBasedTermination,
+        "soo": DefaultSingleObjectiveTermination,
+        "moo": DefaultMultiObjectiveTermination,
+    }
+
+    if name not in TERMINATION:
+        raise Exception("Termination not found.")
+
+    return TERMINATION[name](*args, **kwargs)

pymoo/termination/collection.py

@@ -0,0 +1,12 @@
+
+from pymoo.core.termination import Termination
+
+
+class TerminationCollection(Termination):
+
+    def __init__(self, *args) -> None:
+        super().__init__()
+        self.terminations = args
+
+    def _update(self, algorithm):
+        return max([termination.update(algorithm) for termination in self.terminations])

pymoo/termination/cv.py

@@ -0,0 +1,48 @@
+from pymoo.core.termination import Termination
+from pymoo.termination.delta import DeltaToleranceTermination
+
+
+class ConstraintViolationTermination(DeltaToleranceTermination):
+
+    def __init__(self, tol=1e-6, terminate_when_feasible=True, **kwargs):
+        super().__init__(tol, **kwargs)
+        self.terminate_when_feasible = terminate_when_feasible
+
+    def _update(self, algorithm):
+        if algorithm.problem.has_constraints():
+            feasible_found = any(algorithm.opt.get("feas"))
+
+            if feasible_found:
+                if self.terminate_when_feasible:
+                    return 1.0
+                else:
+                    return 0.0
+
+            else:
+                return super()._update(algorithm)
+        else:
+            return 0.0
+
+    def _delta(self, prev, current):
+        return max(0.0, prev - current)
+
+    def _data(self, algorithm):
+        return algorithm.opt.get("CV").min()
+
+
+class UntilFeasibleTermination(Termination):
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.initial_cv = None
+
+    def _update(self, algorithm):
+        cv = algorithm.opt.get("CV").min()
+
+        if self.initial_cv is None:
+            if cv <= 0:
+                self.initial_cv = 1e-32
+            else:
+                self.initial_cv = cv
+
+        return 1 - cv / self.initial_cv

pymoo/termination/default.py

@@ -0,0 +1,45 @@
+from pymoo.core.termination import Termination
+from pymoo.termination.cv import ConstraintViolationTermination
+from pymoo.termination.ftol import SingleObjectiveSpaceTermination, MultiObjectiveSpaceTermination
+from pymoo.termination.max_eval import MaximumFunctionCallTermination
+from pymoo.termination.max_gen import MaximumGenerationTermination
+from pymoo.termination.robust import RobustTermination
+from pymoo.termination.xtol import DesignSpaceTermination
+
+
+class DefaultTermination(Termination):
+
+    def __init__(self, x, cv, f, n_max_gen=1000, n_max_evals=100000) -> None:
+        super().__init__()
+        self.x = x
+        self.cv = cv
+        self.f = f
+
+        self.max_gen = MaximumGenerationTermination(n_max_gen)
+        self.max_evals = MaximumFunctionCallTermination(n_max_evals)
+
+        self.criteria = [self.x, self.cv, self.f, self.max_gen, self.max_evals]
+
+    def _update(self, algorithm):
+        p = [criterion.update(algorithm) for criterion in self.criteria]
+        return max(p)
+
+
+class DefaultSingleObjectiveTermination(DefaultTermination):
+
+    def __init__(self, xtol=1e-8, cvtol=1e-8, ftol=1e-6, period=30, **kwargs) -> None:
+        x = RobustTermination(DesignSpaceTermination(xtol), period=period)
+        cv = RobustTermination(ConstraintViolationTermination(cvtol, terminate_when_feasible=False), period=period)
+        f = RobustTermination(SingleObjectiveSpaceTermination(ftol, only_feas=True), period=period)
+        super().__init__(x, cv, f, **kwargs)
+
+
+class DefaultMultiObjectiveTermination(DefaultTermination):
+
+    def __init__(self, xtol=0.0005, cvtol=1e-8, ftol=0.005, n_skip=5, period=50, **kwargs) -> None:
+        x = RobustTermination(DesignSpaceTermination(tol=xtol, n_skip=n_skip), period)
+        cv = RobustTermination(ConstraintViolationTermination(cvtol, terminate_when_feasible=False, n_skip=n_skip), period)
+        f = RobustTermination(MultiObjectiveSpaceTermination(ftol, only_feas=True, n_skip=n_skip), period)
+        super().__init__(x, cv, f, **kwargs)
+
+

pymoo/termination/delta.py

@@ -0,0 +1,64 @@
+import math
+from abc import abstractmethod
+
+from pymoo.core.termination import Termination
+
+
+class DeltaToleranceTermination(Termination):
+
+    def __init__(self, tol, n_skip=0):
+        super().__init__()
+
+        # the tolerance threshold the difference (delta) to be under
+        assert tol >= 0
+        self.tol = tol
+
+        # the previous values to calculate the difference
+        self.data = None
+
+        # a counter of update calls
+        self.counter = 0
+
+        # whether some updates should be skipped
+        self.n_skip = n_skip
+
+    def _update(self, algorithm):
+
+        # the object from the previous iteration
+        prev = self.data
+
+        # and the one from the current iteration
+        current = self._data(algorithm)
+
+        # if there is no previous element to use
+        if prev is None:
+            perc = 0.0
+
+        elif self.counter > 0 and self.counter % (self.n_skip + 1) != 0:
+            perc = self.perc
+
+        else:
+            tol = self.tol
+            delta = self._delta(prev, current)
+
+            if delta <= tol:
+                return 1.0
+            else:
+                v = (delta - tol)
+                perc = 1 / (1 + v)
+
+        # remember the data from the current iteration and set it to data
+        self.data = current
+
+        # increase the function update counter
+        self.counter += 1
+
+        return perc
+
+    @abstractmethod
+    def _delta(self, prev, current):
+        pass
+
+    @abstractmethod
+    def _data(self, algorithm):
+        pass

pymoo/termination/fmin.py

@@ -0,0 +1,16 @@
+from pymoo.core.termination import Termination
+
+
+class MinimumFunctionValueTermination(Termination):
+
+    def __init__(self, fmin) -> None:
+        super().__init__()
+        self.fmin = fmin
+
+    def _update(self, algorithm):
+        opt = algorithm.opt
+
+        if not any(opt.get("feas")):
+            return 0.0
+        else:
+            return self.fmin / opt.get("F").min()