pymoo 0.6.1.1__cp39-cp39-win_amd64.whl → 0.6.1.2__cp39-cp39-win_amd64.whl

pymoo/core/plot.py

@@ -74,7 +74,7 @@ class Plot:
 
         # the colormap or the color lists to use
         if isinstance(cmap, str):
-            self.cmap = matplotlib.cm.get_cmap(cmap)
+            self.cmap = matplotlib.pyplot.get_cmap(cmap)
         else:
             self.cmap = cmap
         if isinstance(self.cmap, ListedColormap):

pymoo/core/result.py

@@ -36,6 +36,9 @@ class Result:
         # the history of the optimization run is they were saved
         self.history = []
 
+        # data stored within the algorithm
+        self.data = None
+
     @property
     def cv(self):
         return self.CV[0]

pymoo/core/variable.py

@@ -1,88 +1,382 @@
+"""
+Module containing infrastructure for representing decision variable classes.
+"""
+
+# public API for when using ``from pymoo.core.variable import *``
+__all__ = [
+    "Variable",
+    "BoundedVariable",
+    "Real",
+    "Integer",
+    "Binary",
+    "Choice",
+    "get",
+]
+
+from typing import Optional, Tuple
+from typing import Union
 import numpy as np
+from numpy.typing import ArrayLike
 
 
 class Variable(object):
-
-    def __init__(self, value=None, active=True, flag="default") -> None:
+    """
+    Semi-abstract base class for the representation of a decision variable.
+    """
+
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            active: bool = True, 
+            flag: str = "default",
+        ) -> None:
+        """
+        Constructor for the ``Variable`` class.
+
+        Parameters
+        ----------
+        value : object, None
+            Value the decision variable is to take.
+        active : bool
+            Whether the variable is active (``True``) or inactive (``False``).
+        flag : str
+            Flag to bind to the decision variable.
+        """
         super().__init__()
         self.value = value
         self.flag = flag
         self.active = active
 
-    def sample(self, n=None):
+    def sample(
+            self, 
+            n: Optional[int] = None,
+        ) -> Union[object,np.ndarray]:
+        """
+        Randomly sample ``n`` instances of a decision variable.
+
+        Parameters
+        ----------
+        n : int, None
+            Number of decision variable samples which to draw.
+            If ``int``, sample ``n`` decision variables.
+            If ``None``, sample a single decision variables.
+        
+        Returns
+        -------
+        out : object, np.ndarray
+            If ``n`` is ``int``, return a ``np.ndarray`` of shape ``(n,)`` 
+            containing sampled decision variables.
+            If ``n`` is ``None``, return an ``object`` of a sampled decision 
+            variable.
+        """
         if n is None:
             return self._sample(1)[0]
         else:
             return self._sample(n)
 
-    def _sample(self, n):
+    def _sample(
+            self, 
+            n: int,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a decision variable.
+        This is an abstract private method governing the behavior of the 
+        ``sample`` method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled decision variables.
+        """
         pass
 
-    def set(self, value):
+    def set(
+            self, 
+            value: object,
+        ) -> None:
+        """
+        Set the value of a decision variable.
+
+        Parameters
+        ----------
+        value : object
+            Value to assign to the decision variable.
+        """
         self.value = value
 
-    def get(self, **kwargs):
+    def get(
+            self, 
+            **kwargs: dict
+        ) -> object:
+        """
+        Get the value of a decision variable.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Additional keyword arguments.
+        
+        Returns
+        -------
+        out : object
+            The value of the decision variable.
+        """
         return self.value
 
 
 class BoundedVariable(Variable):
-
-    def __init__(self, value=None, bounds=(None, None), strict=None, **kwargs) -> None:
+    """
+    Semi-abstract class for the representation of a bounded decision variable.
+    """
+
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            bounds: Tuple[Optional[object],Optional[object]] = (None, None), 
+            strict: Optional[Tuple[Optional[object],Optional[object]]] = None, 
+            **kwargs: dict,
+        ) -> None:
+        """
+        Constructor for the ``BoundedVariable`` class.
+
+        Parameters
+        ----------
+        value : object
+            Value the decision variable is to take.
+        bounds : tuple
+            A tuple of length 2 containing upper and lower limits for the 
+            decision variable.
+        strict : tuple, None
+            Strict boundaries for the decision variable.
+            If ``None``, the value of ``bounds`` is copied to ``strict``.
+        kwargs : dict
+            Additional keyword arguments for ``active`` and ``flag``.
+        """
+        # call the Variable constructor 
         super().__init__(value=value, **kwargs)
         self.bounds = bounds
 
+        # if no strict boundaries were provided, consider ``bounds`` as 
+        # strict boundaries
         if strict is None:
             strict = bounds
         self.strict = strict
 
     @property
-    def lb(self):
+    def lb(self) -> object:
+        """
+        Lower bound of the decision variable.
+
+        Returns
+        -------
+        out : object
+            The decision variable lower bound.
+        """
         return self.bounds[0]
 
     @property
-    def ub(self):
+    def ub(self) -> object:
+        """
+        Upper bound of the decision variable.
+
+        Returns
+        -------
+        out : object
+            The decision variable upper bound.
+        """
         return self.bounds[1]
 
 
 class Real(BoundedVariable):
+    """
+    Class for the representation of bounded, real decision variables.
+    """
+    # variable type represented by this object class
     vtype = float
 
-    def _sample(self, n):
+    def _sample(
+            self, 
+            n: int,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a real, bounded decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled real, bounded 
+            decision variables.
+        """
         low, high = self.bounds
         return np.random.uniform(low=low, high=high, size=n)
 
 
 class Integer(BoundedVariable):
+    """
+    Class for the representation of bounded, integer decision variables.
+    """
+    # variable type represented by this object class
     vtype = int
 
-    def _sample(self, n):
+    def _sample(
+            self, 
+            n: int,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a bounded, integer decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, integer 
+            decision variables.
+        """
         low, high = self.bounds
         return np.random.randint(low, high=high + 1, size=n)
 
 
 class Binary(BoundedVariable):
+    """
+    Class for the representation of a binary, bounded decision variable.
+    """
+    # variable type represented by this object class
     vtype = bool
 
-    def _sample(self, n):
+    def _sample(
+            self, 
+            n: int,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a bounded, binary decision variable.
+        Decision variables are sampled from a uniform distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, binary 
+            decision variables.
+        """
         return np.random.random(size=n) < 0.5
 
 
 class Choice(Variable):
+    """
+    Class for the representation of a discrete, subset decision variable.
+    """
+    # variable type represented by this object class
     vtype = object
 
-    def __init__(self, value=None, options=None, all=None, **kwargs) -> None:
+    def __init__(
+            self, 
+            value: Optional[object] = None, 
+            options: Optional[ArrayLike] = None, 
+            all: Optional[ArrayLike] = None, 
+            **kwargs: dict,
+        ) -> None:
+        """
+        Constructor for the ``Choice`` class.
+
+        Parameters
+        ----------
+        value : object
+            Value the decision variable is to take.
+        options : ArrayLike, None
+            A list of decision variable options from which to choose.
+        all : ArrayLike, None
+            A strict list of decision variable options from which to choose.
+            If ``None``, the value of ``options`` is copied to ``all``.
+        kwargs : dict
+            Additional keyword arguments for ``active`` and ``flag``.
+        """
+        # all super constructor
         super().__init__(value=value, **kwargs)
         self.options = options
 
+        # if strict list not provided, set to ``options``
         if all is None:
             all = options
         self.all = all
 
-    def _sample(self, n):
+    def _sample(
+            self, 
+            n: int,
+        ) -> np.ndarray:
+        """
+        Randomly sample ``n`` instances of a discrete, subset decision variable.
+        Decision variables are sampled with replacement from a uniform 
+        distribution.
+
+        This is a private method governing the behavior of the ``sample`` 
+        method.
+
+        Parameters
+        ----------
+        n : int
+            Number of decision variable samples which to draw.
+
+        Returns
+        -------
+        out : np.ndarray
+            An array of shape ``(n,)`` containing sampled bounded, integer 
+            decision variables.
+        """
         return np.random.choice(self.options, size=n)
 
 
-def get(*args, size=None, **kwargs):
+def get(
+        *args: Tuple[Union[Variable,object],...], 
+        size: Optional[Union[tuple,int]] = None, 
+        **kwargs: dict
+    ) -> Union[tuple,object,None]:
+    """
+    Get decision variable values from a tuple of ``Variable`` objects.
+
+    Parameters
+    ----------
+    args : tuple
+        A tuple of ``Variable`` or ``object``s.
+    size : tuple, int, None
+        Size to reshape decision variables.
+    kwargs : dict
+        Additional keyword arguments to pass to the ``get`` method of the 
+        ``Variable`` class when getting decision variable values.
+    
+    Returns
+    -------
+    out : tuple, object, None
+        Decision variable value(s).
+    """
     if len(args) == 0:
         return
 

pymoo/gradient/__init__.py

@@ -3,7 +3,7 @@ import importlib
 
 GRADIENT_MODULE = "pymoo.gradient.toolbox"
 
-TOOLBOX = "autograd.numpy"
+TOOLBOX = "numpy"
 
 
 def activate(name):
@@ -17,3 +17,5 @@ def activate(name):
 
 def deactivate():
     activate("numpy")
+
+

pymoo/gradient/grad_autograd.py

@@ -1,9 +1,33 @@
 import warnings
-
-import autograd.numpy as anp
 import numpy as np
-from autograd.core import VJPNode, vspace, backward_pass
-from autograd.tracer import new_box, isbox
+
+try:
+    import autograd.numpy as anp
+    from autograd import value_and_grad
+    from autograd.core import VJPNode, backward_pass
+    from autograd.tracer import new_box, isbox
+except:
+    print("autograd only supports numpy < 2.0.0 versions.")
+
+
+def value_and_grad(*args, **kwargs):
+    return value_and_grad(*args, **kwargs)
+
+
+def log(*args, **kwargs):
+    return anp.log(*args, **kwargs)
+
+
+def sqrt(*args, **kwargs):
+    return anp.sqrt(*args, **kwargs)
+
+
+def row_stack(*args, **kwargs):
+    return anp.row_stack(*args, **kwargs)
+
+
+def triu_indices(*args, **kwargs):
+    return anp.triu_indices(*args, **kwargs)
 
 
 def run_and_trace(f, x):

pymoo/util/function_loader.py

@@ -4,10 +4,14 @@ from pymoo.config import Config
 
 
 def get_functions():
-    
     from pymoo.util.nds.fast_non_dominated_sort import fast_non_dominated_sort
     from pymoo.util.nds.efficient_non_dominated_sort import efficient_non_dominated_sort
-    from pymoo.util.nds.tree_based_non_dominated_sort import tree_based_non_dominated_sort
+    from pymoo.util.nds.tree_based_non_dominated_sort import (
+        tree_based_non_dominated_sort,
+    )
+    from pymoo.util.nds.dominance_degree_non_dominated_sort import (
+        dominance_degree_non_dominated_sort,
+    )
     from pymoo.decomposition.util import calc_distance_to_weights
     from pymoo.util.misc import calc_perpendicular_distance
     from pymoo.util.hv import hv
@@ -17,36 +21,41 @@ def get_functions():
 
     FUNCTIONS = {
         "fast_non_dominated_sort": {
-            "python": fast_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
+            "python": fast_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
         },
         "efficient_non_dominated_sort": {
-            "python": efficient_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
+            "python": efficient_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "fast_best_order_sort": {
+            "python": None,
+            "cython": "pymoo.cython.non_dominated_sorting",
         },
         "tree_based_non_dominated_sort": {
-            "python": tree_based_non_dominated_sort, "cython": "pymoo.cython.non_dominated_sorting"
+            "python": tree_based_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
+        },
+        "dominance_degree_non_dominated_sort": {
+            "python": dominance_degree_non_dominated_sort,
+            "cython": "pymoo.cython.non_dominated_sorting",
         },
         "calc_distance_to_weights": {
-            "python": calc_distance_to_weights, "cython": "pymoo.cython.decomposition"
+            "python": calc_distance_to_weights,
+            "cython": "pymoo.cython.decomposition",
         },
         "calc_perpendicular_distance": {
-            "python": calc_perpendicular_distance, "cython": "pymoo.cython.calc_perpendicular_distance"
+            "python": calc_perpendicular_distance,
+            "cython": "pymoo.cython.calc_perpendicular_distance",
         },
         "stochastic_ranking": {
-            "python": stochastic_ranking, "cython": "pymoo.cython.stochastic_ranking"
-        },
-        "hv": {
-            "python": hv, "cython": "pymoo.cython.hv"
-        },
-        "calc_mnn": {
-            "python": calc_mnn, "cython": "pymoo.cython.mnn"
+            "python": stochastic_ranking,
+            "cython": "pymoo.cython.stochastic_ranking",
         },
-        "calc_2nn": {
-            "python": calc_2nn, "cython": "pymoo.cython.mnn"
-        },
-        "calc_pcd": {
-            "python": calc_pcd, "cython": "pymoo.cython.pruning_cd"
-        },
-
+        "hv": {"python": hv, "cython": "pymoo.cython.hv"},
+        "calc_mnn": {"python": calc_mnn, "cython": "pymoo.cython.mnn"},
+        "calc_2nn": {"python": calc_2nn, "cython": "pymoo.cython.mnn"},
+        "calc_pcd": {"python": calc_pcd, "cython": "pymoo.cython.pruning_cd"},
     }
 
     return FUNCTIONS
@@ -111,6 +120,7 @@ def load_function(func_name=None, _type="auto"):
 def is_compiled():
     try:
         from pymoo.cython.info import info
+
         if info() == "yes":
             return True
         else: