pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/problems/multi/mw.py

@@ -0,0 +1,400 @@
+import numpy as np
+
+from pymoo.core.problem import Problem
+# Based on the C++ implementation by the Ma and Wang
+# http://www.escience.cn/people/yongwang1/index.html
+from pymoo.problems.many import get_ref_dirs
+from pymoo.util.remote import Remote
+
+
+class MW(Problem):
+    def __init__(self, n_var, n_obj, n_ieq_constr, **kwargs):
+        if 'xl' not in kwargs:
+            kwargs['xl'] = 0
+        if 'xu' not in kwargs:
+            kwargs['xu'] = 1
+        super().__init__(n_var=n_var,
+                         n_obj=n_obj,
+                         n_ieq_constr=n_ieq_constr,
+                         vtype=float, **kwargs)
+
+    @staticmethod
+    def LA1(A, B, C, D, theta):
+        return A * np.power(np.sin(B * np.pi * np.power(theta, C)), D)
+
+    @staticmethod
+    def LA2(A, B, C, D, theta):
+        return A * np.power(np.sin(B * np.power(theta, C)), D)
+
+    @staticmethod
+    def LA3(A, B, C, D, theta):
+        return A * np.power(np.cos(B * np.power(theta, C)), D)
+
+    def g1(self, X):
+        d = self.n_var
+        n = d - self.n_obj
+
+        z = np.power(X[:, self.n_obj - 1:], n)
+        i = np.arange(self.n_obj - 1, d)
+
+        exp = 1 - np.exp(-10.0 * (z - 0.5 - i / (2 * d)) * (z - 0.5 - i / (2 * d)))
+        distance = 1 + exp.sum(axis=1)
+        return distance
+
+    def g2(self, X):
+        d = self.n_var
+        n = d
+
+        i = np.arange(self.n_obj - 1, d)
+        z = 1 - np.exp(-10.0 * (X[:, self.n_obj - 1:] - i / n) * (X[:, self.n_obj - 1:] - i / n))
+        contrib = (0.1 / (n)) * z * z + 1.5 - 1.5 * np.cos(2 * np.pi * z)
+        distance = 1 + contrib.sum(axis=1)
+        return distance
+
+    def g3(self, X):
+        contrib = 2.0 * np.power(
+            X[:, self.n_obj - 1:] + (X[:, self.n_obj - 2:-1] - 0.5) * (X[:, self.n_obj - 2:-1] - 0.5) - 1.0, 2.0)
+        distance = 1 + contrib.sum(axis=1)
+        return distance
+
+
+class MW1(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+        f0 = X[:, 0]
+        f1 = g * (1 - 0.85 * f0 / g)
+
+        g0 = f0 + f1 - 1 - self.LA1(0.5, 2.0, 1.0, 8.0, np.sqrt(2.0) * f1 - np.sqrt(2.0) * f0)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            F = np.zeros((100, 2))
+            F[:, 0] = np.linspace(0, 1, 100)
+        else:
+            F = ref_dirs
+        F[:, 1] = 1 - 0.85 * F[:, 0]
+        l = np.sqrt(2) * F[:, 1] - np.sqrt(2) * F[:, 0]
+        c = 1 - F[:, 0] - F[:, 1] + 0.5 * np.sin(2 * np.pi * l) ** 8
+        F = F[c >= 0]
+        return F
+
+
+class MW2(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        f0 = X[:, 0]
+        f1 = g * (1 - f0 / g)
+
+        g0 = f0 + f1 - 1 - self.LA1(0.5, 3.0, 1.0, 8.0, np.sqrt(2.0) * f1 - np.sqrt(2.0) * f0)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            F = np.zeros((100, 2))
+            F[:, 0] = np.linspace(0, 1, 100)
+        else:
+            F = ref_dirs
+        F[:, 1] = 1 - F[:, 0]
+        return F
+
+
+class MW3(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 2)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g3(X)
+        f0 = X[:, 0]
+        f1 = g * (1 - f0 / g)
+
+        g0 = f0 + f1 - 1.05 - self.LA1(0.45, 0.75, 1.0, 6.0, np.sqrt(2.0) * f1 - np.sqrt(2.0) * f0)
+        g1 = 0.85 - f0 - f1 + self.LA1(0.3, 0.75, 1.0, 2.0, np.sqrt(2.0) * f1 - np.sqrt(2.0) * f0)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1])
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            F = np.zeros((100, 2))
+            F[:, 0] = np.linspace(0, 1, 100)
+        else:
+            F = ref_dirs
+        F[:, 1] = 1 - F[:, 0]
+        invalid = (0.85 - F[:, 0] - F[:, 1] + 0.3 * np.sin(0.75 * np.pi * np.sqrt(2) * (F[:, 1] - F[:, 0])) ** 2) > 0
+        while invalid.any():
+            F[invalid, :] *= 1.001
+            invalid = (0.85 - F[:, 0] - F[:, 1] + 0.3 * np.sin(
+                0.75 * np.pi * np.sqrt(2) * (F[:, 1] - F[:, 0])) ** 2) > 0
+        return F
+
+
+class MW4(MW):
+    def __init__(self, n_var=None, n_obj=3, **kwargs):
+        if n_var is None:
+            n_var = n_obj + 12
+        super().__init__(n_var, n_obj, 1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+        f = g.reshape((-1, 1)) * np.ones((X.shape[0], self.n_obj))
+        f[:, 1:] *= X[:, (self.n_obj - 2)::-1]
+        f[:, 0:-1] *= np.flip(np.cumprod(1 - X[:, :(self.n_obj - 1)], axis=1), axis=1)
+
+        g0 = f.sum(axis=1) - 1 - self.LA1(0.4, 2.5, 1.0, 8.0, f[:, -1] - f[:, :-1].sum(axis=1))
+        out["F"] = f
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+        F = ref_dirs
+        l = F[:, -1] - np.sum(F[:, :-1], axis=1)
+        c = (1 + 0.4 * np.sin(2.5 * np.pi * l) ** 8) - np.sum(F, axis=1)
+        return F[c >= 0]
+
+
+class MW5(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 3)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+        f0 = g * X[:, 0]
+        f1 = g * np.sqrt(1.0 - np.power(f0 / g, 2.0))
+
+        with np.errstate(divide='ignore'):
+            atan = np.arctan(f1 / f0)
+
+        g0 = f0 ** 2 + f1 ** 2 - np.power(1.7 - self.LA2(0.2, 2.0, 1.0, 1.0, atan), 2.0)
+        t = 0.5 * np.pi - 2 * np.abs(atan - 0.25 * np.pi)
+        g1 = np.power(1 + self.LA2(0.5, 6.0, 3.0, 1.0, t), 2.0) - f0 ** 2 - f1 ** 2
+        g2 = np.power(1 - self.LA2(0.45, 6.0, 3.0, 1.0, t), 2.0) - f0 ** 2 - f1 ** 2
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1, g2])
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW5.pf")
+
+
+class MW6(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 1, xl=0.0, xu=1.1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        f0 = g * X[:, 0]
+        f1 = g * np.sqrt(1.1 * 1.1 - np.power(f0 / g, 2.0))
+
+        with np.errstate(divide='ignore'):
+            atan = np.arctan(f1 / f0)
+
+        g0 = f0 ** 2 / np.power(1.0 + self.LA3(0.15, 6.0, 4.0, 10.0, atan), 2.0) + f1 ** 2 / np.power(
+            1.0 + self.LA3(0.75, 6.0, 4.0, 10.0, atan), 2.0) - 1
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            F = np.zeros((100, 2))
+            F[:, 0] = np.linspace(0, 1, 100)
+        else:
+            F = ref_dirs
+        F[:, 1] = 1 - F[:, 0]
+        F = F / np.sqrt(np.sum(F ** 2, axis=1) / 1.21).reshape((-1, 1))
+        l = np.cos(6 * np.arctan(F[:, 1] / F[:, 0]) ** 4) ** 10
+        c = 1 - (F[:, 0] / (1 + 0.15 * l)) ** 2 - (F[:, 1] / (1 + 0.75 * l)) ** 2
+        return F[c >= 0]
+
+
+class MW7(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 2)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g3(X)
+        f0 = g * X[:, 0]
+        f1 = g * np.sqrt(1 - np.power(f0 / g, 2))
+
+        with np.errstate(divide='ignore'):
+            atan = np.arctan(f1 / f0)
+
+        g0 = f0 ** 2 + f1 ** 2 - np.power(1.2 + np.abs(self.LA2(0.4, 4.0, 1.0, 16.0, atan)), 2.0)
+        g1 = np.power(1.15 - self.LA2(0.2, 4.0, 1.0, 8.0, atan), 2.0) - f0 ** 2 - f1 ** 2
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1])
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW7.pf")
+
+
+class MW8(MW):
+    def __init__(self, n_var=None, n_obj=3, **kwargs):
+        if n_var is None:
+            n_var = n_obj + 12
+        super().__init__(n_var, n_obj, 1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        f = g.reshape((-1, 1)) * np.ones((X.shape[0], self.n_obj))
+        f[:, 1:] *= np.sin(0.5 * np.pi * X[:, (self.n_obj - 2)::-1])
+        cos = np.cos(0.5 * np.pi * X[:, :(self.n_obj - 1)])
+        f[:, 0:-1] *= np.flip(np.cumprod(cos, axis=1), axis=1)
+
+        f_squared = (f ** 2).sum(axis=1)
+        g0 = f_squared - (1.25 - self.LA2(0.5, 6.0, 1.0, 2.0, np.arcsin(f[:, -1] / np.sqrt(f_squared)))) * (
+                1.25 - self.LA2(0.5, 6.0, 1.0, 2.0, np.arcsin(f[:, -1] / np.sqrt(f_squared))))
+        out["F"] = f
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            ref_dirs = get_ref_dirs(self.n_obj)
+
+        F = ref_dirs
+        F = F / np.sqrt(np.sum(F ** 2, axis=1)).reshape((-1, 1))
+        c = (1.25 - 0.5 * np.sin(6 * np.arcsin(F[:, -1])) ** 2) ** 2 - np.sum(F ** 2, axis=1)
+        return F[c >= 0]
+
+
+class MW9(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 1)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+        f0 = g * X[:, 0]
+        f1 = g * (1.0 - np.power(f0 / g, 0.6))
+
+        t1 = (1 - 0.64 * f0 * f0 - f1) * (1 - 0.36 * f0 * f0 - f1)
+        t2 = (1.35 * 1.35 - (f0 + 0.35) * (f0 + 0.35) - f1) * (1.15 * 1.15 - (f0 + 0.15) * (f0 + 0.15) - f1)
+        g0 = np.minimum(t1, t2)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW9.pf")
+
+
+class MW10(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 3)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        f0 = g * np.power(X[:, 0], self.n_var)
+        f1 = g * (1.0 - np.power(f0 / g, 2.0))
+
+        g0 = -1.0 * (2.0 - 4.0 * f0 * f0 - f1) * (2.0 - 8.0 * f0 * f0 - f1)
+        g1 = (2.0 - 2.0 * f0 * f0 - f1) * (2.0 - 16.0 * f0 * f0 - f1)
+        g2 = (1.0 - f0 * f0 - f1) * (1.2 - 1.2 * f0 * f0 - f1)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1, g2])
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW10.pf")
+
+
+class MW11(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 4, xl=0.0, xu=np.sqrt(2))
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g3(X)
+        f0 = g * X[:, 0]
+        f1 = g * np.sqrt(2.0 - np.power(f0 / g, 2.0))
+
+        g0 = -1.0 * (3.0 - f0 * f0 - f1) * (3.0 - 2.0 * f0 * f0 - f1)
+        g1 = (3.0 - 0.625 * f0 * f0 - f1) * (3.0 - 7.0 * f0 * f0 - f1)
+        g2 = -1.0 * (1.62 - 0.18 * f0 * f0 - f1) * (1.125 - 0.125 * f0 * f0 - f1)
+        g3 = (2.07 - 0.23 * f0 * f0 - f1) * (0.63 - 0.07 * f0 * f0 - f1)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1, g2, g3])
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW11.pf")
+
+
+class MW12(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 2)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+        f0 = g * X[:, 0]
+        f1 = g * (0.85 - 0.8 * (f0 / g) - 0.08 * np.abs(np.sin(3.2 * np.pi * (f0 / g))))
+
+        g0 = -1.0 * (1 - 0.625 * f0 - f1 + 0.08 * np.sin(2 * np.pi * (f1 - f0 / 1.6))) * (
+                1.4 - 0.875 * f0 - f1 + 0.08 * np.sin(2 * np.pi * (f1 / 1.4 - f0 / 1.6)))
+        g1 = (1 - 0.8 * f0 - f1 + 0.08 * np.sin(2 * np.pi * (f1 - f0 / 1.5))) * (
+                1.8 - 1.125 * f0 - f1 + 0.08 * np.sin(2 * np.pi * (f1 / 1.8 - f0 / 1.6)))
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1])
+
+    def _calc_pareto_front(self, ref_dirs=None):
+        if ref_dirs is None:
+            F = np.zeros((100, 2))
+            F[:, 0] = np.linspace(0, 1, 100)
+        else:
+            F = ref_dirs
+        F[:, 1] = 0.85 - 0.8 * F[:, 0] - 0.08 * np.abs(np.sin(3.2 * np.pi * F[:, 0]))
+
+        invalid = (1 - 0.8 * F[:, 0] - F[:, 1] + 0.08 * np.sin(2 * np.pi * (F[:, 1] - F[:, 0] / 1.5))) * (
+                1.8 - 1.125 * F[:, 0] - F[:, 1] + 0.08 * np.sin(2 * np.pi * (F[:, 1] / 1.8 - F[:, 0] / 1.6))) > 0
+        while invalid.any():
+            F[invalid, :] *= 1.001
+            invalid = (1 - 0.8 * F[:, 0] - F[:, 1] + 0.08 * np.sin(2 * np.pi * (F[:, 1] - F[:, 0] / 1.5))) * (
+                    1.8 - 1.125 * F[:, 0] - F[:, 1] + 0.08 * np.sin(
+                2 * np.pi * (F[:, 1] / 1.8 - F[:, 0] / 1.6))) > 0
+        return F
+
+
+class MW13(MW):
+    def __init__(self, n_var=15, **kwargs):
+        super().__init__(n_var, 2, 2, xu=1.5)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        f0 = g * X[:, 0]
+        f1 = g * (5.0 - np.exp(f0 / g) - np.abs(0.5 * np.sin(3 * np.pi * f0 / g)))
+
+        g0 = -1.0 * (5.0 - (1 + f0 + 0.5 * f0 * f0) - 0.5 * np.sin(3 * np.pi * f0) - f1) * (
+                5.0 - (1 + 0.7 * f0) - 0.5 * np.sin(3 * np.pi * f0) - f1)
+        g1 = (5.0 - np.exp(f0) - 0.5 * np.sin(3 * np.pi * f0) - f1) * (
+                5.0 - (1 + 0.4 * f0) - 0.5 * np.sin(3 * np.pi * f0) - f1)
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = np.column_stack([g0, g1])
+
+    def _calc_pareto_front(self, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "MW", "MW13.pf")
+
+
+class MW14(MW):
+    def __init__(self, n_var=None, n_obj=3, **kwargs):
+        if n_var is None:
+            n_var = n_obj + 12
+        super().__init__(n_var, n_obj, 1, xu=1.5)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g3(X)
+        f = np.zeros((X.shape[0], self.n_obj))
+        f[:, :-1] = X[:, :(self.n_obj - 1)]
+        LA1 = self.LA1(1.5, 1.1, 2.0, 1.0, f[:, :-1])
+        inter = (6 - np.exp(f[:, :-1]) - LA1).sum(axis=1)
+        f[:, -1] = g / (self.n_obj - 1) * inter
+
+        alpha = 6.1 - 1 - f[:, :-1] - 0.5 * f[:, :-1] * f[:, :-1] - LA1
+        g0 = f[:, -1] - 1 / (self.n_obj - 1) * alpha.sum(axis=1)
+        out["F"] = f
+        out["G"] = g0.reshape((-1, 1))
+
+    def _calc_pareto_front(self, **kwargs):
+        if self.n_obj == 3:
+            return Remote.get_instance().load("pymoo", "pf", "MW", "MW14.pf")

pymoo/problems/multi/omnitest.py

@@ -0,0 +1,48 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class OmniTest(Problem):
+    """
+    The Omni-test problem proposed by Deb in [1].
+
+    Parameters
+    ----------
+    n_var: number of decision variables
+
+    References
+    ----------
+    [1] Deb, K., Tiwari, S. "Omni-optimizer: A generic evolutionary algorithm for single and multi-objective optimization"
+    """
+    def __init__(self, n_var=2):
+        assert (n_var >= 2), "The dimension of the decision space should at least be 2!"
+        super().__init__(
+            n_var=n_var, n_obj=2, vtype=float, xl=np.full(n_var, 0), xu=np.full(n_var, 6)
+        )
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        F1 = anp.sum(anp.sin(anp.pi * X), axis=1)
+        F2 = anp.sum(anp.cos(anp.pi * X), axis=1)
+        out["F"] = anp.vstack((F1, F2)).T
+
+    def _calc_pareto_set(self, n_pareto_points=500):
+        # The Omni-test problem has 3^D Pareto subsets
+        num_ps = int(3 ** self.n_var)
+        h = int(n_pareto_points / num_ps)
+        PS = np.zeros((num_ps * h, self.n_var))
+
+        candidates = np.array([np.linspace(2 * m + 1, 2 * m + 3 / 2, h) for m in range(3)])
+        # generate combination indices
+        candidates_indices = [[0, 1, 2] for _ in range(self.n_var)]
+        a = np.meshgrid(*candidates_indices)
+        combination_indices = np.array(a).T.reshape(-1, self.n_var)
+        # generate 3^D combinations
+        for i in range(num_ps):
+            PS[i * h:i * h + h, :] = candidates[combination_indices[i]].T
+        return PS
+
+    def _calc_pareto_front(self, n_pareto_points=500):
+        PS = self._calc_pareto_set(n_pareto_points)
+        return self.evaluate(PS, return_values_of=["F"])

pymoo/problems/multi/osy.py

@@ -0,0 +1,32 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+class OSY(Problem):
+    def __init__(self):
+        super().__init__(n_var=6, n_obj=2, n_ieq_constr=6, vtype=float)
+        self.xl = np.array([0.0, 0.0, 1.0, 0.0, 1.0, 0.0])
+        self.xu = np.array([10.0, 10.0, 5.0, 6.0, 5.0, 10.0])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = - (25 * (x[:, 0] - 2) ** 2 + (x[:, 1] - 2) ** 2 + (x[:, 2] - 1) ** 2 + (x[:, 3] - 4) ** 2 + (
+                x[:, 4] - 1) ** 2)
+        f2 = anp.sum(anp.square(x), axis=1)
+
+        g1 = (x[:, 0] + x[:, 1] - 2.0) / 2.0
+        g2 = (6.0 - x[:, 0] - x[:, 1]) / 6.0
+        g3 = (2.0 - x[:, 1] + x[:, 0]) / 2.0
+        g4 = (2.0 - x[:, 0] + 3.0 * x[:, 1]) / 2.0
+        g5 = (4.0 - (x[:, 2] - 3.0) ** 2 - x[:, 3]) / 4.0
+        g6 = ((x[:, 4] - 3.0) ** 2 + x[:, 5] - 4.0) / 4.0
+
+        out["F"] = anp.column_stack([f1, f2])
+
+        out["G"] = anp.column_stack([g1, g2, g3, g4, g5, g6])
+        out["G"] = - out["G"]
+
+    def _calc_pareto_front(self):
+        return Remote.get_instance().load("pymoo", "pf", "osy.pf")

pymoo/problems/multi/srn.py

@@ -0,0 +1,28 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class SRN(Problem):
+    def __init__(self):
+        super().__init__(n_var=2, n_obj=2, n_ieq_constr=2, xl=-20, xu=+20, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = 2 + (x[:, 0] - 2) ** 2 + (x[:, 1] - 1) ** 2
+        f2 = 9 * x[:, 0] - (x[:, 1] - 1) ** 2
+
+        g1 = x[:, 0] ** 2 + x[:, 1] ** 2 - 225
+        g2 = x[:, 0] - 3 * x[:, 1] + 10
+
+        out["F"] = anp.column_stack([f1, f2])
+        out["G"] = anp.column_stack([g1, g2])
+
+    def _calc_pareto_front(self, *args, n_points=100, **kwargs):
+        ps = self.pareto_set(n_points=n_points)
+        return self.evaluate(ps, return_values_of=["F"])
+
+    def _calc_pareto_set(self, *args, n_points=100, **kwargs):
+        x1 = np.full(n_points, -2.5)
+        x2 = np.linspace(2.5, 14.7902, n_points)
+        return np.column_stack([x1, x2])

pymoo/problems/multi/sympart.py

@@ -0,0 +1,94 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+
+from pymoo.core.problem import Problem
+
+
+class SYMPARTRotated(Problem):
+    """
+    The SYM-PART test problem proposed in [1].
+
+    Parameters:
+    -----------
+    length: the length of each line (i.e., each Pareto subsets), default is 1.
+    v_dist: vertical distance between the centers of two adjacent lines, default is 10.
+    h_dist: horizontal distance between the centers of two adjacent lines, default is 10.
+    angle: the angle to rotate the equivalent Pareto subsets counterclockwisely.
+        When set to a negative value, Pareto subsets are rotated clockwisely.
+
+    References:
+    ----------
+    [1] G. Rudolph, B. Naujoks, and M. Preuss, “Capabilities of EMOA to detect and preserve equivalent Pareto subsets”
+    """
+
+    def __init__(self, length=1, v_dist=10, h_dist=10, angle=np.pi / 4):
+        self.a = length
+        self.b = v_dist
+        self.c = h_dist
+        self.w = angle
+
+        # Calculate the inverted rotation matrix, store for fitness evaluation
+        self.IRM = np.array([
+            [np.cos(self.w), np.sin(self.w)],
+            [-np.sin(self.w), np.cos(self.w)]])
+
+        r = max(self.b, self.c)
+        xl = np.full(2, -10 * r)
+        xu = np.full(2, 10 * r)
+
+        super().__init__(n_var=2, n_obj=2, vtype=float, xl=xl, xu=xu)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        if self.w == 0:
+            X1 = X[:, 0]
+            X2 = X[:, 1]
+        else:
+            # If rotated, we rotate it back by applying the inverted rotation matrix to X
+            Y = anp.array([anp.matmul(self.IRM, x) for x in X])
+            X1 = Y[:, 0]
+            X2 = Y[:, 1]
+
+        a, b, c = self.a, self.b, self.c
+        t1_hat = anp.sign(X1) * anp.ceil((anp.abs(X1) - a - c / 2) / (2 * a + c))
+        t2_hat = anp.sign(X2) * anp.ceil((anp.abs(X2) - b / 2) / b)
+        one = anp.ones(len(X))
+        t1 = anp.sign(t1_hat) * anp.min(anp.vstack((anp.abs(t1_hat), one)), axis=0)
+        t2 = anp.sign(t2_hat) * anp.min(anp.vstack((anp.abs(t2_hat), one)), axis=0)
+
+        p1 = X1 - t1 * c
+        p2 = X2 - t2 * b
+
+        f1 = (p1 + a) ** 2 + p2 ** 2
+        f2 = (p1 - a) ** 2 + p2 ** 2
+        out["F"] = anp.vstack((f1, f2)).T
+
+    def _calc_pareto_set(self, n_pareto_points=500):
+        # The SYM-PART test problem has 9 equivalent Pareto subsets.
+        h = int(n_pareto_points / 9)
+        PS = np.zeros((h * 9, self.n_var))
+        cnt = 0
+        for row in [-1, 0, 1]:
+            for col in [1, 0, -1]:
+                X1 = np.linspace(row * self.c - self.a, row * self.c + self.a, h)
+                X2 = np.tile(col * self.b, h)
+                PS[cnt * h:cnt * h + h, :] = np.vstack((X1, X2)).T
+                cnt = cnt + 1
+        if self.w != 0:
+            # If rotated, we apply the rotation matrix to PS
+            # Calculate the rotation matrix
+            RM = np.array([
+                [np.cos(self.w), -np.sin(self.w)],
+                [np.sin(self.w), np.cos(self.w)]
+            ])
+            PS = np.array([np.matmul(RM, x) for x in PS])
+        return PS
+
+    def _calc_pareto_front(self, n_pareto_points=500):
+        PS = self.pareto_set(n_pareto_points)
+        return self.evaluate(PS, return_values_of=["F"])
+
+
+class SYMPART(SYMPARTRotated):
+    def __init__(self, length=1, v_dist=10, h_dist=10):
+        super().__init__(length, v_dist, h_dist, 0)

pymoo/problems/multi/tnk.py

@@ -0,0 +1,24 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+class TNK(Problem):
+    def __init__(self):
+        super().__init__(n_var=2, n_obj=2, n_ieq_constr=2, vtype=float)
+        self.xl = np.array([0, 1e-30])
+        self.xu = np.array([np.pi, np.pi])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        f2 = x[:, 1]
+        g1 = -(anp.square(x[:, 0]) + anp.square(x[:, 1]) - 1.0 - 0.1 * anp.cos(16.0 * anp.arctan(x[:, 0] / x[:, 1])))
+        g2 = 2 * (anp.square(x[:, 0] - 0.5) + anp.square(x[:, 1] - 0.5)) - 1
+
+        out["F"] = anp.column_stack([f1, f2])
+        out["G"] = anp.column_stack([g1, g2])
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "tnk.pf")