pymoo 0.6.1.3__cp39-cp39-macosx_11_0_arm64.whl → 0.6.1.5.dev0__cp39-cp39-macosx_11_0_arm64.whl

pymoo/algorithms/soo/nonconvex/es.py

@@ -1,4 +1,5 @@
 import numpy as np
+import math
 
 from pymoo.algorithms.base.genetic import GeneticAlgorithm
 from pymoo.algorithms.soo.nonconvex.ga import FitnessSurvival
@@ -43,9 +44,9 @@ class ES(GeneticAlgorithm):
         """
 
         if pop_size is None and n_offsprings is not None:
-            pop_size = int(np.math.ceil(n_offsprings * rule))
+            pop_size = int(math.ceil(n_offsprings * rule))
         elif n_offsprings is None and pop_size is not None:
-            n_offsprings = int(np.math.floor(pop_size / rule))
+            n_offsprings = int(math.floor(pop_size / rule))
 
         assert pop_size is not None and n_offsprings is not None, "You have to at least provivde pop_size of n_offsprings."
         assert n_offsprings >= 2 * pop_size, "The number of offsprings should be at least double the population size."

pymoo/config.py

@@ -22,7 +22,7 @@ class Config:
     # whether when import a file the doc should be parsed - only activate when creating doc files
     parse_custom_docs = False
 
-    # a method defining the endpoint to load data remotely - default from github repo
+    # a method defining the endpoint to load data remotely - default from GitHub repo
     @classmethod
     def data(cls):
         return f"https://raw.githubusercontent.com/anyoptimization/pymoo-data/main/"

pymoo/core/algorithm.py

@@ -261,7 +261,7 @@ class Algorithm:
             opt = None
 
         # if no feasible solution has been found
-        elif not np.any(opt.get("feasible")):
+        elif not np.any(opt.get("FEAS")):
             if self.return_least_infeasible:
                 opt = filter_optimum(opt, least_infeasible=True)
             else:

pymoo/core/individual.py

@@ -12,6 +12,7 @@ __all__ = [
 ]
 
 import copy
+from typing import Any
 from typing import Optional
 from typing import Tuple
 from typing import Union
@@ -48,7 +49,7 @@ class Individual:
     def __init__(
             self, 
             config: Optional[dict] = None, 
-            **kwargs: dict,
+            **kwargs: Any,
         ) -> None:
         """
         Constructor for the ``Invididual`` class.
@@ -58,7 +59,7 @@ class Individual:
         config : dict, None
             A dictionary of configuration metadata.
             If ``None``, use a class-dependent default configuration.
-        kwargs : dict
+        kwargs : Any
             Additional keyword arguments containing data which is to be stored 
             in the ``Individual``.
         """
@@ -553,14 +554,14 @@ class Individual:
 
     def set_by_dict(
             self, 
-            **kwargs: dict
+            **kwargs: Any
         ) -> None:
         """
         Set an individual's data or metadata using values in a dictionary.
 
         Parameters
         ----------
-        kwargs : dict
+        kwargs : Any
             Keyword arguments defining the data to set.
         """
         for k, v in kwargs.items():
@@ -594,15 +595,15 @@ class Individual:
 
     def get(
             self, 
-            *keys: Tuple[str,...],
+            *keys: str,
         ) -> Union[tuple,object]:
         """
         Get the values for one or more keys for an individual.
 
         Parameters
         ----------
-        keys : tuple
-            A tuple of keys for which to get values.
+        keys : str
+            Keys for which to get values.
 
         Returns
         -------

pymoo/core/replacement.py

@@ -7,12 +7,12 @@ from pymoo.core.survival import Survival
 
 
 def is_better(_new, _old, eps=0.0):
-    both_infeasible = not _old.feasible[0] and not _new.feasible[0]
-    both_feasible = _old.feasible[0] and _new.feasible[0]
+    both_infeasible = not _old.feas and not _new.feas
+    both_feasible = _old.feas and _new.feas
 
     if both_infeasible and _old.CV[0] - _new.CV[0] > eps:
         return True
-    elif not _old.feasible and _new.feasible:
+    elif not _old.FEAS and _new.FEAS:
         return True
     elif both_feasible and _old.F[0] - _new.F[0] > eps:
         return True
@@ -59,8 +59,8 @@ class ImprovementReplacement(ReplacementSurvival):
 
         ret = np.full((len(pop), 1), False)
 
-        pop_F, pop_CV, pop_feas = pop.get("F", "CV", "feasible")
-        off_F, off_CV, off_feas = off.get("F", "CV", "feasible")
+        pop_F, pop_CV, pop_feas = pop.get("F", "CV", "FEAS")
+        off_F, off_CV, off_feas = off.get("F", "CV", "FEAS")
 
         if problem.has_constraints() > 0:
 

pymoo/core/survival.py

@@ -86,7 +86,7 @@ class ToReplacement(Survival):
 
 
 def split_by_feasibility(pop, sort_infeas_by_cv=True, sort_feas_by_obj=False, return_pop=False):
-    F, CV, b = pop.get("F", "CV", "feasible")
+    F, CV, b = pop.get("F", "CV", "FEAS")
 
     feasible = np.where(b)[0]
     infeasible = np.where(~b)[0]

pymoo/core/variable.py

@@ -13,7 +13,7 @@ __all__ = [
     "get",
 ]
 
-from typing import Optional, Tuple
+from typing import Any, Optional, Tuple
 from typing import Union
 import numpy as np
 from numpy.typing import ArrayLike
@@ -111,14 +111,14 @@ class Variable(object):
 
     def get(
             self, 
-            **kwargs: dict
+            **kwargs: Any
         ) -> object:
         """
         Get the value of a decision variable.
 
         Parameters
         ----------
-        kwargs : dict
+        kwargs : Any
             Additional keyword arguments.
         
         Returns
@@ -139,7 +139,7 @@ class BoundedVariable(Variable):
             value: Optional[object] = None, 
             bounds: Tuple[Optional[object],Optional[object]] = (None, None), 
             strict: Optional[Tuple[Optional[object],Optional[object]]] = None, 
-            **kwargs: dict,
+            **kwargs: Any,
         ) -> None:
         """
         Constructor for the ``BoundedVariable`` class.
@@ -154,7 +154,7 @@ class BoundedVariable(Variable):
         strict : tuple, None
             Strict boundaries for the decision variable.
             If ``None``, the value of ``bounds`` is copied to ``strict``.
-        kwargs : dict
+        kwargs : Any
             Additional keyword arguments for ``active`` and ``flag``.
         """
         # call the Variable constructor 
@@ -302,7 +302,7 @@ class Choice(Variable):
             value: Optional[object] = None, 
             options: Optional[ArrayLike] = None, 
             all: Optional[ArrayLike] = None, 
-            **kwargs: dict,
+            **kwargs: Any,
         ) -> None:
         """
         Constructor for the ``Choice`` class.
@@ -316,7 +316,7 @@ class Choice(Variable):
         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
+        kwargs : Any
             Additional keyword arguments for ``active`` and ``flag``.
         """
         # all super constructor
@@ -357,7 +357,7 @@ class Choice(Variable):
 def get(
         *args: Tuple[Union[Variable,object],...], 
         size: Optional[Union[tuple,int]] = None, 
-        **kwargs: dict
+        **kwargs: Any
     ) -> Union[tuple,object,None]:
     """
     Get decision variable values from a tuple of ``Variable`` objects.
@@ -368,7 +368,7 @@ def get(
         A tuple of ``Variable`` or ``object``s.
     size : tuple, int, None
         Size to reshape decision variables.
-    kwargs : dict
+    kwargs : Any
         Additional keyword arguments to pass to the ``get`` method of the 
         ``Variable`` class when getting decision variable values.
     

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"