pymoo 0.6.1.1__tar.gz → 0.6.1.3__tar.gz

pymoo-0.6.1.3/MANIFEST.in

@@ -0,0 +1,4 @@
+prune .
+recursive-include pymoo *.py *.pyx *.pxd
+recursive-include pymoo/cython/vendor *.cpp *.h *.py
+include LICENSE Makefile pyproject.toml

{pymoo-0.6.1.1/pymoo.egg-info → pymoo-0.6.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymoo
-Version: 0.6.1.1
+Version: 0.6.1.3
 Summary: Multi-Objective Optimization in Python
 Home-page: https://pymoo.org
 Author: Julian Blank
@@ -14,17 +14,24 @@ Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Scientific/Engineering :: Mathematics
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: numpy>=1.15
+Requires-Dist: scipy>=1.1
+Requires-Dist: matplotlib>=3
+Requires-Dist: autograd>=1.4
+Requires-Dist: cma==3.2.2
+Requires-Dist: alive-progress
+Requires-Dist: dill
+Requires-Dist: Deprecated
 
 
 

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/moo/age.py

@@ -167,7 +167,7 @@ class AGEMOEASurvival(Survival):
         p = self.compute_geometry(front, extreme, n)
 
         nn = np.linalg.norm(front, p, axis=1)
-        distances = self.pairwise_distances(front, p) / nn[:, None]
+        distances = self.pairwise_distances(front, p) / (nn[:, None])
 
         neighbors = 2
         remaining = np.arange(m)
@@ -284,7 +284,7 @@ def normalize(front, extreme):
 
     try:
         hyperplane = np.linalg.solve(front[extreme], np.ones(n))
-        if any(np.isnan(hyperplane)) or any(np.isinf(hyperplane)) or any(hyperplane < 0):
+        if any(np.isnan(hyperplane)) or any(np.isinf(hyperplane)) or any(hyperplane <= 0):
             normalization = np.max(front, axis=0)
         else:
             normalization = 1. / hyperplane
@@ -300,4 +300,5 @@ def normalize(front, extreme):
 
     return front, normalization
 
+
 parse_doc_string(AGEMOEA.__init__)

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/moo/nsga2.py

@@ -70,10 +70,6 @@ def binary_tournament(pop, P, algorithm, **kwargs):
 class RankAndCrowdingSurvival(RankAndCrowding):
     
     def __init__(self, nds=None, crowding_func="cd"):
-        warnings.warn(
-                "RankAndCrowdingSurvival is deprecated and will be removed in version 0.8.*; use RankAndCrowding operator instead, which supports several and custom crowding diversity metrics.",
-                DeprecationWarning, 2
-            )
         super().__init__(nds, crowding_func)
 
 # =========================================================================================================

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/moo/nsga3.py

@@ -278,7 +278,6 @@ class HyperplaneNormalization:
         self.extreme_points = None
 
     def update(self, F, nds=None):
-
         # find or usually update the new ideal point - from feasible solutions
         self.ideal_point = np.min(np.vstack((self.ideal_point, F)), axis=0)
         self.worst_point = np.max(np.vstack((self.worst_point, F)), axis=0)
@@ -296,7 +295,7 @@ class HyperplaneNormalization:
         worst_of_front = np.max(F[nds, :], axis=0)
 
         self.nadir_point = get_nadir_point(self.extreme_points, self.ideal_point, self.worst_point,
-                                           worst_of_population, worst_of_front)
+                                           worst_of_front, worst_of_population)
 
 
 def get_extreme_points_c(F, ideal_point, extreme_points=None):

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/moo/sms.py

@@ -184,6 +184,9 @@ class SMSEMOA(GeneticAlgorithm):
         # merge the offsprings with the current population
         if infills is not None:
             pop = Population.merge(self.pop, infills)
+        else:
+            pop = self.pop
+
 
         self.pop = self.survival.do(self.problem, pop, n_survive=self.pop_size, algorithm=self,
                                     ideal=ideal, nadir=nadir, **kwargs)

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/soo/nonconvex/cmaes.py

@@ -402,7 +402,7 @@ class CMAES(LocalSearch):
             self.norm = NoNormalization()
             self.options['bounds'] = [xl, xu]
 
-        self.options['seed'] = self.seed
+        self.options['seed'] = kwargs.get('seed', self.seed)
 
         if isinstance(self.termination, MaximumGenerationTermination):
             self.options['maxiter'] = self.termination.n_max_gen

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/soo/nonconvex/es.py

@@ -45,7 +45,7 @@ class ES(GeneticAlgorithm):
         if pop_size is None and n_offsprings is not None:
             pop_size = int(np.math.ceil(n_offsprings * rule))
         elif n_offsprings is None and pop_size is not None:
-            n_offsprings = int(np.math.floor(n_offsprings / rule))
+            n_offsprings = int(np.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-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/soo/nonconvex/optuna.py

@@ -1,12 +1,9 @@
-import logging
-
-from optuna.logging import get_logger
-
 from pymoo.util.optimum import filter_optimum
 
 try:
     import optuna
     from optuna.samplers import TPESampler
+    from optuna.logging import get_logger
 except:
     raise Exception("Please install optuna: pip install optuna")
 

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/algorithms/soo/nonconvex/pattern.py

@@ -80,7 +80,7 @@ class PatternSearch(LocalSearch):
     def _next(self):
 
         # whether the last iteration has resulted in a new optimum or not
-        has_improved = is_better(self._explr, self._center, eps=0.0)
+        has_improved = is_better(self._explr, self._center)
 
         # that means that the exploration did not find any new point and was thus unsuccessful
         if not has_improved:

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/constraints/adaptive.py

@@ -40,7 +40,7 @@ class AdaptiveConstraintHandling(Meta, Algorithm):
     def _setup(self, _, **kwargs):
         self.evaluator = AttachConfigEvaluator(self.evaluator, self.config)
 
-    def _adapt(self, config, infills=None, **kwargs):
+    def _adapt_constraint_handling(self, config, infills=None, **kwargs):
         pass
 
     def _initialize_advance(self, infills=None, **kwargs):
@@ -53,7 +53,7 @@ class AdaptiveConstraintHandling(Meta, Algorithm):
         super()._advance(infills=infills, **kwargs)
         copy_to_dict(self.default_config, self.config)
 
-        self._adapt(self.adapted_config, infills=infills, **kwargs)
+        self._adapt_constraint_handling(self.adapted_config, infills=infills, **kwargs)
 
     def _infill(self):
         copy_to_dict(self.adapted_config, self.config)

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/constraints/eps.py

@@ -10,7 +10,7 @@ class AdaptiveEpsilonConstraintHandling(AdaptiveConstraintHandling):
         self.perc_eps_until = perc_eps_until
         self.max_cv = None
 
-    def _adapt(self, config, **kwargs):
+    def _adapt_constraint_handling(self, config, **kwargs):
         t = self.termination.perc
         alpha = np.maximum(0.0, 1 - 1 / self.perc_eps_until * t)
         eps = alpha * self.max_cv

{pymoo-0.6.1.1 → pymoo-0.6.1.3}/pymoo/core/algorithm.py

@@ -253,6 +253,7 @@ class Algorithm:
 
         res.pop = self.pop
         res.archive = self.archive
+        res.data = self.data
 
         # get the optimal solution found
         opt = self.opt