Feat/multi objective

src/smt_optim/benchmarks/multiobj/zdt_mf.py

@@ -68,3 +68,167 @@ def f2_lf(self, x):
 
     def g_lf(self, x):
         return self.f1_lf(x)
+
+###############################################################################
+# ZDT1 Benchmark
+###############################################################################
+
+class ZDT1(BenchmarkProblem):
+    def __init__(self):
+        super().__init__()
+        self.name = "ZDT1"
+        self.num_dim = 30
+        self.num_obj = 2
+        self.num_cstr = 0
+        self.num_fidelity = 2
+        self.tags = ["n_variable", "multi-obj", "multi-fidelity"]
+
+        # Corrected bounds for 30 dimensions
+        self.bounds = np.array(
+            [
+                [0, 1],
+            ]
+        )
+
+        self.objective = [
+            [self.f1_lf, self.f1],
+            [self.f2_lf, self.f2],
+        ]
+        self.constraints = None
+
+    def g(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def g_lf(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def f1(self, x):
+        return x[0]
+
+    def f1_lf(self, x):
+        return x[0] * 0.9 + 0.1
+
+    def h(self, f1, g):
+        return 1 - np.sqrt(f1 / g)
+
+    def f2(self, x):
+        g_val = self.g(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        return g_val * h_val
+
+    def f2_lf(self, x):
+        g_val = self.g_lf(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        return (0.8 * g_val - 0.2) * (1.2 * h_val + 0.2)
+
+###############################################################################
+# ZDT2 Benchmark
+###############################################################################
+
+class ZDT2(BenchmarkProblem):
+    def __init__(self):
+        super().__init__()
+        self.name = "ZDT2"
+        self.num_dim = 30
+        self.num_obj = 2
+        self.num_cstr = 0
+        self.num_fidelity = 2
+        self.tags = ["n_variable", "multi-obj", "multi-fidelity"]
+
+        self.bounds = np.array(
+            [
+                [0, 1],
+            ]
+        )
+
+        self.objective = [
+            [self.f1_lf, self.f1],
+            [self.f2_lf, self.f2],
+        ]
+        self.constraints = None
+
+    def g(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def g_lf(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def f1(self, x):
+        return x[0]
+
+    def f1_lf(self, x):
+        return 0.8 * x[0] + 0.2
+
+    def h(self, f1, g):
+        return 1 - (f1 / g) ** 2
+
+    def f2(self, x):
+        g_val = self.g(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        return g_val * h_val
+
+    def f2_lf(self, x):
+        g_val = self.g_lf(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        # Formula derived from ZDT2_LF functional snippet
+        return (0.9 * g_val + 0.2) * (1.1 * h_val - 0.2)
+
+
+###############################################################################
+# ZDT3 Benchmark
+###############################################################################
+
+class ZDT3(BenchmarkProblem):
+    def __init__(self):
+        super().__init__()
+        self.name = "ZDT3"
+        self.num_dim = 30
+        self.num_obj = 2
+        self.num_cstr = 0
+        self.num_fidelity = 2
+        self.tags = ["n_variable", "multi-obj", "multi-fidelity"]
+
+        self.bounds = np.array(
+            [
+                [0, 1],
+            ]
+        )
+
+        self.objective = [
+            [self.f1_lf, self.f1],
+            [self.f2_lf, self.f2],
+        ]
+        self.constraints = None
+
+    def g(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def g_lf(self, x):
+        return 1 + 9 * np.sum(x[1:]) / (self.num_dim - 1)
+
+    def f1(self, x):
+        return x[0]
+
+    def f1_lf(self, x):
+        return 0.75 * x[0] + 0.25
+
+    def h(self, f1, g):
+        # ZDT3 specific h function
+        return 1 - np.sqrt(f1 / g) - (f1 / g) * np.sin(10 * np.pi * f1)
+
+    def f2(self, x):
+        g_val = self.g(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        return g_val * h_val
+
+    def f2_lf(self, x):
+        g_val = self.g_lf(x)
+        f1_val = self.f1(x)
+        h_val = self.h(f1_val, g_val)
+        # Formula derived from ZDT3_LF functional snippet
+        return g_val * (1.25 * h_val - 0.25)