pycombinatorial 2.1.4__tar.gz → 2.1.8__tar.gz

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.4
+Version: 2.1.8
 Summary: A library to solve TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics, Metaheuristics and Reinforcement Learning
 Home-page: https://github.com/Valdecy/pyCombinatorial
 Author: Valdecy Pereira
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 **pyCombinatorial** is a Python-based library designed to tackle the classic Travelling Salesman Problem (TSP) through a diverse set of **Exact Algorithms**, **Heuristics**, **Metaheuristics** and **Reinforcement Learning**. It brings together both well-established and cutting-edge methodologies, offering end-users a flexible toolkit to generate high-quality solutions for TSP instances of various sizes and complexities.   
 
-Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
+Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **Randomized Spectral Seriation**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
 
 ## Usage
 
@@ -111,6 +111,7 @@ print('Total Distance: ', round(distance, 2))
 - Nearest Neighbour ([ Colab Demo ](https://colab.research.google.com/drive/1aL1kYXgSjUJYPfYSMy_0SWq4hJ3nrueJ?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0166-218X(01)00195-0))
 - Random Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1RP_grqrTXyDkHOLB_L1H8TkvxdLli5hG?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
 - Random Tour ([ Colab Demo ](https://colab.research.google.com/drive/1DPXMJXInkGKTyVFDAQ2bKXjglhy3DaCS?usp=sharing)) ( [ Paper ](https://doi.org/10.1023/A:1011263204536))
+- Randomized Spectral Seriation ([ Colab Demo ](https://colab.research.google.com/drive/1PTtO6HJfftsFZEScCYZvzpBJsgMyjBCY?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - RL Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1dnZhLAzQdz9kzxKrVcwMECWbyEKkZ7St?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL Double Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1VTv8A6Ac-LvBxsereFyGRfkiLRbJI547?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL S.A.R.S.A ([ Colab Demo ](https://colab.research.google.com/drive/1q9hon3jFf8xVCw4idxhu7goLREKbQ6N3?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
@@ -121,7 +122,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/README.md

@@ -4,7 +4,7 @@
 
 **pyCombinatorial** is a Python-based library designed to tackle the classic Travelling Salesman Problem (TSP) through a diverse set of **Exact Algorithms**, **Heuristics**, **Metaheuristics** and **Reinforcement Learning**. It brings together both well-established and cutting-edge methodologies, offering end-users a flexible toolkit to generate high-quality solutions for TSP instances of various sizes and complexities.   
 
-Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
+Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **Randomized Spectral Seriation**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
 
 ## Usage
 
@@ -100,6 +100,7 @@ print('Total Distance: ', round(distance, 2))
 - Nearest Neighbour ([ Colab Demo ](https://colab.research.google.com/drive/1aL1kYXgSjUJYPfYSMy_0SWq4hJ3nrueJ?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0166-218X(01)00195-0))
 - Random Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1RP_grqrTXyDkHOLB_L1H8TkvxdLli5hG?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
 - Random Tour ([ Colab Demo ](https://colab.research.google.com/drive/1DPXMJXInkGKTyVFDAQ2bKXjglhy3DaCS?usp=sharing)) ( [ Paper ](https://doi.org/10.1023/A:1011263204536))
+- Randomized Spectral Seriation ([ Colab Demo ](https://colab.research.google.com/drive/1PTtO6HJfftsFZEScCYZvzpBJsgMyjBCY?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - RL Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1dnZhLAzQdz9kzxKrVcwMECWbyEKkZ7St?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL Double Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1VTv8A6Ac-LvBxsereFyGRfkiLRbJI547?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL S.A.R.S.A ([ Colab Demo ](https://colab.research.google.com/drive/1q9hon3jFf8xVCw4idxhu7goLREKbQ6N3?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
@@ -110,7 +111,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pyCombinatorial/algorithm/__init__.py

@@ -39,6 +39,7 @@ from .rl_double_ql import double_q_learning
 from .rl_ql        import q_learning
 from .rl_sarsa     import sarsa
 from .rr           import ruin_and_recreate
+from .rss          import randomized_spectral_seriation
 from .rt           import random_tour
 from .s_gui        import guided_search
 from .s_itr        import iterated_search

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pyCombinatorial/algorithm/aco.py

@@ -62,41 +62,52 @@ def update_thau(distance_matrix, thau, city_list):
     return thau
 
 # Function: Generate Ant Paths
-def ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search):
-    best_path_distance = float('inf')
+def ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search, deposit_mode = 'all'):
+    best_path_distance = float("inf")
     best_city_list     = None
+    all_tours          = []
     for _ in range(0, ants):
         city_list = [np.random.choice(full_list)]
-        while (len(city_list) < len(full_list)):
-            current_city  = city_list[-1]
-            probabilities = []
-            for next_city in full_list:
-                if (next_city not in city_list):
-                    p = (thau[current_city-1, next_city-1] ** alpha) * (h[current_city-1, next_city-1] ** beta)
-                    probabilities.append(p)
-                else:
-                    probabilities.append(0)
-            probabilities = np.array(probabilities) / np.sum(probabilities)
-            next_city     = np.random.choice(full_list, p = probabilities)
+        while len(city_list) < len(full_list):
+            current_city = city_list[-1]
+            candidates   = [c for c in full_list if c not in city_list]
+            weights      = []
+            for nxt in candidates:
+                tau = thau[current_city - 1, nxt - 1]
+                eta = h[current_city - 1, nxt - 1]
+                w   = (tau ** alpha) * (eta ** beta)
+                weights.append(w)
+            weights = np.array(weights, dtype = float)
+            s       = weights.sum()
+            if s <= 0 or not np.isfinite(s):
+                next_city = np.random.choice(candidates)
+            else:
+                probs     = weights / s
+                next_city = np.random.choice(candidates, p = probs)
             city_list.append(next_city)
         path_distance = calculate_distance(distance_matrix, city_list)
-        if (path_distance < best_path_distance):
-            best_city_list     = copy.deepcopy(city_list)
+        if path_distance < best_path_distance:
             best_path_distance = path_distance
-            
-    if (local_search == True):
+            best_city_list     = copy.deepcopy(city_list)
+        if deposit_mode == "all":
+            all_tours.append((city_list, path_distance))
+    if local_search:
         best_city_list, best_path_distance = local_search_2_opt(distance_matrix, city_tour = [best_city_list, best_path_distance])
-    thau = update_thau(distance_matrix, thau, city_list = best_city_list)
+    if deposit_mode == "all":
+        for tour, dist in all_tours:
+            thau = update_thau(distance_matrix, thau, city_list = tour)
+    else:
+        thau = update_thau(distance_matrix, thau, city_list = best_city_list)
     return best_city_list, best_path_distance, thau
 
 ############################################################################
 
 # ACO Function
-def ant_colony_optimization(distance_matrix, ants = 5, iterations = 50, alpha = 1, beta = 2, decay = 0.05, local_search = True, verbose = True):
+def ant_colony_optimization(distance_matrix, ants = 15, iterations = 100, alpha = 1, beta = 2, decay = 0.05, local_search = True, verbose = True):
     count      = 0
     best_route = []
     full_list  = list(range(1, distance_matrix.shape[0] + 1))
-    distance   = np.sum(distance_matrix.sum())
+    distance   = float('inf')
     h          = attractiveness(distance_matrix)
     thau       = np.ones((distance_matrix.shape[0], distance_matrix.shape[0]))
     while (count <= iterations):

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pyCombinatorial/algorithm/alns.py

@@ -80,10 +80,12 @@ def local_search_2_opt(distance_matrix, city_tour, recursive_seeding = -1, verbo
 # Function: Removal
 def removal_operators():
     def random_removal(city_tour, num_removals):
-        removed = set()
-        while (len(removed) < num_removals):
-            removed.add(random.choice(city_tour[1:]))
-        return list(removed)
+        available = city_tour[1:]
+        if (len(available) == 0):
+            return []
+        k = int(num_removals)
+        k = max(1, min(k, len(available)))
+        return random.sample(available, k)
     return [random_removal]
 
 # Function: Insertion
@@ -104,7 +106,7 @@ def insertion_operators():
 ############################################################################
 
 # Function: Adaptive Large Neighborhood Search
-def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, removal_fraction = 0.2, rho = 0.1, local_search = True, verbose = True):
+def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, removal_fraction = 0.2, rho = 0.1, local_search = True, verbose = True, sa = True, t0 = None, cooling = 0.995):
     initial_tour       = list(range(0, distance_matrix.shape[0]))
     random.shuffle(initial_tour)
     route              = initial_tour.copy()
@@ -113,20 +115,29 @@ def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, remova
     insertion_ops      = insertion_operators()
     weights_removal    = [1.0] * len(removal_ops)
     weights_insertion  = [1.0] * len(insertion_ops)
+    rho                = max(0.0, min(float(rho), 0.99))
+    temp               = float(distance) if (t0 is None) else float(t0)
+    temp               = max(temp, 1e-12)
     count              = 0
-    while (count <= iterations):
+    while (count < iterations):
         if (verbose == True and count > 0):
             print('Iteration = ', count, 'Distance = ', round(distance, 2))     
         city_tour     = route.copy()
         removal_op    = random.choices(removal_ops,   weights = weights_removal)[0]
         insertion_op  = random.choices(insertion_ops, weights = weights_insertion)[0]
         num_removals  = int(removal_fraction * distance_matrix.shape[0])
+        num_removals  = max(1, num_removals)
+        num_removals  = min(num_removals, max(1, len(city_tour) - 1))
         removed_nodes = removal_op(city_tour, num_removals)
         for node in removed_nodes:
             city_tour.remove(node)
         new_tour          = insertion_op(removed_nodes, city_tour, distance_matrix)
         new_tour_distance = distance_point(distance_matrix, new_tour)
-        if (new_tour_distance < distance):
+        delta  = new_tour_distance - distance
+        accept = (delta < 0)
+        if (sa == True and accept == False):
+            accept = (random.random() < np.exp(-delta / temp))
+        if (accept == True):
             route                                                = new_tour
             distance                                             = new_tour_distance
             weights_removal[removal_ops.index(removal_op)]       = weights_removal[removal_ops.index(removal_op)]       * (1 + rho)
@@ -138,6 +149,8 @@ def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, remova
         total_weight_insertion = sum(weights_insertion)
         weights_removal        = [w / total_weight_removal   for w in weights_removal]
         weights_insertion      = [w / total_weight_insertion for w in weights_insertion]
+        if (sa == True):
+            temp = max(temp * cooling, 1e-12)
         count                  = count + 1
     route = route + [route[0]]
     route = [item + 1 for item in route]

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pyCombinatorial/algorithm/opt_4.py

@@ -145,7 +145,7 @@ def local_search_4_opt(distance_matrix, city_tour, recursive_seeding = -1, verbo
                            [a + c + b + d],
                            [a + c + d + b],
                            
-                         ]   
+                         ]  
             for item in trial:   
                 best_route_1[0] = item[0]
                 best_route_1[1] = distance_calc(distance_matrix, [best_route_1[0] + [best_route_1[0][0]], 1])

pycombinatorial-2.1.8/pyCombinatorial/algorithm/rss.py

@@ -0,0 +1,246 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: pyCombinatorial - RSS (Randomized Spectral Seriation)
+ 
+# GitHub Repository: <https://github.com/Valdecy> 
+
+############################################################################
+
+# Required Libraries
+import numpy as np
+
+from numba import njit
+from scipy.sparse import coo_matrix, diags
+from scipy.sparse.linalg import eigsh, ArpackNoConvergence
+
+############################################################################
+
+# Numba Functions
+@njit(fastmath = True, cache = True)
+def tour_length(tour, D):
+    n = len(tour)
+    L = 0.0
+    for i in range(n - 1):
+        L = L + D[tour[i], tour[i + 1]]
+    L = L +  D[tour[n - 1], tour[0]]
+    return L
+
+@njit(fastmath = True, cache = True)
+def _reverse_segment_inplace(tour, pos, p1, p2, n):
+    if p1 <= p2:
+        while p1 < p2:
+            tmp           = tour[p1]
+            tour[p1]      = tour[p2]
+            tour[p2]      = tmp
+            pos[tour[p1]] = p1
+            pos[tour[p2]] = p2
+            p1            = p1 + 1
+            p2            = p2 - 1
+    else:
+        seg_len = (p2 - p1 + n) % n + 1
+        seg     = np.empty(seg_len, dtype=np.int32)
+        for s in range(seg_len):
+            seg[s] = tour[(p1 + s) % n]
+        for s in range(seg_len):
+            ni            = (p1 + s) % n
+            tour[ni]      = seg[seg_len - 1 - s]
+            pos[tour[ni]] = ni
+
+@njit(fastmath = True, cache = True)
+def two_opt_candidates_restart(tour, D, candidates, max_passes):
+    n   = len(tour)
+    pos = np.empty(n, dtype = np.int32)
+    for i in range(n):
+        pos[tour[i]] = i
+    passes       = 0
+    improved_any = True
+    while improved_any and passes < max_passes:
+        passes       = passes + 1
+        improved_any = False
+        for i in range(0, n):
+            a             = tour[i]
+            b             = tour[(i + 1) % n]
+            dab           = D[a, b]
+            improved_here = False
+            for which_end in range(2):
+                x = a if which_end == 0 else b
+                for ci in range(candidates.shape[1]):
+                    c = candidates[x, ci]
+                    if D[x, c] >= dab:
+                        break
+                    j = pos[c]
+                    d = tour[(j + 1) % n]
+                    if d == a or d == b:
+                        continue
+                    gain = dab + D[c, d] - D[a, c] - D[b, d]
+                    if gain > 1e-12:
+                        p1            = (i + 1) % n
+                        p2            = j
+                        _reverse_segment_inplace(tour, pos, p1, p2, n)
+                        improved_any  = True
+                        improved_here = True
+                        break
+                if improved_here:
+                    break
+    return tour
+
+############################################################################
+
+# Function: KNN
+def knn_indices_fast(D, k):
+    n           = D.shape[0]
+    k           = int(min(k, n - 1))
+    pool        = min(n, k + max(16, k // 2))
+    part        = np.argpartition(D, kth = pool - 1, axis = 1)[:, :pool]
+    rows        = np.arange(n)[:, None]
+    dvals       = D[rows, part]
+    order       = np.argsort(dvals, axis = 1)
+    part_sorted = part[rows, order]
+    nbrs        = np.empty((n, k), dtype = np.int32)
+    for i in range(0, n):
+        out = []
+        for v in part_sorted[i]:
+            v = int(v)
+            if v != i:
+                out.append(v)
+            if len(out) == k:
+                break
+        if len(out) < k:
+            pool2 = pool
+            while len(out) < k:
+                if pool2 >= n:
+                    break
+                pool2 = min(n, max(pool2 + 32, int(pool2 * 1.5), k + 16))
+                part2 = np.argpartition(D[i], kth = pool2 - 1)[:pool2]
+                part2 = part2[np.argsort(D[i, part2])]
+                out   = []
+                for v in part2:
+                    v = int(v)
+                    if v != i:
+                        out.append(v)
+                    if len(out) == k:
+                        break
+        nbrs[i, :] = np.array(out[:k], dtype = np.int32)
+    return nbrs
+
+# Function: Affinity
+def build_affinity_sparse(D, k, sigma_mode, sigma_fixed):
+    n    = D.shape[0]
+    nbrs = knn_indices_fast(D.astype(float), k)
+    if sigma_mode == 'adaptive':
+        sig = D[np.arange(n), nbrs[:, -1]].astype(float) + 1e-12
+    else:
+        sig = np.full(n, sigma_fixed, dtype = float)
+    rows, cols, vals = [], [], []
+    for i in range(n):
+        si = sig[i]
+        for j in nbrs[i]:
+            sj = sig[j]
+            dij = float(D[i, j])
+            if sigma_mode == 'adaptive':
+                w = np.exp(-(dij * dij) / (si * sj + 1e-12))
+            else:
+                w = np.exp(-(dij * dij) / (2.0 * sigma_fixed * sigma_fixed + 1e-12))
+            rows.append(i); cols.append(j); vals.append(w)
+    W = coo_matrix((vals, (rows, cols)), shape = (n, n)).tocsr()
+    W = (W + W.T).tocsr()      
+    W = W.tolil()              
+    W.setdiag(0.0)
+    W = W.tocsr()
+    W.eliminate_zeros()
+    return W
+
+# Function: W
+def laplacian_from_W(W):
+    d = np.array(W.sum(axis = 1)).reshape(-1)
+    return (diags(d) - W).tocsr()
+
+# Function: SE
+def spectral_embedding(L, num_vecs = 3, tol = 1e-6, maxiter = 5000):
+    n = L.shape[0]
+    if n <= 2:
+        return np.zeros((n, 1), dtype = float)
+    num_vecs = int(max(1, min(num_vecs, n - 1)))
+    k_req    = min(num_vecs + 3, n - 1)
+    k_req    = max(k_req, 2)
+    try:
+        vals, vecs = eigsh(L, k = k_req, which = 'SM', tol = tol, maxiter = maxiter)
+    except ArpackNoConvergence as e:
+        if e.eigenvectors is not None and e.eigenvalues is not None:
+            vals, vecs = e.eigenvalues, e.eigenvectors
+        else:
+            k_req2     = max(2, min(k_req - 1, n - 1))
+            vals, vecs = eigsh(L, k = k_req2, which = 'SM', tol = tol, maxiter = maxiter)
+    idx  = np.argsort(vals)
+    vals = vals[idx]
+    vecs = vecs[:, idx]
+    eps  = 1e-10
+    j    = 0
+    while j < len(vals) and vals[j] < eps:
+        j = j + 1
+    if j >= len(vals):
+        j = 1
+    end = min(j + num_vecs, vecs.shape[1])
+    if end <= j:
+        end = min(j + 1, vecs.shape[1])
+    return vecs[:, j:end].copy()
+
+############################################################################
+
+# RSS
+def randomized_spectral_seriation(D, k = 12, iterations = 800, sigma_noise = 0.006, sigma_mode = 'adaptive', sigma_fixed = 250.0, two_opt_passes = 30, num_vecs = 3, cand_k = 35, scale_noise_by_std = True, noise_cap_frac = 0.10, rnd = 7, verbose = True):
+    D   = np.asarray(D, dtype = np.float64)
+    n   = D.shape[0]
+    rng = np.random.default_rng(rnd)
+    if n < 3:
+        tour = list(range(1, n + 1))
+        if n > 0:
+            tour.append(tour[0])
+        return tour, 0.0
+    k         = int(max(1, min(k, n - 1)))
+    cand_k    = int(max(1, min(cand_k, n - 1)))
+    W         = build_affinity_sparse(D, k, sigma_mode, sigma_fixed)
+    L         = laplacian_from_W(W)
+    embedding = spectral_embedding(L, num_vecs = num_vecs, tol = 1e-6, maxiter = 5000)
+    m         = embedding.shape[1]
+    if m <= 0:
+        embedding = np.zeros((n, 1), dtype = float)
+        m = 1
+    candidates = knn_indices_fast(D, cand_k)
+    best_L     = float("inf")
+    best_tour  = None
+    for it in range(0, iterations):
+        coeffs    = rng.normal(0.0, 1.0, size = m)
+        if m > 0:
+            coeffs[0] = 3.0 * coeffs[0]
+        coeffs = coeffs/(np.linalg.norm(coeffs) + 1e-12)
+        x_proj = embedding @ coeffs
+        if scale_noise_by_std:
+            s     = float(np.std(x_proj) + 1e-12)
+            eff   = sigma_noise * s
+            cap   = noise_cap_frac * float((np.max(x_proj) - np.min(x_proj)) + 1e-12)
+            eff   = min(eff, cap)
+            noise = rng.normal(0.0, eff, size = n)
+        else:
+            noise = rng.normal(0.0, sigma_noise, size = n)
+        x_noisy   = x_proj + noise
+        candidate = np.argsort(x_noisy).astype(np.int32)
+        if rng.random() < 0.5:
+            candidate = candidate[::-1].copy()
+        shift     = int(rng.integers(0, n))
+        candidate = np.roll(candidate, shift).astype(np.int32)
+        candidate = two_opt_candidates_restart(candidate, D, candidates, max(two_opt_passes, 2))
+        Lc        = tour_length(candidate, D)
+        if Lc < best_L:
+            best_L    = Lc
+            best_tour = candidate.copy()
+        if verbose:
+            print("Iteration =", it, "; Distance =", best_L)
+    best_out = (best_tour + 1).tolist()
+    best_out.append(best_out[0])
+    return best_out, float(best_L)
+
+############################################################################

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pyCombinatorial/algorithm/ssi.py

@@ -61,7 +61,7 @@ def two_opt(tour, D, max_passes):
 
 # Function: KNN
 def knn_indices(D, k):
-    return np.argsort(D, axis=1)[:, 1 : k + 1]
+    return np.argsort(D, axis = 1)[:, 1 : k + 1]
 
 # Function: Affinity
 def build_affinity_sparse(D, k, sigma_mode, sigma_fixed):

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pycombinatorial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.4
+Version: 2.1.8
 Summary: A library to solve TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics, Metaheuristics and Reinforcement Learning
 Home-page: https://github.com/Valdecy/pyCombinatorial
 Author: Valdecy Pereira
@@ -15,7 +15,7 @@ License-File: LICENSE
 
 **pyCombinatorial** is a Python-based library designed to tackle the classic Travelling Salesman Problem (TSP) through a diverse set of **Exact Algorithms**, **Heuristics**, **Metaheuristics** and **Reinforcement Learning**. It brings together both well-established and cutting-edge methodologies, offering end-users a flexible toolkit to generate high-quality solutions for TSP instances of various sizes and complexities.   
 
-Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
+Techniques: **2-opt**; **2.5-opt**; **3-opt**; **4-opt**; **5-opt**; **Or-opt**; **2-opt Stochastic**; **2.5-opt Stochastic**; **3-opt Stochastic**; **4-opt Stochastic**; **5-opt Stochastic**; **Ant Colony Optimization**; **Adaptive Large Neighborhood Search**; **Bellman-Held-Karp Exact Algorithm**; **Bitonic Tour**; **Branch & Bound**; **BRKGA** (Biased Random Key Genetic Algorithm); **Brute Force**; **Cheapest Insertion**; **Christofides Algorithm**; **Clarke & Wright**  (Savings Heuristic); **Concave Hull Algorithm**; **Convex Hull Algorithm**; **Elastic Net**; **Extremal Optimization**; **Farthest Insertion**; **FRNN** (Fixed Radius Near Neighbor); **Genetic Algorithm**; **GRASP** (Greedy Randomized Adaptive Search Procedure); **Greedy Karp-Steele Patching**; **Guided Search**; **Hopfield Network**; **Iterated Search**; **Karp-Steele Patching**;  **Large Neighborhood Search**; **Multifragment Heuristic**; **Nearest Insertion**; **Nearest Neighbour**; **Random Insertion**; **Random Tour**; **Randomized Spectral Seriation**; **RL Q-Learning**; **RL Double Q-Learning**; **RL S.A.R.S.A** (State Action Reward State Action); **Ruin & Recreate**; **Scatter Search**; **Simulated Annealing**; **SOM** (Self Organizing Maps); **Space Filling Curve** (Hilbert); **Space Filling Curve** (Morton); **Space Filling Curve** (Sierpinski); **Spectral Seriation Initializer**; **Stochastic Hill Climbing**; **Sweep**; **Tabu Search**; **Truncated Branch & Bound**; **Twice-Around the Tree Algorithm** (Double Tree Algorithm); **Variable Neighborhood Search**; **Zero Suffix Method**.
 
 ## Usage
 
@@ -111,6 +111,7 @@ print('Total Distance: ', round(distance, 2))
 - Nearest Neighbour ([ Colab Demo ](https://colab.research.google.com/drive/1aL1kYXgSjUJYPfYSMy_0SWq4hJ3nrueJ?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0166-218X(01)00195-0))
 - Random Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1RP_grqrTXyDkHOLB_L1H8TkvxdLli5hG?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
 - Random Tour ([ Colab Demo ](https://colab.research.google.com/drive/1DPXMJXInkGKTyVFDAQ2bKXjglhy3DaCS?usp=sharing)) ( [ Paper ](https://doi.org/10.1023/A:1011263204536))
+- Randomized Spectral Seriation ([ Colab Demo ](https://colab.research.google.com/drive/1PTtO6HJfftsFZEScCYZvzpBJsgMyjBCY?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - RL Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1dnZhLAzQdz9kzxKrVcwMECWbyEKkZ7St?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL Double Q-Learning ([ Colab Demo ](https://colab.research.google.com/drive/1VTv8A6Ac-LvBxsereFyGRfkiLRbJI547?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
 - RL S.A.R.S.A ([ Colab Demo ](https://colab.research.google.com/drive/1q9hon3jFf8xVCw4idxhu7goLREKbQ6N3?usp=sharing)) ( [ Paper ](https://doi.org/10.1049/tje2.12303))
@@ -121,7 +122,7 @@ print('Total Distance: ', round(distance, 2))
 - Space Filling Curve (Hilbert) ([ Colab Demo ](https://colab.research.google.com/drive/1FXzWrUBjdbJBngRFHv66CZw5pFN3yOs8?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0960-0779(95)80046-J))
 - Space Filling Curve (Morton) ([ Colab Demo ](https://colab.research.google.com/drive/1Z13kXyi7eaNQbBUmhvwuQjY4VaUfGVbs?usp=sharing)) ( [ Paper ](https://dominoweb.draco.res.ibm.com/reports/Morton1966.pdf))
 - Space Filling Curve (Sierpinski) ([ Colab Demo ](https://colab.research.google.com/drive/1w-Zptd5kOryCwvQ0qSNBNhPXC61c8QXF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.67.9061&rep=rep1&type=pdf))
-- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S009753979528577))
+- Spectral Seriation Initializer ([ Colab Demo ](https://colab.research.google.com/drive/1lG0pYxASU75qh0jK-A_eMCoPpCWv0I4V?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/S0097539795285771))
 - Stochastic Hill Climbing ([ Colab Demo ](https://colab.research.google.com/drive/1_wP6vg4JoRHGItGxEtXcf9Y9OuuoDlDl?usp=sharing)) ( [ Paper ](http://aima.cs.berkeley.edu/)) 
 - Sweep ([ Colab Demo ](https://colab.research.google.com/drive/1AkAn4yeomAp6POBslk3Asd6OrxfBrHT7?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.22.2.340))
 - Tabu Search ([ Colab Demo ](https://colab.research.google.com/drive/1SRwQrBaxkKk18SDvQPy--0yNRWdl6Y1G?usp=sharing)) ( [ Paper ](https://doi.org/10.1287/ijoc.1.3.190))

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/pycombinatorial.egg-info/SOURCES.txt

@@ -44,6 +44,7 @@ pyCombinatorial/algorithm/rl_double_ql.py
 pyCombinatorial/algorithm/rl_ql.py
 pyCombinatorial/algorithm/rl_sarsa.py
 pyCombinatorial/algorithm/rr.py
+pyCombinatorial/algorithm/rss.py
 pyCombinatorial/algorithm/rt.py
 pyCombinatorial/algorithm/s_gui.py
 pyCombinatorial/algorithm/s_itr.py

{pycombinatorial-2.1.4 → pycombinatorial-2.1.8}/setup.py

@@ -6,7 +6,7 @@ long_description = (this_directory / 'README.md').read_text()
 
 setup(
     name='pycombinatorial',
-    version='2.1.4',
+    version='2.1.8',
     license='GNU',
     author='Valdecy Pereira',
     author_email='valdecy.pereira@gmail.com',