pymoo 0.6.1.5.dev0__cp310-cp310-macosx_11_0_arm64.whl

pymoo/problems/multi/clutch.py

@@ -0,0 +1,104 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Clutch(Problem):
+
+    def __init__(self):
+        super().__init__(n_var=5, n_obj=2, n_ieq_constr=19, vtype=int)
+        # ri, ro, t, F, Xp
+        # self.xl = np.array([60, 90, 1, 600, 2])
+        self.xl = np.array([0, 0, 0, 0, 0])
+        self.xu = np.array([20, 20, 4, 400, 7])
+
+        self.x1 = np.arange(60, 81)
+        self.x2 = np.arange(90, 111)
+        self.x3 = np.arange(1, 3.5, 0.5)
+        self.x4 = np.arange(600, 1001)
+        self.x5 = np.arange(2, 11)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+
+        x1, x2, x3, x4, x5 = anp.split(x, 5, axis=1)
+
+        x1 = self.x1[x1]
+        x2 = self.x2[x2]
+        x3 = self.x3[x3]
+        x4 = self.x4[x4]
+        x5 = self.x5[x5]
+
+        pi = anp.pi
+        mu = 0.5
+        s = 1.5
+        M_f = 3  # Nm
+        ri_max = 80  # mm
+        t_max = 3  # mm
+        n = 250  # rpm
+        w = pi * n/30  # rad/s
+        R_sr = (2/3) * ((x2**3 - x1**3)/(x2**2 - x1**2))  # mm
+        p_max = 1  # MPa
+        T_max = 15  # s
+        I_z = 55  # kg*m^2
+        ro_min = 90  # mm
+        F_max = 1000  # N
+        A = pi * (x2**2 - x1**2)  # mm^2
+        deltaR = 20  # mm
+        rho = 0.0000078  # kg/mm^2
+        delta = 0.5  # mm
+        ro_max = 110  # mm
+
+        Z_max = 9
+        p_rz = x4/A  # N/mm^2
+        L_max = 30  # mm
+        Vsr_max = 10  #m/s
+        M_s = 40  # Nm
+        ri_min = 60  # mm
+        t_min = 1.5  # mm
+
+        M_h = (2/3) * mu * x4 * x5 * ((x2**3 - x1**3)/(x2**2 - x1**2))  # N*mm
+        Vsr = (pi * R_sr * n)/30  # mm/s
+
+        T = (I_z * w)/(M_h/1000 + M_f)
+
+        g1 = (x2 - x1 - deltaR) * -1
+        g2 = (L_max - (x5 + 1) * (x3 + delta)) * -1
+        g3 = (p_max - p_rz) * -1
+        g4 = (p_max * Vsr_max*1000 - p_rz * Vsr) * -1
+        g5 = (Vsr_max*1000 - Vsr) * -1
+        g6 = (M_h/1000 - (s * M_s)) * -1
+        g7 = T * -1
+        g8 = (T_max - T) * -1
+
+        _g9 = -x1 + ri_min
+        _g10 = x1 - ri_max
+
+        _g11 = -x2 + ro_min
+        _g12 = x2 - ro_max
+
+        _g13 = -x3 + t_min
+        _g14 = x3 - t_max
+
+        _g15 = -x4
+        _g16 = x4 - F_max
+
+        _g17 = -x5 + 2
+        _g18 = x5 - Z_max
+
+        f1 = pi * (x2**2 - x1**2) * x3 * (x5 + 1) * rho
+        f2 = T
+
+        out["F"] = anp.column_stack([f1, f2])
+        out["G"] = anp.column_stack([g1, g2, g3, g4, g5, g6, g7, g8])
+
+
+if __name__ == "__main__":
+    x = np.array([[10, 0, 1, 400, 1]])
+    # x = np.array([[10, 0, 0, 260, 1]])
+
+    problem = Clutch()
+
+    res = problem.evaluate(x)
+
+    print(res)

pymoo/problems/multi/csi.py

@@ -0,0 +1,55 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class CSI(Problem):
+    def __init__(self):
+        xl = np.array([0.500, 0.450, 0.500, 0.500, 0.875, 0.400, 0.400])
+        xu = np.array([1.500, 1.350, 1.500, 1.500, 2.625, 1.200, 1.200])
+        super().__init__(n_var=7, n_obj=3, n_ieq_constr=10, xl=xl, xu=xu, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+
+        # the definition is index 1 based -> simply add a dummy var in the beginning
+        x = anp.column_stack([anp.zeros((len(x), 1)), x])
+
+        F = 4.72 - 0.5 * x[:, 4] - 0.19 * x[:, 2] * x[:, 3]
+
+        V_mbp = 10.58 - 0.674 * x[:, 1] * x[:, 2] - 0.67275 * x[:, 2]
+
+        V_fd = 16.45 - 0.489 * x[:, 3] * x[:, 7] - 0.843 * x[:, 5] * x[:, 6]
+
+        f1 = 1.98 + 4.9 * x[:, 1] + 6.67 * x[:, 2] + 6.98 * x[:, 3] + 4.01 * x[:, 4] + 1.78 * x[:, 5] + \
+             0.00001 * x[:, 6] + 2.73 * x[:, 7]
+
+        f2 = F
+
+        f3 = 0.5 * (V_mbp + V_fd)
+
+        g1 = 1.16 - 0.3717 * x[:, 2] * x[:, 4] - 0.0092928 * x[:, 3] - 1
+
+        g2 = 0.261 - 0.0159 * x[:, 1] * x[:, 2] - 0.06486 * x[:, 1] - 0.019 * x[:, 2] * x[:, 7] + \
+             0.0144 * x[:, 3] * x[:, 5] + 0.0154464 * x[:, 6] - 0.32
+
+        g3 = 0.214 + 0.00817 * x[:, 5] - 0.045195 * x[:, 1] - 0.0135168 * x[:, 1] + 0.03099 * x[:, 2] * x[:, 6] - \
+             0.018 * x[:, 2] * x[:, 7] + 0.007176 * x[:, 3] + 0.023232 * x[:, 3] - 0.00364 * x[:, 5] * x[:, 6] - \
+             0.018 * x[:, 2] ** 2 - 0.32
+
+        g4 = 0.74 - 0.61 * x[:, 2] - 0.031296 * x[:, 3] - 0.031872 * x[:, 7] + 0.227 * x[:, 2] ** 2 - 0.32
+
+        g5 = 28.98 + 3.818 * x[:, 3] - 4.2 * x[:, 1] * x[:, 2] + 1.27296 * x[:, 6] - 2.68065 * x[:, 7] - 32
+
+        g6 = 33.86 + 2.95 * x[:, 3] - 5.057 * x[:, 1] * x[:, 2] - 3.795 * x[:, 2] - 3.4431 * x[:, 7] + 1.45728 - 32
+
+        g7 = 46.36 - 9.9 * x[:, 2] - 4.4505 * x[:, 1] - 32
+
+        g8 = F - 4
+
+        g9 = V_mbp - 9.9
+
+        g10 = V_fd - 15.7
+
+        out["F"] = anp.column_stack([f1, f2, f3])
+        out["G"] = anp.column_stack([g1, g2, g3, g4, g5, g6, g7, g8, g9, g10])

pymoo/problems/multi/ctp.py

@@ -0,0 +1,198 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+def g_linear(x):
+    return 1 + np.sum(x, axis=1)
+
+
+def g_multimodal(x):
+    A = 10
+    return 1 + A * x.shape[1] + np.sum(x ** 2 - A * np.cos(2 * np.pi * x), axis=1)
+
+
+class CTP(Problem):
+
+    def __init__(self, n_var=2, n_ieq_constr=1, option="linear"):
+        super().__init__(n_var=n_var, n_obj=2, n_ieq_constr=n_ieq_constr, xl=0, xu=1, vtype=float)
+
+        if option == "linear":
+            self.calc_g = g_linear
+
+        elif option == "multimodal":
+            self.calc_g = g_multimodal
+            self.xl[1:] = -5.12
+            self.xu[1:] = 5.12
+
+        else:
+            print("Unknown option for CTP single.")
+
+    def calc_objectives(self, x):
+        f1 = x[:, 0]
+        gg = self.calc_g(x[:, 1:])
+        f2 = gg * (1 - (f1 / gg) ** 0.5)
+        return f1, f2
+
+    def calc_constraint(self, theta, a, b, c, d, e, f1, f2):
+
+        # Equations in readable format
+        exp1 = (f2 - e) * anp.cos(theta) - f1 * anp.sin(theta)
+
+        exp2 = (f2 - e) * anp.sin(theta) + f1 * anp.cos(theta)
+        exp2 = b * anp.pi * (exp2 ** c)
+        exp2 = anp.abs(anp.sin(exp2))
+        exp2 = a * (exp2 ** d)
+
+        # as in the paper
+        # val = - (exp1 - exp2)
+
+        # as in the C code of NSGA2
+        val = 1 - exp1 / exp2
+
+        # ONE EQUATION
+        # _val = - (anp.cos(theta) * (f2 - e) - anp.sin(theta) * f1 -
+        #           a * anp.abs(anp.sin(b * anp.pi * (anp.sin(theta) * (f2 - e) + anp.cos(theta) * f1) ** c)) ** d)
+
+        return val
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "CTP", str(self.__class__.__name__).lower() + ".pf")
+
+
+class CTP1(CTP):
+
+    def __init__(self, n_var=2, n_ieq_constr=2, **kwargs):
+        super().__init__(n_var, n_ieq_constr, **kwargs)
+
+        a, b = np.zeros(n_ieq_constr + 1), np.zeros(n_ieq_constr + 1)
+        a[0], b[0] = 1, 1
+        delta = 1 / (n_ieq_constr + 1)
+        alpha = delta
+
+        for j in range(n_ieq_constr):
+            beta = a[j] * np.exp(-b[j] * alpha)
+            a[j + 1] = (a[j] + beta) / 2
+            b[j + 1] = - 1 / alpha * np.log(beta / a[j + 1])
+
+            alpha += delta
+
+        self.a = a[1:]
+        self.b = b[1:]
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        gg = self.calc_g(x[:, 1:])
+        f2 = gg * anp.exp(-f1 / gg)
+        out["F"] = anp.column_stack([f1, f2])
+
+        a, b = self.a, self.b
+        g = []
+        for j in range(self.n_ieq_constr):
+            _g = - (f2 - (a[j] * anp.exp(-b[j] * f1)))
+            g.append(_g)
+        out["G"] = anp.column_stack(g)
+
+
+class CTP2(CTP):
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = -0.2 * anp.pi
+        a, b, c, d, e = 0.2, 10, 1, 6, 1
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP3(CTP):
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = -0.2 * anp.pi
+        a, b, c, d, e = 0.1, 10, 1, 0.5, 1
+
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP4(CTP):
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = -0.2 * anp.pi
+        a, b, c, d, e = 0.75, 10, 1, 0.5, 1
+
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP5(CTP):
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = -0.2 * anp.pi
+        a, b, c, d, e = 0.1, 10, 2, 0.5, 1
+
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP6(CTP):
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.xu = np.full(self.n_var, 20)
+        self.xu[0] = 1
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = 0.1 * anp.pi
+        a, b, c, d, e = 40, 0.5, 1, 2, -2
+
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP7(CTP):
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = -0.05 * anp.pi
+        a, b, c, d, e = 40, 5, 1, 6, 0
+
+        out["G"] = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+
+class CTP8(CTP):
+    def __init__(self, **kwargs):
+        super().__init__(n_ieq_constr=2, **kwargs)
+        self.xu = np.full(self.n_var, 20)
+        self.xu[0] = 1
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1, f2 = self.calc_objectives(x)
+        out["F"] = anp.column_stack([f1, f2])
+
+        theta = 0.1 * anp.pi
+        a, b, c, d, e = 40, 0.5, 1, 2, -2
+        g1 = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+        theta = -0.05 * anp.pi
+        a, b, c, d, e = 40, 2, 1, 6, 0
+        g2 = self.calc_constraint(theta, a, b, c, d, e, f1, f2)
+
+        out["G"] = anp.column_stack([g1, g2])
+
+
+if __name__ == '__main__':
+    problem = CTP1(n_ieq_constr=3)
+    print(problem.n_ieq_constr)

pymoo/problems/multi/dascmop.py

@@ -0,0 +1,213 @@
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+DIFFICULTIES = [
+    (0.25, 0., 0.), (0., 0.25, 0.), (0., 0., 0.25), (0.25, 0.25, 0.25),
+    (0.5, 0., 0.), (0., 0.5, 0.), (0., 0., 0.5), (0.5, 0.5, 0.5),
+    (0.75, 0., 0.), (0., 0.75, 0.), (0., 0., 0.75), (0.75, 0.75, 0.75),
+    (0., 1.0, 0.), (0.5, 1.0, 0.), (0., 1.0, 0.5), (0.5, 1.0, 0.5)
+]
+
+
+class DASCMOP(Problem):
+    def __init__(self, n_obj, n_ieq_constr, difficulty, **kwargs):
+        super().__init__(n_var=30,
+                         n_obj=n_obj,
+                         n_ieq_constr=n_ieq_constr,
+                         vtype=float, xl=0., xu=1., **kwargs)
+
+        if isinstance(difficulty, int):
+            self.difficulty = difficulty
+            if not (1 <= difficulty <= len(DIFFICULTIES)):
+                raise Exception(f"Difficulty must be 1 <= difficulty <= {len(DIFFICULTIES)}, but it is {difficulty}!")
+            vals = DIFFICULTIES[difficulty - 1]
+        else:
+            self.difficulty = -1
+            vals = difficulty
+
+        self.eta, self.zeta, self.gamma = vals
+
+    def g1(self, X):
+        contrib = (X[:, self.n_obj - 1:] - np.sin(0.5 * np.pi * X[:, 0:1])) ** 2
+        return contrib.sum(axis=1)[:, None]
+
+    def g2(self, X):
+        z = X[:, self.n_obj - 1:] - 0.5
+        contrib = z ** 2 - np.cos(20 * np.pi * z)
+        return (self.n_var - self.n_obj + 1) + contrib.sum(axis=1)[:, None]
+
+    def g3(self, X):
+        j = np.arange(self.n_obj - 1, self.n_var) + 1
+        contrib = (X[:, self.n_obj - 1:] - np.cos(0.25 * j / self.n_var * np.pi * (X[:, 0:1] + X[:, 1:2]))) ** 2
+        return contrib.sum(axis=1)[:, None]
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "DASCMOP", f"{str(self.__class__.__name__).lower()}_{self.difficulty}.pf")
+
+
+class DASCMOP1(DASCMOP):
+    def __init__(self, difficulty, **kwargs):
+        super().__init__(2, 11, difficulty)
+
+    def constraints(self, X, f0, f1, g):
+        a = 20.
+        b = 2. * self.eta - 1.
+        d = 0.5 if self.zeta != 0 else 0.
+        if self.zeta > 0:
+            e = d - np.log(self.zeta)
+        else:
+            e = 1e30
+        r = 0.5 * self.gamma
+
+        p_k = np.array([[0., 1.0, 0., 1.0, 2.0, 0., 1.0, 2.0, 3.0]])
+        q_k = np.array([[1.5, 0.5, 2.5, 1.5, 0.5, 3.5, 2.5, 1.5, 0.5]])
+
+        a_k2 = 0.3
+        b_k2 = 1.2
+        theta_k = -0.25 * np.pi
+
+        c = np.zeros((X.shape[0], 2 + p_k.shape[1]))
+
+        c[:, 0] = np.sin(a * np.pi * X[:, 0]) - b
+        if self.zeta == 1.:
+            c[:, 1:2] = 1e-4 - np.abs(e - g)
+        else:
+            c[:, 1:2] = (e - g) * (g - d)
+
+        c[:, 2:] = (((f0 - p_k) * np.cos(theta_k) - (f1 - q_k) * np.sin(theta_k)) ** 2 / a_k2
+                    + ((f0 - p_k) * np.sin(theta_k) + (f1 - q_k) * np.cos(theta_k)) ** 2 / b_k2
+                    - r)
+
+        return -1 * c
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - X[:, 0:1] ** 2 + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP2(DASCMOP1):
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - np.sqrt(X[:, 0:1]) + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP3(DASCMOP1):
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g1(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - np.sqrt(X[:, 0:1]) + 0.5 * np.abs(np.sin(5 * np.pi * X[:, 0:1])) + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP4(DASCMOP1):
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - X[:, 0:1] ** 2 + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP5(DASCMOP1):
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - np.sqrt(X[:, 0:1]) + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP6(DASCMOP1):
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+
+        f0 = X[:, 0:1] + g
+        f1 = 1.0 - np.sqrt(X[:, 0:1]) + 0.5 * np.abs(np.sin(5 * np.pi * X[:, 0:1])) + g
+
+        out["F"] = np.column_stack([f0, f1])
+        out["G"] = self.constraints(X, f0, f1, g)
+
+
+class DASCMOP7(DASCMOP):
+
+    def __init__(self, difficulty_factors, **kwargs):
+        super().__init__(3, 7, difficulty_factors)
+
+    def constraints(self, X, f0, f1, f2, g):
+        a = 20.
+        b = 2. * self.eta - 1.
+        d = 0.5 if self.zeta != 0 else 0
+        if self.zeta > 0:
+            e = d - np.log(self.zeta)
+        else:
+            e = 1e30
+        r = 0.5 * self.gamma
+
+        x_k = np.array([[1.0, 0., 0., 1.0 / np.sqrt(3.0)]])
+        y_k = np.array([[0., 1.0, 0., 1.0 / np.sqrt(3.0)]])
+        z_k = np.array([[0., 0., 1.0, 1.0 / np.sqrt(3.0)]])
+
+        c = np.zeros((X.shape[0], 3 + x_k.shape[1]))
+
+        c[:, 0] = np.sin(a * np.pi * X[:, 0]) - b
+        c[:, 1] = np.cos(a * np.pi * X[:, 1]) - b
+        if self.zeta == 1:
+            c[:, 2:3] = 1e-4 - np.abs(e - g)
+        else:
+            c[:, 2:3] = (e - g) * (g - d)
+
+        c[:, 3:] = (f0 - x_k) ** 2 + (f1 - y_k) ** 2 + (f2 - z_k) ** 2 - r ** 2
+        return -1 * c
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+
+        f0 = X[:, 0:1] * X[:, 1:2] + g
+        f1 = X[:, 1:2] * (1.0 - X[:, 0:1]) + g
+        f2 = 1 - X[:, 1:2] + g
+
+        out["F"] = np.column_stack([f0, f1, f2])
+        out["G"] = self.constraints(X, f0, f1, f2, g)
+
+
+class DASCMOP8(DASCMOP7):
+
+    def objectives(self, X, g):
+        f0 = np.cos(0.5 * np.pi * X[:, 0:1]) * np.cos(0.5 * np.pi * X[:, 1:2]) + g
+        f1 = np.cos(0.5 * np.pi * X[:, 0:1]) * np.sin(0.5 * np.pi * X[:, 1:2]) + g
+        f2 = np.sin(0.5 * np.pi * X[:, 0:1]) + g
+        return np.column_stack([f0, f1, f2])
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g2(X)
+        F = self.objectives(X, g)
+        out["F"] = F
+        out["G"] = self.constraints(X, F[:, 0:1], F[:, 1:2], F[:, 2:3], g)
+
+
+class DASCMOP9(DASCMOP8):
+    def _evaluate(self, X, out, *args, **kwargs):
+        g = self.g3(X)
+        F = self.objectives(X, g)
+        out["F"] = F
+        out["G"] = self.constraints(X, F[:, 0:1], F[:, 1:2], F[:, 2:3], g)

pymoo/problems/multi/kursawe.py

@@ -0,0 +1,25 @@
+import pymoo.gradient.toolbox as anp
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+class Kursawe(Problem):
+    def __init__(self):
+        super().__init__(n_var=3, n_obj=2, xl=-5, xu=5, vtype=float)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        l = []
+        for i in range(2):
+            l.append(-10 * anp.exp(-0.2 * anp.sqrt(anp.square(x[:, i]) + anp.square(x[:, i + 1]))))
+        f1 = anp.sum(anp.column_stack(l), axis=1)
+
+        f2 = anp.sum(anp.power(anp.abs(x), 0.8) + 5 * anp.sin(anp.power(x, 3)), axis=1)
+
+        out["F"] = anp.column_stack([f1, f2])
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        return Remote.get_instance().load("pymoo", "pf", "kursawe.pf")
+
+
+

pymoo/problems/multi/modact.py

@@ -0,0 +1,68 @@
+import numpy as np
+
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.util.remote import Remote
+
+
+class MODAct(ElementwiseProblem):
+    """Multi-Objective Design of Actuators
+
+    MODAct is a framework for real-world constrained multi-objective optimization.
+    Refer to the python package https://github.com/epfl-lamd/modact from requirements.
+
+    Best-known Pareto fronts must be downloaded from here: https://doi.org/10.5281/zenodo.3824302
+
+    Parameters
+    ----------
+
+    function: str or modact.problems
+        The name of the benchmark problem to use either as a string or the
+        problem object instance. Example values: cs1, cs3, ct2, ct4, cts3
+
+    References:
+    ----------
+    C. Picard and J. Schiffmann, “Realistic Constrained Multi-Objective Optimization Benchmark Problems from Design,”
+    IEEE Transactions on Evolutionary Computation, pp. 1–1, 2020.
+    """
+
+    def __init__(self, function, pf=None, **kwargs):
+
+        self.function = function
+        self.pf = pf
+
+        try:
+            import modact.problems as pb
+        except:
+            raise Exception("Please install the modact library: https://github.com/epfl-lamd/modact")
+
+        if isinstance(function, pb.Problem):
+            self.fct = function
+        else:
+            self.fct = pb.get_problem(function)
+
+        lb, ub = self.fct.bounds()
+        n_var = len(lb)
+        n_obj = len(self.fct.weights)
+        n_ieq_constr = len(self.fct.c_weights)
+        xl = lb
+        xu = ub
+
+        self.weights = np.array(self.fct.weights)
+        self.c_weights = np.array(self.fct.c_weights)
+
+        super().__init__(n_var=n_var, n_obj=n_obj, n_ieq_constr=n_ieq_constr, xl=xl, xu=xu, vtype=float, **kwargs)
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f, g = self.fct(x)
+        out["F"] = np.array(f) * -1 * self.weights
+        out["G"] = np.array(g) * self.c_weights
+
+    def _calc_pareto_front(self, *args, **kwargs):
+        # allows to provide a custom pf - because of the size of files published by the author
+        if self.pf is None:
+            pf = Remote.get_instance().load("pymoo", "pf", "MODACT", f"{self.function}.pf")
+            # pf = pf * [1, -1]
+            pf = pf * self.weights * -1
+            return pf
+        else:
+            return self.pf