pymoo 0.6.1.2__tar.gz → 0.6.1.5.dev0__tar.gz

pymoo-0.6.1.5.dev0/MANIFEST.in

@@ -0,0 +1,6 @@
+exclude tests/*
+exclude pymoo/cython/*.cpp
+include pymoo/cython/*.pyx 
+include pymoo/cython/*.pxd
+include pymoo/cython/vendor/*.h
+include Makefile

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/Makefile

@@ -1,21 +1,23 @@
+.PHONY: clean
 clean:
 	rm -rf build dist pymoo.egg-info
 
+.PHONY: clean-ext
 clean-ext:
 	rm -f pymoo/cython/*.c
 	rm -f pymoo/cython/*.so
 	rm -f pymoo/cython/*.cpp
 	rm -f pymoo/cython/*.html
 
+.PHONY: compile
 compile:
 	python setup.py build_ext --inplace
 
-compile-without-cython:
-	python setup.py build_ext --inplace --no-cython
-
+.PHONY: dist
 dist:
 	python setup.py sdist
 
+.PHONY: install
 install:
 	python setup.py install
 

{pymoo-0.6.1.2/pymoo.egg-info → pymoo-0.6.1.5.dev0}/PKG-INFO

@@ -1,29 +1,36 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pymoo
-Version: 0.6.1.2
+Version: 0.6.1.5.dev0
 Summary: Multi-Objective Optimization in Python
-Home-page: https://pymoo.org
-Author: Julian Blank
-Author-email: blankjul@msu.edu
-License: Apache License 2.0
+Author-email: Julian Blank <blankjul@outlook.com>
+License-Expression: Apache-2.0
+Project-URL: homepage, https://pymoo.org
 Keywords: optimization
-Platform: any
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 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.19.3
+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
+Dynamic: license-file
 
 
 

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/pymoo/algorithms/moo/age.py

@@ -167,7 +167,13 @@ 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])
+        # Replace very small norms with 1 to prevent division by zero
+        nn[nn < 1e-8] = 1
+
+        distances = self.pairwise_distances(front, p)
+        distances[distances < 1e-8] = 1e-8  # Replace very small entries to prevent division by zero
+
+        distances = distances / (nn[:, None])
 
         neighbors = 2
         remaining = np.arange(m)
@@ -209,7 +215,7 @@ class AGEMOEASurvival(Survival):
         return p
 
     @staticmethod
-    @jit(fastmath=True)
+    #@jit(nopython=True, fastmath=True)
     def pairwise_distances(front, p):
         m = np.shape(front)[0]
         distances = np.zeros((m, m))
@@ -219,14 +225,14 @@ class AGEMOEASurvival(Survival):
         return distances
 
     @staticmethod
-    @jit(fastmath=True)
+    @jit(nopython=True, fastmath=True)
     def minkowski_distances(A, B, p):
         m1 = np.shape(A)[0]
         m2 = np.shape(B)[0]
         distances = np.zeros((m1, m2))
         for i in range(m1):
             for j in range(m2):
-                distances[i][j] = sum(np.abs(A[i] - B[j]) ** p) ** (1 / p)
+                distances[i][j] = np.sum(np.abs(A[i] - B[j]) ** p) ** (1 / p)
 
         return distances
 
@@ -254,15 +260,15 @@ def find_corner_solutions(front):
     return indexes
 
 
-@jit(fastmath=True)
+@jit(nopython=True, fastmath=True)
 def point_2_line_distance(P, A, B):
-    d = np.zeros(P.shape[0])
+    d = np.zeros(P.shape[0], dtype=numba.float64)
 
     for i in range(P.shape[0]):
         pa = P[i] - A
         ba = B - A
         t = np.dot(pa, ba) / np.dot(ba, ba)
-        d[i] = sum((pa - t * ba) ** 2)
+        d[i] = np.sum((pa - t * ba) ** 2)
 
     return d
 

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/pymoo/algorithms/moo/age2.py

@@ -64,48 +64,78 @@ class AGEMOEA2(GeneticAlgorithm):
         self.tournament_type = 'comp_by_rank_and_crowding'
 
 
-@jit(fastmath=True)
+@jit(nopython=True, fastmath=True)
 def project_on_manifold(point, p):
-    dist = sum(point[point > 0] ** p) ** (1/p)
+    dist = np.sum(point[point > 0] ** p) ** (1/p)
     return np.multiply(point, 1 / dist)
 
 
+import numpy as np
+
+
 def find_zero(point, n, precision):
     x = 1
-
+    epsilon = 1e-10  # Small constant for regularization
     past_value = x
+    max_float = np.finfo(np.float64).max  # Maximum representable float value
+    log_max_float = np.log(max_float)  # Logarithm of the maximum float
+
     for i in range(0, 100):
 
-        # Original function
+        # Original function with regularization
         f = 0.0
         for obj_index in range(0, n):
             if point[obj_index] > 0:
-                f += np.power(point[obj_index], x)
+                log_value = x * np.log(point[obj_index] + epsilon)
+                if log_value < log_max_float:
+                    f += np.exp(log_value)
+                else:
+                    return 1  # Handle overflow by returning a fallback value
 
-        f = np.log(f)
+        f = np.log(f) if f > 0 else 0  # Avoid log of non-positive numbers
 
-        # Derivative
+        # Derivative with regularization
         numerator = 0
         denominator = 0
         for obj_index in range(0, n):
             if point[obj_index] > 0:
-                numerator = numerator + np.power(point[obj_index], x) * np.log(point[obj_index])
-                denominator = denominator + np.power(point[obj_index], x)
-
-        if denominator == 0:
-            return 1
+                log_value = x * np.log(point[obj_index] + epsilon)
+                if log_value < log_max_float:
+                    power_value = np.exp(log_value)
+                    log_term = np.log(point[obj_index] + epsilon)
+
+                    # Use logarithmic comparison to avoid overflow
+                    if log_value + np.log(abs(log_term) + epsilon) < log_max_float:
+                        result = power_value * log_term
+                        numerator += result
+                        denominator += power_value
+                    else:
+                        # Handle extreme cases by capping the result
+                        numerator += max_float
+                        denominator += power_value
+                else:
+                    return 1  # Handle overflow by returning a fallback value
+
+        if denominator == 0 or np.isnan(denominator) or np.isinf(denominator):
+            return 1  # Handle division by zero or NaN
+
+        if np.isnan(numerator) or np.isinf(numerator):
+            return 1  # Handle invalid numerator
 
         ff = numerator / denominator
 
-        # zero of function
+        if ff == 0:  # Check for zero before division
+            return 1  # Handle by returning a fallback value
+
+        # Update x using Newton's method
         x = x - f / ff
 
         if abs(x - past_value) <= precision:
             break
         else:
-            paste_value = x  # update current point
+            past_value = x  # Update current point
 
-    if isinstance(x, complex):
+    if isinstance(x, complex) or np.isinf(x) or np.isnan(x):
         return 1
     else:
         return x
@@ -135,7 +165,7 @@ class AGEMOEA2Survival(AGEMOEASurvival):
         return p
 
     @staticmethod
-    @jit(fastmath=True)
+    @jit(nopython=True, fastmath=True)
     def pairwise_distances(front, p):
         m, n = front.shape
         projected_front = front.copy()
@@ -148,7 +178,7 @@ class AGEMOEA2Survival(AGEMOEASurvival):
         if 0.95 < p < 1.05:
             for row in range(0, m - 1):
                 for column in range(row + 1, m):
-                    distances[row][column] = sum(np.abs(projected_front[row] - projected_front[column]) ** 2) ** 0.5
+                    distances[row][column] = np.sum(np.abs(projected_front[row] - projected_front[column]) ** 2) ** 0.5
 
         else:
             for row in range(0, m-1):
@@ -156,8 +186,8 @@ class AGEMOEA2Survival(AGEMOEASurvival):
                     mid_point = projected_front[row] * 0.5 + projected_front[column] * 0.5
                     mid_point = project_on_manifold(mid_point, p)
 
-                    distances[row][column] = sum(np.abs(projected_front[row] - mid_point) ** 2) ** 0.5 + \
-                                            sum(np.abs(projected_front[column] - mid_point) ** 2) ** 0.5
+                    distances[row][column] = np.sum(np.abs(projected_front[row] - mid_point) ** 2) ** 0.5 + \
+                                            np.sum(np.abs(projected_front[column] - mid_point) ** 2) ** 0.5
 
         return distances + distances.T
 

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/pymoo/algorithms/moo/ctaea.py

@@ -14,7 +14,7 @@ from pymoo.operators.selection.tournament import TournamentSelection
 from pymoo.util.display.multi import MultiObjectiveOutput
 from pymoo.util.dominator import Dominator
 from pymoo.util.function_loader import load_function
-from pymoo.util.misc import has_feasible, random_permuations
+from pymoo.util.misc import has_feasible, random_permutations
 from pymoo.util.nds.non_dominated_sorting import NonDominatedSorting
 
 
@@ -63,7 +63,7 @@ class RestrictedMating(TournamentSelection):
         n_random = n_select * n_parents * self.pressure
         n_perms = math.ceil(n_random / n_pop)
         # get random permutations and reshape them
-        P = random_permuations(n_perms, n_pop)[:n_random]
+        P = random_permutations(n_perms, n_pop)[:n_random]
         P = np.reshape(P, (n_select * n_parents, self.pressure))
         if Pc <= Pd:
             # Choose from DA

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/pymoo/algorithms/moo/kgb.py

@@ -24,13 +24,13 @@ class KGB(NSGA2):
         c_size=13,
         eps=0.0,
         ps={},
-        pertub_dev=0.1,
+        perturb_dev=0.1,
         save_ps=False,
         **kwargs,
     ):
 
         super().__init__(**kwargs)
-        self.PERTUB_DEV = pertub_dev
+        self.PERTURB_DEV = perturb_dev
         self.PERC_DIVERSITY = perc_diversity
         self.PERC_DETECT_CHANGE = perc_detect_change
         self.EPS = eps
@@ -258,11 +258,11 @@ class KGB(NSGA2):
         :param pop: Population to check and fix boundaries
         :return: Population with corrected boundaries
         """
-        # check wether numpy array or pymoo population is given
+        # check whether numpy array or pymoo population is given
         if isinstance(pop, Population):
             pop = pop.get("X")
 
-        # check if any solution is outside of the bounds
+        # check if any solution is outside the bounds
         for individual in pop:
             for i in range(len(individual)):
                 if individual[i] > self.problem.xu[i]:
@@ -281,7 +281,7 @@ class KGB(NSGA2):
         # TODO: Check boundaries
         random_pop = np.random.random((N_r, self.problem.n_var))
 
-        # check if any solution is outside of the bounds
+        # check if any solution is outside the bounds
         for individual in random_pop:
             for i in range(len(individual)):
                 if individual[i] > self.problem.xu[i]:
@@ -341,16 +341,16 @@ class KGB(NSGA2):
             X_test = self.random_strategy(self.nr_rand_solutions)
 
             # introduce noise to vary previously useful solutions
-            noise = np.random.normal(0, self.PERTUB_DEV, self.problem.n_var)
+            noise = np.random.normal(0, self.PERTURB_DEV, self.problem.n_var)
             noisy_useful_history = np.asarray(pop_useful) + noise
 
-            # check wether solutions are within bounds
+            # check whether solutions are within bounds
             noisy_useful_history = self.check_boundaries(noisy_useful_history)
 
             # add noisy useful history to randomly generated solutions
             X_test = np.vstack((X_test, noisy_useful_history))
 
-            # predict wether random solutions are useful or useless
+            # predict whether random solutions are useful or useless
             Y_test = model.predict(X_test)
 
             # create list of useful predicted solutions
@@ -391,7 +391,7 @@ class KGB(NSGA2):
             # if there are still not enough solutions in init_pop randomly sample previously useful solutions directly without noise to init_pop
             if len(init_pop) < self.pop_size:
 
-                # fill up init_pop with randomly sampled solutions from pop_usefull
+                # fill up init_pop with randomly sampled solutions from pop_useful
                 if len(pop_useful) >= self.pop_size - len(init_pop):
 
                     nr_sampled_pop_useful = self.pop_size - len(init_pop)

{pymoo-0.6.1.2 → pymoo-0.6.1.5.dev0}/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.2 → pymoo-0.6.1.5.dev0}/pymoo/algorithms/moo/nsga3.py

@@ -212,7 +212,7 @@ def niching(pop, n_remaining, niche_count, niche_of_individuals, dist_to_niche):
         # the minimum niche count
         min_niche_count = next_niche_count.min()
 
-        # all niches with the minimum niche count (truncate if randomly if more niches than remaining individuals)
+        # all niches with the minimum niche count (truncate randomly if there are more niches than remaining individuals)
         next_niches = next_niches_list[np.where(next_niche_count == min_niche_count)[0]]
         next_niches = next_niches[np.random.permutation(len(next_niches))[:n_select]]
 
@@ -303,7 +303,7 @@ def get_extreme_points_c(F, ideal_point, extreme_points=None):
     weights = np.eye(F.shape[1])
     weights[weights == 0] = 1e6
 
-    # add the old extreme points to never loose them for normalization
+    # add the old extreme points to never lose them for normalization
     _F = F
     if extreme_points is not None:
         _F = np.concatenate([extreme_points, _F], axis=0)