pymoo 0.6.1.5.dev0__cp311-cp311-musllinux_1_2_x86_64.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 Any, 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: Any
+        ) -> object:
+        """
+        Get the value of a decision variable.
+
+        Parameters
+        ----------
+        kwargs : Any
+            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: Any,
+        ) -> 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 : Any
+            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: Any,
+        ) -> 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 : Any
+            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: Any
+    ) -> 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 : Any
+        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/calc_perpendicular_distance.pyx

@@ -0,0 +1,67 @@
+# distutils: language = c++
+# cython: language_level=2, boundscheck=False, wraparound=False, cdivision=True
+
+
+import numpy as np
+from libcpp.vector cimport vector
+
+
+
+def calc_perpendicular_distance(double[:,:] P, double[:,:] L):
+    return np.array(c_calc_perpendicular_distance(P, L))
+
+
+cdef extern from "math.h":
+    double sqrt(double m)
+    double pow(double base, double exponent)
+
+
+cdef double c_norm(double[:] v):
+    cdef:
+        double val
+        int i
+    val = 0
+    for i in range(v.shape[0]):
+        val += pow(v[i], 2)
+    val = sqrt(val)
+    return val
+
+
+cdef double[:,:] c_calc_perpendicular_distance(double[:,:] P, double[:,:] L):
+    cdef :
+        int s_L, s_P, n_dim, i, j, k
+        double[:,:] M
+        vector[double] N
+        double norm, dot, perp_dist, norm_scalar_proj
+
+    s_L = L.shape[0]
+    s_P = P.shape[0]
+    n_dim = L.shape[1]
+
+    M = np.zeros((s_P, s_L), dtype=np.float64)
+
+    for i in range(s_L):
+
+        norm = c_norm(L[i, :])
+
+        N = vector[double](n_dim)
+        for k in range(n_dim):
+            N[k] = L[i, k] / norm
+
+        for j in range(s_P):
+
+            dot = 0
+            for k in range(n_dim):
+                dot += L[i, k] * P[j, k]
+            norm_scalar_proj = dot / norm
+
+            perp_dist = 0
+            for k in range(n_dim):
+                perp_dist += pow(norm_scalar_proj * N[k] - P[j, k], 2)
+            perp_dist = sqrt(perp_dist)
+
+            M[j, i] = perp_dist
+
+    return M
+
+

pymoo/cython/decomposition.pyx

@@ -0,0 +1,165 @@
+# distutils: language = c++
+# cython: language_level=2, boundscheck=False, wraparound=False, cdivision=True
+
+
+import numpy as np
+from libcpp.vector cimport vector
+
+
+# -----------------------------------------------------------
+# INTERFACE
+# -----------------------------------------------------------
+
+def calc_perpendicular_distance(double[:,:] P, double[:,:] L):
+    return np.array(c_calc_perpendicular_distance(P, L))
+
+
+def pbi(double[:,:] F, double[:,:] weights, double[:] ideal_point, double theta, double eps=1e-10):
+    return np.array(c_pbi(F, weights, ideal_point, theta, eps), dtype=np.float64)
+
+
+def calc_distance_to_weights(F, weights, utopian_point=None):
+
+    if utopian_point is None:
+        utopian_point = np.zeros(F.shape[1])
+
+    norm = np.linalg.norm(weights, axis=1)
+
+    d1, d2 = np.zeros(F.shape[0]), np.zeros(F.shape[0])
+
+    F = F - utopian_point
+    c_d1(d1, F, weights, norm)
+    c_d2(d2, F, weights, d1, norm)
+
+    return d1, d2
+
+
+# -----------------------------------------------------------
+# IMPLEMENTATION
+# -----------------------------------------------------------
+
+cdef extern from "math.h":
+    double sqrt(double m)
+    double pow(double base, double exponent)
+
+
+
+
+cdef double c_norm(double[:] v):
+    cdef:
+        double val
+        int i
+
+    val = 0
+    for i in range(v.shape[0]):
+        val += pow(v[i], 2)
+    val = sqrt(val)
+    return val
+
+
+cdef double[:,:] c_calc_perpendicular_distance(double[:,:] P, double[:,:] L):
+    cdef :
+        int s_L, s_P, n_dim, i, j, k
+        double[:,:] M
+        vector[double] N
+        double norm, dot, perp_dist, norm_scalar_proj
+
+    s_L = L.shape[0]
+    s_P = P.shape[0]
+    n_dim = L.shape[1]
+
+    M = np.zeros((s_P, s_L), dtype=np.float64)
+
+    for i in range(s_L):
+
+        norm = c_norm(L[i, :])
+
+        N = vector[double](n_dim)
+        for k in range(n_dim):
+            N[k] = L[i, k] / norm
+
+        for j in range(s_P):
+
+            dot = 0
+            for k in range(n_dim):
+                dot += L[i, k] * P[j, k]
+            norm_scalar_proj = dot / norm
+
+            perp_dist = 0
+            for k in range(n_dim):
+                perp_dist += pow(norm_scalar_proj * N[k] - P[j, k], 2)
+            perp_dist = sqrt(perp_dist)
+
+            M[j, i] = perp_dist
+
+    return M
+
+
+
+cdef vector[double] c_pbi(double[:,:] F, double[:,:] weights, double[:] ideal_point, double theta, double eps):
+    cdef:
+        double d1, d2, f_max, norm
+        int i, j, n_dim
+        vector[double] pbi
+
+    n_points = F.shape[0]
+    n_obj = F.shape[1]
+    pbi = vector[double](n_points)
+
+    for i in range(n_points):
+
+        norm = c_norm(weights[i,:])
+
+        d1 = 0
+        for j in range(n_obj):
+            d1 += (F[i,j] - ideal_point[j] + eps) * weights[i,j]
+        d1 = d1 / norm
+
+        d2 = 0
+        for j in range(n_obj):
+            d2 += pow(F[i,j] - ideal_point[j] + eps - (d1 * weights[i,j] / norm), 2.0)
+        d2 = sqrt(d2)
+
+        pbi[i] = d1 + theta * d2
+
+    return pbi
+
+
+
+
+cdef void c_d1(double[:] d1, double[:,:] F, double[:,:] weights, double[:] norm):
+    cdef:
+        double val
+        int i, j
+
+    n_points = F.shape[0]
+    n_obj = F.shape[1]
+
+    for i in range(n_points):
+
+        val = 0
+        for j in range(n_obj):
+            val += F[i,j] * weights[i,j]
+        d1[i] = val / norm[i]
+
+
+
+
+cdef void c_d2(double[:] d2, double[:,:] F, double[:,:] weights, double[:] d1, double[:] norm):
+    cdef:
+        double val
+        int i, j
+
+    n_points = F.shape[0]
+    n_obj = F.shape[1]
+
+    for i in range(n_points):
+
+        val = 0
+        for j in range(n_obj):
+            val += pow(F[i,j] - (d1[i] * weights[i,j] / norm[i]), 2.0)
+        d2[i] = sqrt(val)
+
+
+
+

pymoo/cython/hv.pyx

@@ -0,0 +1,18 @@
+# distutils: language = c++
+# cython: language_level=2, boundscheck=False, wraparound=False, cdivision=True
+
+import numpy as np
+
+cdef extern from "vendor/hypervolume.cpp":
+    double overmars_yap(double * points, double * referencePoint, unsigned noObjectives, unsigned noPoints);
+
+
+def hv(ref_point, F):
+    F = F[np.argsort(F[:, -1])]
+    n, m = F.shape
+    return c_hv(F, ref_point, m, n)
+
+
+def c_hv(double[:,:] F, double[:] ref_point, m, n):
+    return overmars_yap(&F[0, 0], &ref_point[0], m, n)
+    # return fpli_hv(&F[0,0], m, n, &ref_point[0])

pymoo/cython/info.pyx

@@ -0,0 +1,5 @@
+# distutils: language = c++
+# cython: language_level=2, boundscheck=False, wraparound=False, cdivision=True
+
+def info():
+    return "yes"