pydmoo 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

pydmoo/__init__.py

@@ -0,0 +1,5 @@
+from ._version import __version__
+
+__all__ = [
+    "__version__"
+]

pydmoo/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.13"

pydmoo/problems/__init__.py

@@ -0,0 +1,98 @@
+from pydmoo.problems.dynamic.cec2015 import FDA4, FDA5
+from pydmoo.problems.dynamic.df import DF1, DF2, DF3, DF4, DF5, DF6, DF7, DF8, DF9, DF10, DF11, DF12, DF13, DF14
+from pydmoo.problems.dynamic.gts import (
+    GTS1,
+    GTS1_2,
+    GTS1_3,
+    GTS2,
+    GTS2_2,
+    GTS2_3,
+    GTS3,
+    GTS3_2,
+    GTS3_3,
+    GTS4,
+    GTS4_2,
+    GTS4_3,
+    GTS5,
+    GTS5_2,
+    GTS5_3,
+    GTS6,
+    GTS6_2,
+    GTS6_3,
+    GTS7,
+    GTS7_2,
+    GTS7_3,
+    GTS8,
+    GTS8_2,
+    GTS8_3,
+    GTS9,
+    GTS9_2,
+    GTS9_3,
+    GTS10,
+    GTS10_2,
+    GTS10_3,
+    GTS11,
+    GTS11_2,
+    GTS11_3,
+)
+
+PROBLEM = {
+    'fda4': FDA4,
+    'fda5': FDA5,
+    'gts1': GTS1,
+    'gts2': GTS2,
+    'gts3': GTS3,
+    'gts4': GTS4,
+    'gts5': GTS5,
+    'gts6': GTS6,
+    'gts7': GTS7,
+    'gts8': GTS8,
+    'gts9': GTS9,
+    'gts10': GTS10,
+    'gts11': GTS11,
+    'gts1_2': GTS1_2,
+    'gts2_2': GTS2_2,
+    'gts3_2': GTS3_2,
+    'gts4_2': GTS4_2,
+    'gts5_2': GTS5_2,
+    'gts6_2': GTS6_2,
+    'gts7_2': GTS7_2,
+    'gts8_2': GTS8_2,
+    'gts9_2': GTS9_2,
+    'gts10_2': GTS10_2,
+    'gts11_2': GTS11_2,
+    'gts1_3': GTS1_3,
+    'gts2_3': GTS2_3,
+    'gts3_3': GTS3_3,
+    'gts4_3': GTS4_3,
+    'gts5_3': GTS5_3,
+    'gts6_3': GTS6_3,
+    'gts7_3': GTS7_3,
+    'gts8_3': GTS8_3,
+    'gts9_3': GTS9_3,
+    'gts10_3': GTS10_3,
+    'gts11_3': GTS11_3,
+    'df1': DF1,
+    'df2': DF2,
+    'df3': DF3,
+    'df4': DF4,
+    'df5': DF5,
+    'df6': DF6,
+    'df7': DF7,
+    'df8': DF8,
+    'df9': DF9,
+    'df10': DF10,
+    'df11': DF11,
+    'df12': DF12,
+    'df13': DF13,
+    'df14': DF14,
+}
+
+
+def get_problem(name, *args, **kwargs):
+    name = name.lower()
+
+    if name.lower() not in PROBLEM:
+        raise Exception("Problem not found.")
+
+    return PROBLEM[name.lower()](*args, **kwargs)

pydmoo/problems/dyn.py

@@ -0,0 +1,89 @@
+"""
+Includes modified code from pymoo (https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dyn.py),
+licensed under Apache License 2.0. Original copyright and license terms are preserved.
+"""
+
+from abc import ABC
+from math import ceil
+
+from mpmath import mp
+from pymoo.core.callback import Callback
+from pymoo.core.problem import Problem
+
+
+class DynamicProblem(Problem, ABC):
+    pass
+
+
+class DynamicTestProblem(DynamicProblem, ABC):
+
+    def __init__(self, nt, taut, t0=50, tau=1, time=None, add_time_perturbation=False, **kwargs):
+        super().__init__(**kwargs)
+        self.tau = tau
+        self.nt = nt
+        self.taut = taut
+        self.t0 = t0  # added by DynOpt
+        self._time = time
+
+        self.add_time_perturbation = add_time_perturbation  # added by DynOpt
+
+    def tic(self, elapsed=1):
+
+        # increase the time counter by one
+        self.tau += elapsed
+
+        # remove the cache of the problem to recreate ps and pf
+        self.__dict__["cache"] = {}
+
+    @property
+    def time(self):
+        if self._time is not None:
+            return self._time
+        else:
+            # return 1 / self.nt * (self.tau // self.taut)
+
+            # added by DynOpt
+            delta_time = 1 / self.nt
+            count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
+
+            if not self.add_time_perturbation:
+                ratio = 0
+
+            else:
+                mp.dps = max(ceil(10 + count), 10)
+                mp_pi = 0 if count == 0 else int(str(mp.pi).split(".")[-1][count - 1])
+                ratio = 0.5 * 1 / 9 * mp_pi
+
+            return delta_time * count + delta_time * ratio
+
+    @time.setter
+    def time(self, value):
+        self._time = value
+
+    # added by DynOpt
+    def update_to_next_time(self):
+
+        # update to next time
+        count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
+
+        elapsed = int(count * self.taut + (self.t0 + 1) - self.tau)
+
+        self.tic(elapsed=elapsed)
+
+        return elapsed
+
+
+class TimeSimulation(Callback):
+
+    def update(self, algorithm):
+        problem = algorithm.problem
+
+        # added by DynOpt
+        # Designed to handle time-linkage properties within the GTS test suites.
+        if hasattr(problem, "time_linkage") and hasattr(problem, "cal"):
+            problem.cal(algorithm.opt.get("F"))
+
+        if hasattr(problem, "tic"):
+            problem.tic()
+        else:
+            raise Exception("TimeSimulation can only be used for dynamic test problems.")

pydmoo/problems/dynamic/cec2015.py

@@ -0,0 +1,147 @@
+"""
+Includes modified code from pymoo (https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dynamic/cec2015.py),
+licensed under Apache License 2.0. Original copyright and license terms are preserved.
+"""
+
+from math import cos, fabs, floor, pi, sin, sqrt
+
+import numpy as np
+
+from pydmoo.problems.dyn import DynamicTestProblem
+from pydmoo.problems.dynamic.df import get_PF
+
+
+class DynamicCEC2015(DynamicTestProblem):
+
+    def __init__(self, n_var=10, nt=10, taut=20, n_obj=2, xl=0.0, xu=1.0, vtype=float, **kwargs):
+        super().__init__(nt, taut, n_var=n_var, n_obj=n_obj, xl=xl, xu=xu, vtype=vtype, **kwargs)
+
+
+class FDA2DEB(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import fda2_deb as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class FDA4(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, n_obj=3, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import FDA4 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+    # added by DynOpt
+    def _calc_pareto_front(self, *args, n_pareto_points=100, **kwargs):
+        H = 20
+        x1, x2 = np.meshgrid(np.linspace(0, 1, H), np.linspace(0, 1, H), indexing='xy')
+
+        f1 = np.cos(x1 * pi / 2) * np.cos(x2 * pi / 2)
+        f2 = np.cos(x1 * pi / 2) * np.sin(x2 * pi / 2)
+        f3 = np.sin(x1 * pi / 2)
+
+        h = get_PF(np.array([f1, f2, f3]), False)
+        return h
+
+
+class FDA5(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, n_obj=3, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import FDA5 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+    # added by DynOpt
+    def _calc_pareto_front(self, *args, n_pareto_points=100, **kwargs):
+        H = 20
+        x1, x2 = np.meshgrid(np.linspace(0, 1, H), np.linspace(0, 1, H), indexing='xy')
+
+        G = fabs(sin(0.5 * pi * self.time))
+        g = G
+        F = 1 + 100 * pow(sin(0.5 * pi * self.time), 4)
+
+        x1 = np.power(x1, F)
+        x2 = np.power(x2, F)
+
+        f1 = (1 + g) * np.cos(x1 * pi / 2) * np.cos(x2 * pi / 2)
+        f2 = (1 + g) * np.cos(x1 * pi / 2) * np.sin(x2 * pi / 2)
+        f3 = (1 + g) * np.sin(x1 * pi / 2)
+
+        h = get_PF(np.array([f1, f2, f3]), True)
+        return h
+
+
+class DIMP2(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import DIMP2 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class dMOP2(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import dMOP2 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class dMOP3(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import dMOP3 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class HE2(DynamicCEC2015):
+
+    def __init__(self, n_var=30, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import HE2 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class HE7(DynamicCEC2015):
+
+    def __init__(self, n_var=10, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import HE7 as f
+        out["F"] = np.array([f(x, t) for x in X])
+
+
+class HE9(DynamicCEC2015):
+
+    def __init__(self, n_var=10, **kwargs):
+        super().__init__(n_var=n_var, **kwargs)
+
+    def _evaluate(self, X, out, *args, **kwargs):
+        t = self.time
+        from pymoo.vendor.gta import HE9 as f
+        out["F"] = np.array([f(x, t) for x in X])