pymoo 0.6.1.2__cp311-cp311-win_amd64.whl → 0.6.1.5.dev0__cp311-cp311-win_amd64.whl

pymoo/docs.py

@@ -87,7 +87,7 @@ algorithms = {
 
 visualization = {
     "figsize": """tuple
-                The figure size. Default (figsize=(8, 6)). For some plots changing the size might have side-effects for position.
+                The figure size. Default (figsize=(8, 6)). For some plots changing the size might have side effects for position.
                 """,
 
     "title": """str or tuple

pymoo/gradient/grad_autograd.py

@@ -3,7 +3,6 @@ import numpy as np
 
 try:
     import autograd.numpy as anp
-    from autograd import value_and_grad
     from autograd.core import VJPNode, backward_pass
     from autograd.tracer import new_box, isbox
 except:
@@ -11,7 +10,8 @@ except:
 
 
 def value_and_grad(*args, **kwargs):
-    return value_and_grad(*args, **kwargs)
+    from autograd import value_and_grad as vag
+    return vag(*args, **kwargs)
 
 
 def log(*args, **kwargs):

pymoo/operators/crossover/ox.py

@@ -36,7 +36,7 @@ def ox(receiver, donor, seq=None, shift=False):
     assert len(donor) == len(receiver)
 
     # the sequence which shall be use for the crossover
-    seq = seq if not None else random_sequence(len(receiver))
+    seq = seq if seq is not None else random_sequence(len(receiver))
     start, end = seq
 
     # the donation and a set of it to allow a quick lookup

pymoo/operators/selection/rnd.py

@@ -3,7 +3,7 @@ import math
 import numpy as np
 
 from pymoo.core.selection import Selection
-from pymoo.util.misc import random_permuations
+from pymoo.util.misc import random_permutations
 
 
 class RandomSelection(Selection):
@@ -16,7 +16,7 @@ class RandomSelection(Selection):
         n_perms = math.ceil(n_random / len(pop))
 
         # get random permutations and reshape them
-        P = random_permuations(n_perms, len(pop))[:n_random]
+        P = random_permutations(n_perms, len(pop))[:n_random]
 
         return np.reshape(P, (n_select, n_parents))
 

pymoo/operators/selection/tournament.py

@@ -3,12 +3,12 @@ import math
 import numpy as np
 
 from pymoo.core.selection import Selection
-from pymoo.util.misc import random_permuations
+from pymoo.util.misc import random_permutations
 
 
 class TournamentSelection(Selection):
     """
-      The Tournament selection is used to simulated a tournament between individuals. The pressure balances
+      The Tournament selection is used to simulate a tournament between individuals. The pressure balances
       greedy the genetic algorithm will be.
     """
 
@@ -19,10 +19,10 @@ class TournamentSelection(Selection):
         ----------
         func_comp: func
             The function to compare two individuals. It has the shape: comp(pop, indices) and returns the winner.
-            If the function is None it is assumed the population is sorted by a criterium and only indices are compared.
+            If the function is None it is assumed the population is sorted by a criterion and only indices are compared.
 
         pressure: int
-            The selection pressure to bie applied. Default it is a binary tournament.
+            The selection pressure to be applied. Default it is a binary tournament.
         """
 
         super().__init__(**kwargs)
@@ -42,7 +42,7 @@ class TournamentSelection(Selection):
         n_perms = math.ceil(n_random / len(pop))
 
         # get random permutations and reshape them
-        P = random_permuations(n_perms, len(pop))[:n_random]
+        P = random_permutations(n_perms, len(pop))[:n_random]
         P = np.reshape(P, (n_select * n_parents, self.pressure))
 
         # compare using tournament function

pymoo/optimize.py

@@ -8,7 +8,7 @@ def minimize(problem, algorithm, termination=None, copy_algorithm=True, copy_ter
 
     This is used as a convenience function to execute several algorithms with default settings which turned
     out to work for a test single. However, evolutionary computations utilizes the idea of customizing a
-    meta-algorithm. Customizing the algorithm using the object oriented interface is recommended to improve the
+    meta-algorithm. Customizing the algorithm using the object-oriented interface is recommended to improve the
     convergence.
 
     Parameters
@@ -48,7 +48,7 @@ def minimize(problem, algorithm, termination=None, copy_algorithm=True, copy_ter
 
     """
 
-    # create a copy of the algorithm object to ensure no side-effects
+    # create a copy of the algorithm object to ensure no side effects
     if copy_algorithm:
         algorithm = copy.deepcopy(algorithm)
 

pymoo/problems/dynamic/df.py

@@ -318,10 +318,10 @@ class DF11(DF):
         y1 = np.pi * G / 6 + (np.pi / 2 - np.pi * G / 3) * x1
         y2 = np.pi * G / 6 + (np.pi / 2 - np.pi * G / 3) * x2
 
-        f1 = np.sin(y1)
-        f2 = np.dot(np.multiply(1, np.sin(y2)), np.cos(y1))
-        f3 = np.dot(np.multiply(1, np.cos(y2)), np.cos(y1))
-
+        f1 = (1 + G) * np.sin(y1)
+        f2 = (1 + G) * np.sin(y2) * np.cos(y1)  # Correct element-wise multiplication
+        f3 = (1 + G) * np.cos(y2) * np.cos(y1)  # Correct element-wise multiplication
+        
         return get_PF(np.array([f1, f2, f3]), False)
 
 

pymoo/problems/single/traveling_salesman.py

@@ -14,7 +14,7 @@ class TravelingSalesman(ElementwiseProblem):
         Parameters
         ----------
         cities : numpy.array
-            The cities with 2-dimensional coordinates provided by a matrix where where city is represented by a row.
+            The cities with 2-dimensional coordinates provided by a matrix where city is represented by a row.
 
         """
         n_cities, _ = cities.shape

pymoo/util/misc.py

@@ -58,7 +58,7 @@ def parameter_less_constraints(F, CV, F_max=None):
     return F
 
 
-def random_permuations(n, l, concat=True):
+def random_permutations(n, l, concat=True):
     P = []
     for i in range(n):
         P.append(np.random.permutation(l))
@@ -360,7 +360,7 @@ def intersect(a, b):
 
 
 def has_feasible(pop):
-    return np.any(pop.get("feasible"))
+    return np.any(pop.get("FEAS"))
 
 
 def to_numpy(a):

pymoo/util/mnn.py

@@ -40,7 +40,7 @@ def calc_mnn_base(X, n_remove=0, twonn=False):
     
     D = squareform(pdist(X, metric="sqeuclidean"))
     Dnn = np.partition(D, range(1, M+1), axis=1)[:, 1:M+1]
-    d = np.product(Dnn, axis=1)
+    d = np.prod(Dnn, axis=1)
     d[extremes] = np.inf
     
     n_removed = 0
@@ -63,7 +63,7 @@ def calc_mnn_base(X, n_remove=0, twonn=False):
 
             D[:, k] = np.inf
             Dnn[H] = np.partition(D[H], range(1, M+1), axis=1)[:, 1:M+1]
-            d[H] = np.product(Dnn[H], axis=1)
+            d[H] = np.prod(Dnn[H], axis=1)
             d[extremes] = np.inf
     
     return d

pymoo/util/nds/fast_non_dominated_sort.py

@@ -3,8 +3,11 @@ import numpy as np
 from pymoo.util.dominator import Dominator
 
 
-def fast_non_dominated_sort(F, **kwargs):
-    M = Dominator.calc_domination_matrix(F)
+def fast_non_dominated_sort(F, dominator=Dominator(), **kwargs):
+    if "dominator" in kwargs:
+        M = Dominator.calc_domination_matrix(F)
+    else:
+        M = dominator.calc_domination_matrix(F)
 
     # calculate the dominance matrix
     n = M.shape[0]
@@ -65,4 +68,3 @@ def fast_non_dominated_sort(F, **kwargs):
         current_front = next_front
 
     return fronts
-

pymoo/util/nds/non_dominated_sorting.py

@@ -1,5 +1,5 @@
 import numpy as np
-
+import sys
 from pymoo.util.dominator import Dominator
 from pymoo.util.function_loader import load_function
 
@@ -53,7 +53,7 @@ class NonDominatedSorting:
 
 def rank_from_fronts(fronts, n):
     # create the rank array and set values
-    rank = np.full(n, 1e16, dtype=int)
+    rank = np.full(n, sys.maxsize, dtype=int)
     for i, front in enumerate(fronts):
         rank[front] = i
 

pymoo/util/normalization.py

@@ -66,7 +66,7 @@ class ZeroToOneNormalization(Normalization):
         # now create all the masks that are necessary
         self.xl_only, self.xu_only = np.logical_and(~xl_nan, xu_nan), np.logical_and(xl_nan, ~xu_nan)
         self.both_nan = np.logical_and(np.isnan(xl), np.isnan(xu))
-        self.neither_nan = ~self.both_nan
+        self.neither_nan = np.logical_and(~np.isnan(xl), ~np.isnan(xu))
 
         # if neither is nan than xu must be greater or equal than xl
         any_nan = np.logical_or(np.isnan(xl), np.isnan(xu))
@@ -76,18 +76,15 @@ class ZeroToOneNormalization(Normalization):
         if X is None or (self.xl is None and self.xu is None):
             return X
 
-        xl, xu, xl_only, xu_only = self.xl, self.xu, self.xl_only, self.xu_only
-        both_nan, neither_nan = self.both_nan, self.neither_nan
-
         # simple copy the input
         N = np.copy(X)
 
         # normalize between zero and one if neither of them is nan
-        N[..., neither_nan] = (X[..., neither_nan] - xl[neither_nan]) / (xu[neither_nan] - xl[neither_nan])
+        N[...,  self.neither_nan] = (X[...,  self.neither_nan] - self.xl[self.neither_nan]) / (self.xu[self.neither_nan] - self.xl[self.neither_nan])
 
-        N[..., xl_only] = X[..., xl_only] - xl[xl_only]
+        N[..., self.xl_only] = X[..., self.xl_only] - self.xl[self.xl_only]
 
-        N[..., xu_only] = 1.0 - (xu[xu_only] - X[..., xu_only])
+        N[..., self.xu_only] = 1.0 - (self.xu[self.xu_only] - X[..., self.xu_only])
 
         return N
 
@@ -305,7 +302,7 @@ class ObjectiveSpaceNormalization:
         self._worst = None
 
     def update(self, pop):
-        F, feas = pop.get("F", "feasible")
+        F, feas = pop.get("F", "FEAS")
         self._infeas_ideal = find_ideal(F, current=self._infeas_ideal)
 
         if np.any(feas):

pymoo/util/ref_dirs/energy.py

@@ -156,12 +156,14 @@ class RieszEnergyReferenceDirectionFactory(ReferenceDirectionFactory):
                 X = ReductionBasedReferenceDirectionFactory(self.n_dim,
                                                             self.n_points,
                                                             kmeans=True,
-                                                            lexsort=False) \
+                                                            lexsort=False,
+                                                            seed=self.seed) \
                     .do()
 
             elif self.sampling == "construction":
                 X = ConstructionBasedReferenceDirectionFactory(self.n_dim,
-                                                               self.n_points) \
+                                                               self.n_points,
+                                                               seed=self.seed) \
                     .do()
             else:
                 raise Exception("Unknown sampling method. Either reduction or construction.")

pymoo/util/ref_dirs/reduction.py

@@ -62,7 +62,7 @@ class ReductionBasedReferenceDirectionFactory(ReferenceDirectionFactory):
         self.n_points = n_points
 
     def _do(self):
-        rnd = sample_on_unit_simplex(self.n_sample_points, self.n_dim, unit_simplex_mapping=self.sampling)
+        rnd = sample_on_unit_simplex(self.n_sample_points, self.n_dim, seed=self.seed, unit_simplex_mapping=self.sampling)
 
         def h(n):
             return get_partition_closest_to_points(n, self.n_dim)

pymoo/util/reference_direction.py

@@ -174,12 +174,13 @@ class MultiLayerReferenceDirectionFactory:
 # Util
 # =========================================================================================================
 
-def get_rng(seed = None):
+def get_rng(seed=None):
     if seed is None or type(seed) == int:
         rng = np.random.default_rng(seed)
     return rng
 
-def sample_on_unit_simplex(n_points, n_dim, unit_simplex_mapping="kraemer", seed = None):
+
+def sample_on_unit_simplex(n_points, n_dim, unit_simplex_mapping="kraemer", seed=None):
     if unit_simplex_mapping == "sum":
         rnd = map_onto_unit_simplex(get_rng(seed).random((n_points, n_dim)), "sum")