pydmoo 0.0.18__py3-none-any.whl → 0.1.0__py3-none-any.whl

pydmoo/core/sample_uniform.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+
+def uniform_sample_in_neighborhood(x, radius=0.1, bounds=None, size=1, random_state=None):
+    """
+    Generate uniformly distributed samples within hypercube neighborhoods of input points.
+
+    Parameters
+    ----------
+    x : ndarray, shape (m, n)
+        Input matrix of m solutions in n-dimensional space.
+    radius : float or array_like, optional
+        Neighborhood sampling radius. Can be:
+        - Scalar: uniform radius for all dimensions (default=0.1)
+        - Array of shape (n,): dimension-specific radii
+        - Array of shape (m, n): solution-specific and dimension-specific radii
+    bounds : tuple of array_like, optional
+        Tuple containing (lower_bound, upper_bound) where each is of shape (n,).
+        If provided, samples will be clipped to these bounds.
+    size : int, optional
+        Number of samples to generate per solution (default=1).
+
+    Returns
+    -------
+    ndarray
+        Sampled solutions:
+        - If size=1: shape (m, n)
+        - If size>1: shape (m, size, n)
+
+    Notes
+    -----
+    1. Sampling is performed using uniform distribution within [-radius, +radius]
+       around each solution coordinate.
+    2. For bounded sampling, uses np.clip to enforce constraints.
+    3. The function preserves input dtype for numerical precision.
+
+    Examples
+    --------
+    >>> x = np.array([[1.0, 2.0], [3.0, 4.0]])
+    >>> # Single sample with uniform radius
+    >>> samples = uniform_sample_in_neighborhood(x, radius=0.5)
+    >>> # Multiple samples with dimension-specific radii
+    >>> samples = uniform_sample_in_neighborhood(x, radius=[0.1, 0.2], size=10)
+    """
+    # Input validation and shape processing
+    x = np.asarray(x)
+    m, n = x.shape  # m solutions, n dimensions
+
+    # Process radius parameter
+    if np.isscalar(radius):
+        radius = np.full((1, n), radius)  # Broadcast scalar to all dimensions
+    elif isinstance(radius, (list, np.ndarray)) and len(radius) == n:
+        radius = np.reshape(radius, (1, n))  # Convert 1D vector to row vector
+
+    # Generate random perturbations
+    samples = x[:, np.newaxis, :] + random_state.uniform(low=-radius, high=radius, size=(m, size, n))  # np.random
+
+    # Apply bounds constraint if provided
+    if bounds is not None:
+        lb, ub = np.asarray(bounds[0]), np.asarray(bounds[1])
+        samples = np.clip(samples, lb, ub)
+
+    return samples.squeeze()

pydmoo/{response/tca_model.py → core/transfer.py}

@@ -2,7 +2,7 @@ import numpy as np
 from scipy.linalg import eigh
 
 
-class TCAModel:
+class TCA:
     """Transfer Component Analysis (TCA) for domain adaptation.
 
     TCA finds a latent space where source and target domain distributions are similar.
@@ -141,8 +141,8 @@ class TCAModel:
         if self.kernel_type == 'linear':
             return X1 @ X2.T  # Linear kernel: K(x,y) = x^T y
         elif self.kernel_type == 'rbf':
-            # RBF kernel: K(x,y) = exp(-γ||x-y||²)
-            # Efficient computation using ||x-y||² = ||x||² + ||y||² - 2x^T y
+            # RBF kernel: K(x,y) = exp(-\gamma||x-y||^2)
+            # Efficient computation using ||x-y||^2 = ||x||^2 + ||y||^2 - 2x^T y
             dist_sq = (np.sum(X1**2, axis=1)[:, np.newaxis] + np.sum(X2**2, axis=1) - 2 * X1 @ X2.T)
             return np.exp(-self.kernel_param * dist_sq)
         elif self.kernel_type == 'poly':

pydmoo/problems/__init__.py

@@ -35,57 +35,61 @@ from pydmoo.problems.dynamic.gts import (
     GTS11_2,
     GTS11_3,
 )
+from pydmoo.problems.real_world.dsrp import DSRP
+from pydmoo.problems.real_world.dwbdp import DWBDP
 
 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,
+    "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,
+    "dsrp": DSRP,
+    "dwbdp": DWBDP,
 }
 
 

pydmoo/problems/dyn.py

@@ -1,7 +1,10 @@
 """
-Include modified code from [pymoo](https://github.com/anyoptimization/pymoo):
- [dyn.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dyn.py),
-licensed under Apache License 2.0. Original copyright and license terms are preserved.
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [dyn.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dyn.py)
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
 """
 
 from abc import ABC
@@ -16,17 +19,74 @@ class DynamicProblem(Problem, ABC):
     pass
 
 
-class DynamicTestProblem(DynamicProblem, ABC):
+class DynamicApplProblem(DynamicProblem):
+
+    def __init__(self, nt, taut, t0=50, tau=1, time=None, **kwargs):
+        super().__init__(**kwargs)
+        self.tau = tau
+        self.nt = nt
+        self.taut = taut
+        self.t0 = t0
+        self._time = time
+
+    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)
+
+            # Calculate base time step
+            delta_time = 1 / self.nt
+
+            # Calculate time count considering initial offset
+            count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
+
+            # Return time value
+            return delta_time * count
+
+    @time.setter
+    def time(self, value):
+        self._time = value
+
+    def update_to_next_time(self):
+        """Advance problem to the next significant time step.
+
+        Returns
+        -------
+            elapsed: The actual time units advanced
+        """
+        # Calculate how many time steps to advance
+        count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
+
+        # Calculate exact elapsed time needed to reach next discrete time point
+        elapsed = int(count * self.taut + (self.t0 + 1) - self.tau)
+
+        # Advance time by calculated amount
+        self.tic(elapsed=elapsed)
+
+        return elapsed
+
+
+class DynamicTestProblem(DynamicProblem):
 
     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.t0 = t0  # Initial time offset - added by DynOpt Team
         self._time = time
 
-        self.add_time_perturbation = add_time_perturbation  # added by DynOpt
+        self.add_time_perturbation = add_time_perturbation  # Stochastic perturbation flag - added by DynOpt Team
 
     def tic(self, elapsed=1):
 
@@ -43,48 +103,69 @@ class DynamicTestProblem(DynamicProblem, ABC):
         else:
             # return 1 / self.nt * (self.tau // self.taut)
 
-            # added by DynOpt
+            # Modified by DynOpt Team
+            # Calculate base time step
             delta_time = 1 / self.nt
+
+            # Calculate time count considering initial offset
             count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
 
+            # Calculate perturbation ratio if enabled
             if not self.add_time_perturbation:
                 ratio = 0
 
             else:
+                # Use mathematical constants to generate deterministic perturbations
                 mp.dps = max(ceil(10 + count), 10)
-                mp_pi = 0 if count == 0 else int(str(mp.pi).split(".")[-1][count - 1])
+                mp_pi = 0 if count == 0 else int(str(mp.pi).split(".")[-1][count - 1])  # Extract digit from pi
                 ratio = 0.5 * 1 / 9 * mp_pi
 
+            # Return time value with optional perturbation
             return delta_time * count + delta_time * ratio
 
     @time.setter
     def time(self, value):
         self._time = value
 
-    # added by DynOpt
+    # Added by DynOpt Team
     def update_to_next_time(self):
+        """Advance problem to the next significant time step.
 
-        # update to next time
+        Returns
+        -------
+            elapsed: The actual time units advanced
+        """
+        # Calculate how many time steps to advance
         count = max((self.tau + self.taut - (self.t0 + 1)), 0) // self.taut
 
+        # Calculate exact elapsed time needed to reach next discrete time point
         elapsed = int(count * self.taut + (self.t0 + 1) - self.tau)
 
+        # Advance time by calculated amount
         self.tic(elapsed=elapsed)
 
         return elapsed
 
 
 class TimeSimulation(Callback):
+    """Callback for simulating time evolution in dynamic optimization problems.
+
+    Handles time-linkage properties and time step updates.
+    """
 
     def update(self, algorithm):
+        """Update method called at each algorithm iteration."""
         problem = algorithm.problem
 
-        # added by DynOpt
-        # Designed to handle time-linkage properties within the GTS test suites.
+        # Added by DynOpt Team
+        # Emulate time-linkage property: Update problem state based on current optimal solutions
+        # Must execute before the problem.tic() to ensure proper time sequencing
         if hasattr(problem, "time_linkage") and hasattr(problem, "cal"):
+            # Calculate time-linkage effects using current optimal objective values
             problem.cal(algorithm.opt.get("F"))
 
+        # Advance time step for dynamic problem simulation
         if hasattr(problem, "tic"):
-            problem.tic()
+            problem.tic()  # Progress the dynamic problem to next time step
         else:
             raise Exception("TimeSimulation can only be used for dynamic test problems.")

pydmoo/problems/dynamic/cec2015.py

@@ -1,7 +1,12 @@
 """
-Include modified code from [pymoo](https://github.com/anyoptimization/pymoo):
- [cec2015.py](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.
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [cec2015.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dynamic/cec2015.py)
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
+
+Add the method `_calc_pareto_front` for FDA4 and FDA5.
 """
 
 from math import cos, fabs, floor, pi, sin, sqrt
@@ -39,7 +44,7 @@ class FDA4(DynamicCEC2015):
         from pymoo.vendor.gta import FDA4 as f
         out["F"] = np.array([f(x, t) for x in X])
 
-    # added by DynOpt
+    # 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')
@@ -62,7 +67,7 @@ class FDA5(DynamicCEC2015):
         from pymoo.vendor.gta import FDA5 as f
         out["F"] = np.array([f(x, t) for x in X])
 
-    # added by DynOpt
+    # 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')

pydmoo/problems/dynamic/df.py

@@ -1,7 +1,10 @@
 """
-Include modified code from [pymoo](https://github.com/anyoptimization/pymoo):
- [df.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dynamic/df.py),
-licensed under Apache License 2.0. Original copyright and license terms are preserved.
+Includes modified code from [pymoo](https://github.com/anyoptimization/pymoo).
+
+Sources:
+    - [df.py](https://github.com/anyoptimization/pymoo/blob/main/pymoo/problems/dynamic/df.py)
+
+Licensed under the Apache License, Version 2.0. Original copyright and license terms are preserved.
 """
 
 import numpy as np

pydmoo/problems/dynamic/gts.py

@@ -8,55 +8,55 @@ from pydmoo.problems.dyn import DynamicTestProblem
 from pydmoo.problems.dynamic.df import get_PF
 
 
-def knee_point(F):
-    ideal_point = np.min(F, axis=0)
-    distances = cdist(F, [ideal_point])
+def knee_point(solved_pf: np.ndarray):
+    ideal_point = np.min(solved_pf, axis=0)
+    distances = cdist(solved_pf, [ideal_point])
     knee_idx = np.argmax(distances)
-    return F[knee_idx]
+    return solved_pf[knee_idx]
 
 
 def G_t(t):
-    """\\( G(t) = \\sin(0.5\\pi t) \\)"""
+    # $G(t) = \\sin(0.5\\pi t)$
     return np.sin(0.5 * np.pi * t)
 
 
 def H_t(t):
-    """\\( H(t) = 1.5 + G(t) \\)"""
+    # $H(t) = 1.5 + G(t)$
     return 1.5 + G_t(t)
 
 
 def alpha_t(t):
-    """\\( \\alpha_t = 5\\cos(0.5\\pi t) \\)"""
+    # $\\alpha_t = 5\\cos(0.5\\pi t)$
     return 5 * np.cos(0.5 * np.pi * t)
 
 
 def beta_t(t):
-    """\\( \\beta_t = 0.2 + 2.8|G(t)| \\)"""
+    # $\\beta_t = 0.2 + 2.8|G(t)|$
     return 0.2 + 2.8 * np.abs(G_t(t))
 
 
 def omega_t(t):
-    """\\( \\omega_t = \\lfloor 10G(t) \\rfloor \\)"""
+    # $\\omega_t = \\lfloor 10G(t) \\rfloor$
     return np.floor(10 * G_t(t))
 
 
 def a_t(t):
-    """\\( a(t) = \\sin(0.5\\pi t) \\)"""
+    # $a(t) = \\sin(0.5\\pi t)$
     return np.sin(0.5 * np.pi * t)
 
 
 def b_t(t):
-    """\\( b(t) = 1 + |\\cos(0.5\\pi t)| \\)"""
+    # $b(t) = 1 + |\\cos(0.5\\pi t)|$
     return 1 + np.abs(np.cos(0.5 * np.pi * t))
 
 
 def y_t(x1, t):
-    """\\( y_t(x_1) = 0.5 + G(t)(x_1 - 0.5) \\)"""
+    # $y_t(x_1) = 0.5 + G(t)(x_1 - 0.5)$
     return 0.5 + G_t(t) * (x1 - 0.5)
 
 
 def p_t(t):
-    """\\( p_t = \\lfloor 6G(t) \\rfloor \\)"""
+    # $p_t = \\lfloor 6G(t) \\rfloor$
     return np.floor(6 * G_t(t))
 
 
@@ -131,23 +131,69 @@ class GTS(DynamicTestProblem):
 
 
 class GTS1(GTS):
-    r"""
+    r"""GTS1 test problem.
+
+    - Inherits all parameters from parent class GTS.
+
+    Attributes
+    ----------
+    name : str
+        Problem name, default is 'GTS3'
+    n_var : int
+        Number of decision variables
+    n_obj : int
+        Number of objective functions
+    time_linkage : bool
+        Whether the problem has time linkage
+
+    Notes
+    -----
+    - Mathematical Formulation:
+
     \begin{equation}
-    \text{min}
-    \begin{cases}
-    f_1(\mathbf{x},t) = x_1 \\
-    f_2(\mathbf{x},t) = g(\mathbf{x},t)(1 -  (\frac{x_1}{g(\mathbf{x},t)})^{H(t)})
-    \end{cases}
+        \text{min}
+        \begin{cases}
+            f_1(\mathbf{x},t) = x_1 \\
+            f_2(\mathbf{x},t) = g(\mathbf{x},t)(1 -  (\frac{x_1}{g(\mathbf{x},t)})^{H(t)})
+            \end{cases}
     \end{equation}
 
-    ![GTS1 PS](../figs/PS/GTS1.png)
+    \begin{equation}
+        \text{min}
+        \begin{cases}
+            f_1(\mathbf{x},t) = x_1 \\
+            f_2(\mathbf{x},t) = g(\mathbf{x},t)(1 -  (\frac{x_1}{g(\mathbf{x},t)})^{H(t)})
+        \end{cases}
+    \end{equation}
+
+    with
+
+    \begin{equation*}
+        \begin{split}
+            g(\mathbf{x},t) = 1
+             & + \Bigl(\bigl(\mathbf{x}_{II,1} - h_1(\mathbf{x}_I)\bigr)^T \mathbf{R}_{II,1}(t) \bigl(\mathbf{x}_{II,1} - h_1(\mathbf{x}_I)\bigr)\Bigr)^{\frac{1}{p}} \\
+             & + \Bigl(\bigl(\mathbf{x}_{II,2} - h_2(\mathbf{x}_I)\bigr)^T \mathbf{R}_{II,2}(t) \bigl(\mathbf{x}_{II,2} - h_2(\mathbf{x}_I)\bigr)\Bigr)^{\frac{1}{p}}
+        \end{split}
+    \end{equation*}
+
+    where $p \geq 1$, $\mathbf{x}_I = (x_1)$, $\mathbf{x}_{II,1} = (x_2, \cdots, x_{\lfloor\frac{D}{2}\rfloor})$ and $\mathbf{x}_{II,2} = (x_{\lfloor\frac{D}{2}\rfloor + 1}, \cdots, x_D)$,
+    $h_1(\mathbf{x}_I, t) = \cos(0.5\pi t)$ and $h_2(\mathbf{x}_I, t) = G(t) + x_1^{H(t)}$,
+    $\mathbf{R}_{II,1}(t)$ and $\mathbf{R}_{II,2}(t)$ are symmetric positive semidefinite matrices in the $t$-th environment,
+    the search space is $[0,1] \times [-1,1]^{\lfloor\frac{D}{2}\rfloor -1} \times  [-1, 2]^{\lceil\frac{D}{2}\rceil}$.
 
-    ![GTS1 PF](../figs/PF/GTS1.png)
+    - Pareto set (PS)
+
+    ![GTS1 PS](../../figs/PS/GTS1.png)
+
+    - Pareto front (PF)
+
+    ![GTS1 PF](../../figs/PF/GTS1.png)
     """
     def __init__(self, **kwargs):
         super().__init__(part_idx=1, bounds=((0, 1), (-1, 1), (-1, 2)), **kwargs)
 
     def _evaluate(self, x, out, *args, **kwargs):
+        """Evaluate."""
         xi = np.cos(0.5 * np.pi * self.time)
         xj = G_t(self.time) + np.power(x[:, 0], H_t(self.time))
 
@@ -164,12 +210,14 @@ class GTS1(GTS):
         out["F"] = np.column_stack([f1, f2])
 
     def _calc_pareto_front(self, *args, n_pareto_points=100, **kwargs):
+        """Pareto front."""
         x = np.linspace(0, 1, n_pareto_points)
         f1 = x
         f2 = 1 - np.power(x, H_t(self.time))
         return np.array([f1, f2]).T
 
     def _calc_pareto_set(self, *args, n_pareto_points=100, **kwargs):
+        """Pareto set."""
         x_vec1 = np.linspace(0, 1, n_pareto_points)
         x_vec2 = np.full(len(x_vec1), np.cos(0.5 * np.pi * self.time))
         x_vec3 = G_t(self.time) + np.power(x_vec1, H_t(self.time))
@@ -178,19 +226,6 @@ class GTS1(GTS):
 
 
 class GTS2(GTS):
-    r"""
-    \begin{equation}
-    \text{min}
-    \begin{cases}
-    f_1(\mathbf{x},t) = 0.5x_1+x_2 \\
-    f_2(\mathbf{x},t) = g(\mathbf{x},t)(2.8 - (\frac{0.5x_1+x_2}{g(\mathbf{x},t)})^{H(t)})
-    \end{cases}
-    \end{equation}
-
-    ![GTS2 PS](../figs/PS/GTS2.png)
-
-    ![GTS2 PF](../figs/PF/GTS2.png)
-    """
     def __init__(self, **kwargs):
         super().__init__(part_idx=2, bounds=((0, 1), (0, 1), (-1, 2)), **kwargs)