pymoo 0.6.1.6__cp312-cp312-macosx_10_13_universal2.whl

pymoo/problems/multi/truss2d.py

@@ -0,0 +1,83 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class Truss2D(Problem):
+
+    def __init__(self):
+        super().__init__(n_var=3, n_obj=2, n_ieq_constr=1, vtype=float)
+
+        self.Amax = 0.01
+        self.Smax = 1e5
+
+        self.xl = np.array([0.0, 0.0, 1.0])
+        self.xu = np.array([self.Amax, self.Amax, 3.0])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+
+        # variable names for convenient access
+        x1 = x[:, 0]
+        x2 = x[:, 1]
+        y = x[:, 2]
+
+        # first objectives
+        f1 = x1 * anp.sqrt(16 + anp.square(y)) + x2 * anp.sqrt((1 + anp.square(y)))
+
+        # measure which are needed for the second objective
+        sigma_ac = 20 * anp.sqrt(16 + anp.square(y)) / (y * x1)
+        sigma_bc = 80 * anp.sqrt(1 + anp.square(y)) / (y * x2)
+
+        # take the max
+        f2 = anp.max(anp.column_stack((sigma_ac, sigma_bc)), axis=1)
+
+        # define a constraint
+        g1 = f2 - self.Smax
+
+        out["F"] = anp.column_stack([f1, f2])
+        out["G"] = g1
+
+    def _calc_pareto_front(self, *args, **kwargs):
+
+        T = 2 * np.sqrt(5) * self.Amax
+
+        # Part A - before transition point T
+
+        f1 = np.linspace(400 / self.Smax, T, 1000)
+        f2 = 400 / f1
+        part_a = np.column_stack([f1, f2])
+
+        # Part B - after transition point T
+
+        def calc_y(V):
+            return np.sqrt(3200 * V**2 + 40 * V * np.sqrt(6400 * V**2 - 12) - 4)
+
+        def calc_SV(y):
+            return (4 + y**2) / (0.01 * y)
+
+        def calc_x1(y):
+            return 0.0025 * np.sqrt((16 + y**2) / (1 + y**2))
+
+        def calc_S(V):
+            y = calc_y(V)
+            SV = calc_SV(y)
+            S = SV / V
+            return S
+
+        y = 3
+        x1 = calc_x1(y)
+        x2 = 0.01
+
+        V_min = T
+        V_max = self.evaluate(np.array([x1, x2, y]), return_values_of=["F"])[0]
+
+        f1 = np.linspace(V_min, V_max, 100)
+        f2 = calc_S(f1)
+        part_b = np.column_stack([f1, f2])
+
+        pf = np.vstack([part_a, part_b])
+
+        return pf
+
+

pymoo/problems/multi/welded_beam.py

@@ -0,0 +1,41 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+from pymoo.util.remote import Remote
+
+
+class WeldedBeam(Problem):
+    def __init__(self):
+        super().__init__(n_var=4, n_obj=2, n_ieq_constr=4, vtype=float)
+        self.xl = np.array([0.125, 0.1, 0.1, 0.125])
+        self.xu = np.array([5.0, 10.0, 10.0, 5.0])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = 1.10471 * x[:, 0] ** 2 * x[:, 1] + 0.04811 * x[:, 2] * x[:, 3] * (14.0 + x[:, 1])
+        f2 = 2.1952 / (x[:, 3] * x[:, 2] ** 3)
+
+        P = 6000
+        L = 14
+        t_max = 13600
+        s_max = 30000
+
+        R = anp.sqrt(0.25 * (x[:, 1] ** 2 + (x[:, 0] + x[:, 2]) ** 2))
+        M = P * (L + x[:, 1] / 2)
+        J = 2 * anp.sqrt(0.5) * x[:, 0] * x[:, 1] * (x[:, 1] ** 2 / 12 + 0.25 * (x[:, 0] + x[:, 2]) ** 2)
+        t1 = P / (anp.sqrt(2) * x[:, 0] * x[:, 1])
+        t2 = M * R / J
+        t = anp.sqrt(t1 ** 2 + t2 ** 2 + t1 * t2 * x[:, 1] / R)
+        s = 6 * P * L / (x[:, 3] * x[:, 2] ** 2)
+        P_c = 64746.022 * (1 - 0.0282346 * x[:, 2]) * x[:, 2] * x[:, 3] ** 3
+
+        g1 = (1 / t_max) * (t - t_max)
+        g2 = (1 / s_max) * (s - s_max)
+        g3 = (1 / (5 - 0.125)) * (x[:, 0] - x[:, 3])
+        g4 = (1 / P) * (P - P_c)
+
+        out["F"] = anp.column_stack([f1, f2])
+        out["G"] = anp.column_stack([g1, g2, g3, g4])
+
+    def _calc_pareto_front(self):
+        return Remote.get_instance().load("pymoo", "pf", "welded_beam.pf")

pymoo/problems/multi/wrm.py

@@ -0,0 +1,36 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class WRM(Problem):
+
+    def __init__(self):
+        xl = np.array([0.01, 0.01, 0.01])
+        xu = np.array([0.45, 0.10, 0.10])
+        super().__init__(n_var=3, n_obj=5, n_ieq_constr=7, 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])
+
+        f1 = 106780.37 * (x[:, 2] + x[:, 3]) + 61704.67
+        f2 = 3000 * x[:, 1]
+        f3 = 305700 * 2289 * x[:, 2] / (0.06 * 2289) ** 0.65
+        f4 = 250 * 2289 * anp.exp(-39.75 * x[:, 2] + 9.9 * x[:, 3] + 2.74)
+        f5 = 25 * (1.39 / (x[:, 1] * x[:, 2]) + 4940 * x[:, 3] - 80)
+
+        deno = 1. / (x[:, 1] * x[:, 2])
+
+        g1 = -(1.0 - (0.00139 * deno + 4.94 * x[:, 3] - 0.08))
+        g2 = -(1.0 - (0.000306 * deno + 1.082 * x[:, 3] - 0.0986))
+        g3 = -(50000 - (12.307 * deno + 49408.24 * x[:, 3] + 4051.02))
+        g4 = -(16000 - (2.098 * deno + 8046.33 * x[:, 3] - 696.71))
+        g5 = -(10000 - (2.138 * deno + 7883.39 * x[:, 3] - 705.04))
+        g6 = -(2000 - (0.417 * deno + 1721.26 * x[:, 3] - 136.54))
+        g7 = -(550 - (0.164 * deno + 631.13 * x[:, 3] - 54.58))
+
+        out["F"] = anp.column_stack([f1, f2, f3, f4, f5])
+        out["G"] = anp.column_stack([g1, g2, g3, g4, g5, g6, g7])

pymoo/problems/multi/zdt.py

@@ -0,0 +1,151 @@
+
+import numpy as np
+
+import pymoo.gradient.toolbox as anp
+from pymoo.core.problem import Problem
+from pymoo.util.normalization import normalize
+
+
+class ZDT(Problem):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, n_obj=2, xl=0, xu=1, vtype=float, **kwargs)
+
+
+class ZDT1(ZDT):
+
+    def _calc_pareto_front(self, n_pareto_points=100):
+        x = np.linspace(0, 1, n_pareto_points)
+        return np.array([x, 1 - np.sqrt(x)]).T
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        g = 1 + 9.0 / (self.n_var - 1) * anp.sum(x[:, 1:], axis=1)
+        f2 = g * (1 - anp.power((f1 / g), 0.5))
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+class ZDT2(ZDT):
+
+    def _calc_pareto_front(self, n_pareto_points=100):
+        x = np.linspace(0, 1, n_pareto_points)
+        return np.array([x, 1 - np.power(x, 2)]).T
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        c = anp.sum(x[:, 1:], axis=1)
+        g = 1.0 + 9.0 * c / (self.n_var - 1)
+        f2 = g * (1 - anp.power((f1 * 1.0 / g), 2))
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+class ZDT3(ZDT):
+
+    def _calc_pareto_front(self, n_points=100, flatten=True):
+        regions = [[0, 0.0830015349],
+                   [0.182228780, 0.2577623634],
+                   [0.4093136748, 0.4538821041],
+                   [0.6183967944, 0.6525117038],
+                   [0.8233317983, 0.8518328654]]
+
+        pf = []
+
+        for r in regions:
+            x1 = np.linspace(r[0], r[1], int(n_points / len(regions)))
+            x2 = 1 - np.sqrt(x1) - x1 * np.sin(10 * np.pi * x1)
+            pf.append(np.array([x1, x2]).T)
+
+        if not flatten:
+            pf = np.concatenate([pf[None,...] for pf in pf])
+        else:
+            pf = np.vstack(pf)
+
+        return pf
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        c = anp.sum(x[:, 1:], axis=1)
+        g = 1.0 + 9.0 * c / (self.n_var - 1)
+        f2 = g * (1 - anp.power(f1 * 1.0 / g, 0.5) - (f1 * 1.0 / g) * anp.sin(10 * anp.pi * f1))
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+class ZDT4(ZDT):
+    def __init__(self, n_var=10):
+        super().__init__(n_var)
+        self.xl = -5 * np.ones(self.n_var)
+        self.xl[0] = 0.0
+        self.xu = 5 * np.ones(self.n_var)
+        self.xu[0] = 1.0
+        self.func = self._evaluate
+
+    def _calc_pareto_front(self, n_pareto_points=100):
+        x = np.linspace(0, 1, n_pareto_points)
+        return np.array([x, 1 - np.sqrt(x)]).T
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = x[:, 0]
+        g = 1.0
+        g += 10 * (self.n_var - 1)
+        for i in range(1, self.n_var):
+            g += x[:, i] * x[:, i] - 10.0 * anp.cos(4.0 * anp.pi * x[:, i])
+        h = 1.0 - anp.sqrt(f1 / g)
+        f2 = g * h
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+class ZDT5(ZDT):
+
+    def __init__(self, m=11, n=5, normalize=True, **kwargs):
+        self.m = m
+        self.n = n
+        self.normalize = normalize
+        super().__init__(n_var=(30 + n * (m - 1)), **kwargs)
+
+    def _calc_pareto_front(self, n_pareto_points=100):
+        x = 1 + np.linspace(0, 1, n_pareto_points) * 30
+        pf = np.column_stack([x, (self.m-1) / x])
+        if self.normalize:
+            pf = normalize(pf)
+        return pf
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        x = x.astype(float)
+
+        _x = [x[:, :30]]
+        for i in range(self.m - 1):
+            _x.append(x[:, 30 + i * self.n: 30 + (i + 1) * self.n])
+
+        u = anp.column_stack([x_i.sum(axis=1) for x_i in _x])
+        v = (2 + u) * (u < self.n) + 1 * (u == self.n)
+        g = v[:, 1:].sum(axis=1)
+
+        f1 = 1 + u[:, 0]
+        f2 = g * (1 / f1)
+
+        if self.normalize:
+            f1 = normalize(f1, 1, 31)
+            f2 = normalize(f2, (self.m-1) * 1/31, (self.m-1))
+
+        out["F"] = anp.column_stack([f1, f2])
+
+
+class ZDT6(ZDT):
+
+    def __init__(self, n_var=10, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _calc_pareto_front(self, n_pareto_points=100):
+        x = np.linspace(0.2807753191, 1, n_pareto_points)
+        return np.array([x, 1 - np.power(x, 2)]).T
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        f1 = 1 - anp.exp(-4 * x[:, 0]) * anp.power(anp.sin(6 * anp.pi * x[:, 0]), 6)
+        g = 1 + 9.0 * anp.power(anp.sum(x[:, 1:], axis=1) / (self.n_var - 1.0), 0.25)
+        f2 = g * (1 - anp.power(f1 / g, 2))
+
+        out["F"] = anp.column_stack([f1, f2])

pymoo/problems/multi_to_single.py

@@ -0,0 +1,22 @@
+from pymoo.core.meta import Meta
+from pymoo.core.problem import Problem
+
+
+class MultiToSingleObjective(Meta, Problem):
+
+    def __init__(self, problem, decomposition, kwargs=None):
+        super().__init__(problem)
+        self.decomposition = decomposition
+        self.kwargs = kwargs if not None else dict()
+        self.n_obj = 1
+
+    def do(self, X, return_values_of, *args, **kwargs):
+        out = self.__object__.do(X, return_values_of, *args, **kwargs)
+        F = out["F"]
+        out["__F__"] = F
+        out["F"] = self.decomposition.do(F, **self.kwargs)[:, None]
+        return out
+
+
+
+

pymoo/problems/single/__init__.py

@@ -0,0 +1,12 @@
+from pymoo.problems.single.ackley import *
+from pymoo.problems.single.cantilevered_beam import *
+from pymoo.problems.single.griewank import *
+from pymoo.problems.single.knapsack import *
+from pymoo.problems.single.pressure_vessel import *
+from pymoo.problems.single.rastrigin import *
+from pymoo.problems.single.rosenbrock import *
+from pymoo.problems.single.schwefel import *
+from pymoo.problems.single.sphere import *
+from pymoo.problems.single.zakharov import *
+from pymoo.problems.single.g import *
+from pymoo.problems.single.himmelblau import *

pymoo/problems/single/ackley.py

@@ -0,0 +1,24 @@
+import numpy as np
+import pymoo.gradient.toolbox as anp
+
+from pymoo.core.problem import Problem
+
+
+class Ackley(Problem):
+
+    def __init__(self, n_var=2, a=20, b=1/5, c=2 * np.pi):
+        super().__init__(n_var=n_var, n_obj=1, xl=-32.768, xu=+32.768, vtype=float)
+        self.a = a
+        self.b = b
+        self.c = c
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        part1 = -1. * self.a * anp.exp(-1. * self.b * anp.sqrt((1. / self.n_var) * anp.sum(x * x, axis=1)))
+        part2 = -1. * anp.exp((1. / self.n_var) * anp.sum(anp.cos(self.c * x), axis=1))
+        out["F"] = part1 + part2 + self.a + anp.exp(1)
+
+    def _calc_pareto_front(self):
+        return 0
+
+    def _calc_pareto_set(self):
+        return np.full(self.n_var, 0)

pymoo/problems/single/cantilevered_beam.py

@@ -0,0 +1,34 @@
+import pymoo.gradient.toolbox as anp
+import numpy as np
+
+from pymoo.core.problem import Problem
+
+
+class CantileveredBeam(Problem):
+
+    def __init__(self):
+        super().__init__(n_var=4, n_obj=1, n_ieq_constr=2, vtype=float)
+        self.xl = np.array([2, 0.1, 0.1, 3.0])
+        self.xu = np.array([12.0, 1.0, 2.0, 7.0])
+        self.h1 = np.array([0.1, 0.25, 0.35, 0.5, 0.65, 0.75, 0.9, 1.0])
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        E, L, P = 1e7, 36.0, 1000.0
+
+        b1, h1, b2, H = x[:, 0], x[:, 1], x[:, 2], x[:, 3]
+        I = 1 / 12 * b2 * (H - 2 * h1) ** 3 + 2 * (1 / 12 * b1 * h1 ** 3 + b1 * h1 * (H - h1) ** 2 / 4)
+        volume = (2 * h1 * b1 + (H - 2 * h1) * b2) * L
+        out["F"] = volume
+
+        sigma = P * L * H / (2 * I)
+        delta = P * L ** 3 / (3 * E * I)
+
+        g1 = (sigma - 5000.0) / 5000.0
+        g2 = (delta - 0.1) / 0.1
+        out["G"] = anp.column_stack([g1, g2])
+
+    def _calc_pareto_front(self):
+        return 92.7693
+
+    def _calc_pareto_set(self):
+        return [9.4846, 0.1000, 0.1000, 7.0000]

pymoo/problems/single/flowshop_scheduling.py

@@ -0,0 +1,113 @@
+
+import numpy as np
+
+from pymoo.core.problem import ElementwiseProblem
+from pymoo.util import default_random_state
+
+
+class FlowshopScheduling(ElementwiseProblem):
+
+    def __init__(self, processing_times, **kwargs):
+        """
+        Flowshop scheduling problem.
+
+        Parameters
+        ----------
+        processing_times : numpy.array
+            Matrix where processing_time[i][j] is the processing time for job j on machine i.
+
+        """
+
+        n_machines, n_jobs = processing_times.shape
+        self.records = processing_times
+
+        super(FlowshopScheduling, self).__init__(
+            n_var=n_jobs,
+            n_obj=1,
+            xl=0,
+            xu=n_machines,
+            vtype=int,
+            **kwargs
+        )
+
+    def _evaluate(self, x, out, *args, **kwargs):
+        out["F"] = self.makespan(x)
+
+    def makespan(self, x):
+        machine_times = self.get_machine_times(x)
+        # The makespan is the difference between the starting time of the first job and the latest finish time of any
+        # job. Minimizing the makespan amounts to minimizing the total time it takes to process all jobs from start
+        # to finish.
+        makespan = machine_times[-1][-1] + self.records[-1][x[-1]]  # finish time of the last job
+        return makespan
+
+    def get_machine_times(self, x):
+        n_machines, n_jobs = self.records.shape
+
+        # A 2d array to store the starting time for each job on each machine
+        # machine_times[i][j] --> starting time for the j-th job on machine i
+        machine_times = [[] for _ in range(n_machines)]
+
+        # Assign the initial job to the machines
+        machine_times[0].append(0)
+        for i in range(1, n_machines):
+            # Start the next job when the previous one is finished
+            machine_times[i].append(
+                machine_times[i - 1][0] + self.records[i - 1][x[0]]
+            )
+
+        # Assign the remaining jobs
+        for j in range(1, n_jobs):
+            # For the first machine, we can put a job when the previous one is finished
+            machine_times[0].append(
+                machine_times[0][j - 1] + self.records[0][x[j - 1]]
+            )
+
+            # For the remaining machines, the starting time of the current job j is the max of the following two times:
+            # 1. The finish time of the previous job on the current machine
+            # 2. The finish time of the current job on the previous machine
+            for i in range(1, n_machines):
+                machine_times[i].append(
+                    max(
+                        machine_times[i][j - 1] + self.records[i][x[j - 1]],  # 1
+                        machine_times[i - 1][j] + self.records[i - 1][x[j]]  # 2
+                    )
+                )
+        return machine_times
+
+
+@default_random_state(seed=1)
+def create_random_flowshop_problem(n_machines, n_jobs, random_state=None, **kwargs):
+    T = random_state.random((n_machines, n_jobs)) * 50 + 50
+    return FlowshopScheduling(T)
+
+
+def visualize(problem, x, path=None, label=True):
+    from pymoo.visualization.matplotlib import plt
+    with plt.style.context('ggplot'):
+        n_machines, n_jobs = problem.records.shape
+        machine_times = problem.get_machine_times(x)
+
+        fig = plt.figure()
+        ax = fig.add_subplot(111)
+
+        Y = np.flip(np.arange(n_machines))
+
+        for i in range(n_machines):
+            for j in range(n_jobs):
+                width = problem.records[i][x[j]]
+                left = machine_times[i][j]
+                ax.barh(Y[i], width, left=left,
+                        align='center', color='gray',
+                        edgecolor='black', linewidth=0.8
+                        )
+                if label:
+                    ax.text((left + width / 2), Y[i], str(x[j] + 1), ha='center', va='center', color='white',
+                            fontsize=15)
+        ax.set_xlabel("Time")
+        ax.set_yticks(np.arange(n_machines))
+        ax.set_yticklabels(["M%d" % (i + 1) for i in Y])
+        ax.set_title("Makespan: %s" % np.round(problem.makespan(x), 3))
+        if path is not None:
+            plt.savefig(path)
+        plt.show()