pydmoo 0.0.10__tar.gz → 0.0.12__tar.gz

{pydmoo-0.0.10 → pydmoo-0.0.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydmoo
-Version: 0.0.10
+Version: 0.0.12
 Summary: pydmoo
 Project-URL: Homepage, https://github.com/dynoptimization/pydmoo
 Project-URL: Repository, https://github.com/dynoptimization/pydmoo
@@ -35,10 +35,12 @@ Requires-Dist: statsmodels>=0.14.5
 Requires-Dist: tabulate>=0.9.0
 Description-Content-Type: text/markdown
 
-# pydmoo
+# Dynamic Multi-Objective Optimization in Python
+
+[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0.en.html)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydmoo)
+[![PyPI](https://img.shields.io/pypi/v/pydmoo)](https://pypi.org/project/pydmoo/)
 
 ## Dynamic Multi-Objective Optimization Problems (DMOPs)
 
 ## Dynamic Multi-Objective Optimization Algorithms (DMOAs)
-
-## Dynamic Multi-Objective Optimization Benchmarks (DMOBs)

pydmoo-0.0.12/README.md

@@ -0,0 +1,9 @@
+# Dynamic Multi-Objective Optimization in Python
+
+[![License](https://img.shields.io/badge/license-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0.en.html)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydmoo)
+[![PyPI](https://img.shields.io/pypi/v/pydmoo)](https://pypi.org/project/pydmoo/)
+
+## Dynamic Multi-Objective Optimization Problems (DMOPs)
+
+## Dynamic Multi-Objective Optimization Algorithms (DMOAs)

pydmoo-0.0.12/docs/api-manual/index.md

@@ -0,0 +1 @@
+# Munual API

pydmoo-0.0.12/docs/reference/algorithms/knowledge-based.md

@@ -0,0 +1 @@
+# Knowledge-Based Algorithms

pydmoo-0.0.12/docs/reference/algorithms/memory-based.md

@@ -0,0 +1 @@
+# Memory-Based Algorithms

pydmoo-0.0.12/docs/reference/algorithms/multi-population-based.md

@@ -0,0 +1 @@
+# Multi-Population-Based Algorithms

pydmoo-0.0.12/docs/reference/algorithms/prediction-based.md

@@ -0,0 +1 @@
+# Prediction-Based Algorithms

{pydmoo-0.0.10 → pydmoo-0.0.12}/mkdocs.yml

@@ -133,14 +133,22 @@ nav:
   - Getting Started:
       - Installation: users-guide/installation.md
 
-  - API:
+  - Auto-API:
       - pydmoo: api-auto/pydmoo.md
       - API reference: api-auto.md
 
+  - Manual API:
+      - API reference: api-manual/index.md
+
   - Reference:
       - reference/index.md
       - Benchmarks: reference/problems/benchmarks.md
-      - Algorithms: reference/algorithms/diversity-based.md
+      - Algorithms:
+          - Diversity-Based: reference/algorithms/diversity-based.md
+          - Memory-Based: reference/algorithms/memory-based.md
+          - Multi-Population-Based: reference/algorithms/multi-population-based.md
+          - Knowledge-Based: reference/algorithms/knowledge-based.md
+          - Prediction-Based: reference/algorithms/prediction-based.md
       - Metrics: reference/metrics/index.md
       - Applications: reference/applications/index.md
 

pydmoo-0.0.12/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-0.0.12/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
+        self._time = time
+
+        self.add_time_perturbation = add_time_perturbation  # added
+
+    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
+            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
+    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
+        # 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-0.0.12/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])