pymoo 0.6.1.2__cp312-cp312-macosx_10_9_universal2.whl

pymoo/core/variable.py

@@ -0,0 +1,399 @@
+"""
+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):
+    """
+    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: 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: 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: 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: 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):
+    """
+    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) -> object:
+        """
+        Lower bound of the decision variable.
+
+        Returns
+        -------
+        out : object
+            The decision variable lower bound.
+        """
+        return self.bounds[0]
+
+    @property
+    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: 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: 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: 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: 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: 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: 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
+
+    ret = []
+    for arg in args:
+        v = arg.get(**kwargs) if isinstance(arg, Variable) else arg
+
+        if size is not None:
+
+            if isinstance(v, np.ndarray):
+                v = np.reshape(v, size)
+            else:
+                v = np.full(size, v)
+
+        ret.append(v)
+
+    if len(ret) == 1:
+        return ret[0]
+    else:
+        return tuple(ret)

pymoo/cython/utils.pxd

@@ -0,0 +1,129 @@
+# distutils: language = c++
+# cython: language_level=2, boundscheck=False, wraparound=False, cdivision=True
+
+import numpy as np
+
+from libcpp cimport bool
+from libcpp.vector cimport vector
+from libcpp.set cimport set as cpp_set
+
+
+cdef extern from "math.h":
+    double HUGE_VAL
+
+
+# Returns elements to remove based on crowding metric d and heap of remaining elements H
+cdef inline int c_get_drop(double[:] d, cpp_set[int] H):
+
+    cdef:
+        int i, min_i
+        double min_d
+
+    min_d = HUGE_VAL
+    min_i = 0
+
+    for i in H:
+
+        if d[i] <= min_d:
+            min_d = d[i]
+            min_i = i
+
+    return min_i
+
+
+# Returns vector of positions of minimum values along axis 0 of a 2d memoryview
+cdef inline vector[int] c_get_argmin(double[:, :] X):
+
+    cdef:
+        int N, M, min_i, n, m
+        double min_val
+        vector[int] indexes
+
+    N = X.shape[0]
+    M = X.shape[1]
+
+    indexes = vector[int]()
+
+    for m in range(M):
+
+        min_i = 0
+        min_val = X[0, m]
+
+        for n in range(N):
+
+            if X[n, m] < min_val:
+
+                min_i = n
+                min_val = X[n, m]
+
+        indexes.push_back(min_i)
+
+    return indexes
+
+
+# Returns vector of positions of maximum values along axis 0 of a 2d memoryview
+cdef inline vector[int] c_get_argmax(double[:, :] X):
+
+    cdef:
+        int N, M, max_i, n, m
+        double max_val
+        vector[int] indexes
+
+    N = X.shape[0]
+    M = X.shape[1]
+
+    indexes = vector[int]()
+
+    for m in range(M):
+
+        max_i = 0
+        max_val = X[0, m]
+
+        for n in range(N):
+
+            if X[n, m] > max_val:
+
+                max_i = n
+                max_val = X[n, m]
+
+        indexes.push_back(max_i)
+
+    return indexes
+
+
+# Performs normalization of a 2d memoryview
+cdef inline double[:, :] c_normalize_array(double[:, :] X, vector[int] extremes_max, vector[int] extremes_min):
+
+    cdef:
+        int N = X.shape[0]
+        int M = X.shape[1]
+        int n, m, l, u
+        double l_val, u_val, diff_val
+        vector[double] min_vals, max_vals
+
+    min_vals = vector[double]()
+    max_vals = vector[double]()
+
+    m = 0
+    for u in extremes_max:
+        u_val = X[u, m]
+        max_vals.push_back(u_val)
+        m = m + 1
+
+    m = 0
+    for l in extremes_min:
+        l_val = X[l, m]
+        min_vals.push_back(l_val)
+        m = m + 1
+
+    for m in range(M):
+
+        diff_val = max_vals[m] - min_vals[m]
+        if diff_val == 0.0:
+            diff_val = 1.0
+
+        for n in range(N):
+
+            X[n, m] = (X[n, m] - min_vals[m]) / diff_val
+
+    return X

pymoo/cython/vendor/hypervolume.h

@@ -0,0 +1,63 @@
+
+
+#ifndef HYPERVOLUME_H
+#define HYPERVOLUME_H
+
+/*!
+ *
+ * \brief Implementation of the Overmars-Yap Algorithm, originally provided by N. Beume.
+ *
+ * Applicable to points of dimension d >= 3. It is assumed that the array of points is sorted
+ * according to the 'last' objective.
+ *
+ * <PRE>
+ * author = {Nicola Beume and G\"unther Rudolph},
+ * title = {Faster {S}-Metric Calculation By Considering Dominated Hypervolume as {Klee}'s Measure Problem},
+ * booktitle = {IASTED International Conference on Computational Intelligence},
+ * publisher = {ACTA Press},
+ * pages = {231-236},
+ * year = {2006},
+ * </PRE>
+ */
+ 
+double overmars_yap( double * points, double * referencePoint, unsigned noObjectives, unsigned noPoints );
+
+/*!
+ *
+ * \brief Algorithm for the special case of d = 3 objectives.
+ *
+ * Applicable to points of dimension d = 3.
+ *
+ * Relevant literature:
+ *
+ * [1]  C. M. Fonseca, L. Paquete, and M. Lopez-Ibanez. An
+ *     improved dimension-sweep algorithm for the hypervolume
+ *     indicator. In IEEE Congress on Evolutionary Computation,
+ *     pages 1157-1163, Vancouver, Canada, July 2006.
+ *
+ * [2]  L. Paquete, C. M. Fonseca and M. Lopez-Ibanez. An optimal
+ *     algorithm for a special case of Klee's measure problem in three
+ *     dimensions. Technical Report CSI-RT-I-01/2006, CSI, Universidade
+ *     do Algarve, 2006.
+ */
+ 
+double fonseca( double * points, double * referencePoint, unsigned noObjectives, unsigned noPoints );
+
+
+//!
+//! \brief computation of the hypervolume
+//!
+//! \par
+//! This function acts as a frontend to various algorithms
+//! for the computation of the hypervolume.
+//!
+//! \param  points          the list containes the coordinates of all points in a single array
+//! \param  referencePoint  the reference or nadir point
+//! \param  noObjectives    number of coordinates per point
+//! \param  noPoints        number of points in the list
+//! \return                 dominated hypervolume
+//!
+double hypervolume(double* points, double* referencePoint, unsigned int noObjectives, unsigned int noPoints);
+
+
+#endif // HYPERVOLUME_H

pymoo/decomposition/aasf.py

@@ -0,0 +1,24 @@
+import numpy as np
+
+from pymoo.decomposition.asf import ASF
+
+
+class AASF(ASF):
+
+    def __init__(self, eps=1e-10, _type="auto", rho=None, beta=None, **kwargs) -> None:
+        super().__init__(eps, _type, **kwargs)
+        if rho is None and beta is None:
+            raise Exception("Either provide rho or beta!")
+        elif rho is None:
+            self.rho = calc_rho(beta)
+        else:
+            self.rho = rho
+
+    def _do(self, F, weights, **kwargs):
+        asf = super()._do(F, weights, **kwargs)
+        augment = ((F - self.utopian_point) / np.clip(weights, 1e-12, np.inf)).sum(axis=1)
+        return asf + self.rho * augment
+
+
+def calc_rho(beta):
+    return 1 / (1 - np.tan(beta / 360 * 2 * np.pi)) - 1

pymoo/decomposition/asf.py

@@ -0,0 +1,10 @@
+from pymoo.core.decomposition import Decomposition
+
+
+class ASF(Decomposition):
+
+    def _do(self, F, weights, weight_0=1e-10, **kwargs):
+        _weights = weights.astype(float)
+        _weights[weights == 0] = weight_0
+        asf = ((F - self.utopian_point) / _weights).max(axis=1)
+        return asf

pymoo/decomposition/pbi.py

@@ -0,0 +1,13 @@
+from pymoo.core.decomposition import Decomposition
+from pymoo.util.function_loader import load_function
+
+
+class PBI(Decomposition):
+
+    def __init__(self, theta=5, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.theta = theta
+
+    def _do(self, F, weights, **kwargs):
+        d1, d2 = load_function("calc_distance_to_weights")(F, weights, self.utopian_point)
+        return d1 + self.theta * d2

pymoo/decomposition/perp_dist.py

@@ -0,0 +1,13 @@
+from pymoo.core.decomposition import Decomposition
+from pymoo.util.function_loader import load_function
+
+
+class PerpendicularDistance(Decomposition):
+
+    def __init__(self, theta=5, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.theta = theta
+
+    def _do(self, F, weights, **kwargs):
+        _, d2 = load_function("calc_distance_to_weights")(F, weights)
+        return d2

pymoo/decomposition/tchebicheff.py

@@ -0,0 +1,11 @@
+import numpy as np
+
+from pymoo.core.decomposition import Decomposition
+
+
+class Tchebicheff(Decomposition):
+
+    def _do(self, F, weights, **kwargs):
+        v = np.abs(F - self.utopian_point) * weights
+        tchebi = v.max(axis=1)
+        return tchebi