How to create lots of constraints efficiently?

[yj9k5789]

First of all, thank you very much to develop Pymoo, which is a great framework to work on multi-objective optimization and most of information are well documented. However, there is a problem that I couldn't find, which is "how to define several constraints efficiently".

In this example, there are total J numbers of g sub j of x constraints. It is not possible to define it one by one if J is large. Is there any way to do it efficiently in Pymoo?

[blankjul]

How many constraints are we speaking about? Look for the definition of G1 for example:

class G1(G):
    def __init__(self):
        n_var = 13
        xl = np.zeros(n_var, dtype=float)
        xu = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 100, 100, 100, 1], dtype=float)
        super().__init__(n_var=n_var, n_obj=1, n_ieq_constr=9, xl=xl, xu=xu, vtype=float)

    def _evaluate(self, x, out, *args, **kwargs):
        x1 = x[:, 0: 4]
        x2 = x[:, 4: 13]

        f = 5 * x1.sum(axis=1) - 5 * (x1 ** 2).sum(axis=1) - x2.sum(axis=1)

        # Constraints
        g1 = 2 * x[:, 0] + 2 * x[:, 1] + x[:, 9] + x[:, 10] - 10
        g2 = 2 * x[:, 0] + 2 * x[:, 2] + x[:, 9] + x[:, 11] - 10
        g3 = 2 * x[:, 1] + 2 * x[:, 2] + x[:, 10] + x[:, 11] - 10
        g4 = -8 * x[:, 0] + x[:, 9]
        g5 = -8 * x[:, 1] + x[:, 10]
        g6 = -8 * x[:, 2] + x[:, 11]
        g7 = -2 * x[:, 3] - x[:, 4] + x[:, 9]
        g8 = -2 * x[:, 5] - x[:, 6] + x[:, 10]
        g9 = -2 * x[:, 7] - x[:, 8] + x[:, 11]

        out["F"] = f
        out["G"] = [g1, g2, g3, g4, g5, g6, g7, g8, g9]

The out["G"] can also be created using a loop. It is probably worth saying that most black-box algorithms are not great at handling a very constrained search space out of the box.