pymoo 0.6.1__cp310-cp310-win_amd64.whl → 0.6.1.2__cp310-cp310-win_amd64.whl

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/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/algorithms/moo/sms.py

@@ -137,7 +137,7 @@ class SMSEMOA(GeneticAlgorithm):
                  pop_size=100,
                  sampling=FloatRandomSampling(),
                  selection=TournamentSelection(func_comp=cv_and_dom_tournament),
-                 crossover=SBX(prob_exch=0.5),
+                 crossover=SBX(),
                  mutation=PM(),
                  survival=LeastHypervolumeContributionSurvival(),
                  eliminate_duplicates=True,
@@ -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/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/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/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/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/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/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/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