pycombinatorial 2.1.1__tar.gz → 2.1.2__tar.gz

{pycombinatorial-2.1.1 → pycombinatorial-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.1
+Version: 2.1.2
 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); **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**; **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
 
@@ -121,6 +121,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))
 - 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.1 → pycombinatorial-2.1.2}/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); **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**; **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
 
@@ -110,6 +110,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))
 - 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.1 → pycombinatorial-2.1.2}/pyCombinatorial/algorithm/__init__.py

@@ -51,6 +51,7 @@ from .som          import self_organizing_maps
 from .spfc_h       import space_filling_curve_h
 from .spfc_m       import space_filling_curve_m
 from .spfc_s       import space_filling_curve_s
+from .ssi          import spectral_seriation_initializer
 from .swp          import sweep
 from .tat          import tat_algorithm
 from .tbb          import truncated_branch_and_bound

pycombinatorial-2.1.2/pyCombinatorial/algorithm/ins_f.py

@@ -0,0 +1,126 @@
+############################################################################
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+
+# Lesson: pyCombinatorial - Farthest Insertion
+ 
+# GitHub Repository: <https://github.com/Valdecy> 
+
+############################################################################
+
+import copy
+import numpy as np
+
+############################################################################
+
+# Function: Tour Distance
+def distance_calc(distance_matrix, city_tour):
+    distance = 0
+    for k in range(0, len(city_tour[0]) - 1):
+        m        = k + 1
+        distance = distance + distance_matrix[city_tour[0][k] - 1, city_tour[0][m] - 1]
+    return distance
+
+############################################################################
+
+# Function: 2_opt
+def local_search_2_opt(distance_matrix, city_tour, recursive_seeding = -1, verbose = True):
+    if (recursive_seeding < 0):
+        count = -2
+    else:
+        count = 0
+    city_list = copy.deepcopy(city_tour)
+    distance  = city_list[1] * 2
+    iteration = 0
+    while (count < recursive_seeding):
+        if (verbose == True):
+            print('Iteration = ', iteration, 'Distance = ', round(city_list[1], 2))
+        best_route = copy.deepcopy(city_list)
+        seed       = copy.deepcopy(city_list)
+        for i in range(0, len(city_list[0]) - 2):
+            for j in range(i + 1, len(city_list[0]) - 1):
+                best_route[0][i:j + 1] = list(reversed(best_route[0][i:j + 1]))
+                best_route[0][-1]      = best_route[0][0]
+                best_route[1]          = distance_calc(distance_matrix, best_route)
+                if (city_list[1] > best_route[1]):
+                    city_list = copy.deepcopy(best_route)
+                best_route = copy.deepcopy(seed)
+        count     = count + 1
+        iteration = iteration + 1
+        if (distance > city_list[1] and recursive_seeding < 0):
+            distance          = city_list[1]
+            count             = -2
+            recursive_seeding = -1
+        elif (city_list[1] >= distance and recursive_seeding < 0):
+            count             = -1
+            recursive_seeding = -2
+    return city_list[0], city_list[1]
+
+############################################################################
+
+# Function: Cheapest insertion Position 
+def best_insertion(distance_matrix, temp):
+    if len(temp) <= 2:
+        return temp
+    new_node    = temp[-1]
+    base        = temp[:-1]
+    base_closed = base + [base[0]]
+    best_pos    = None
+    best_delta  = float('+inf')
+    for i in range(0, len(base)): 
+        a = base_closed[i]
+        b = base_closed[i + 1]
+        delta = (distance_matrix[a, new_node] + distance_matrix[new_node, b] - distance_matrix[a, b])
+        if delta < best_delta:
+            best_delta = delta
+            best_pos   = i + 1
+    out = base[:]
+    out.insert(best_pos, new_node)
+    return out
+
+############################################################################
+
+# Function: Farthest Insertion
+def farthest_insertion(distance_matrix, local_search = True, verbose = True):
+    best_val         = float('+inf')
+    best_route       = []
+    n                = distance_matrix.shape[0]
+    initial_location = -1
+    for i1 in range(0, n):
+        if (initial_location != -1):
+            i1 = initial_location - 1
+        dist    = np.copy(distance_matrix).astype(float)
+        np.fill_diagonal(dist, float('-inf'))
+        idx     = dist[i1, :].argmax()
+        temp    = [i1, idx] 
+        in_tour = set(temp)
+        for _ in range(0, n - 2):
+            remaining  = [u for u in range(0, n) if u not in in_tour]
+            best_u     = None
+            best_score = float('-inf')
+            for u in remaining:
+                score = min(distance_matrix[u, t] for t in temp)
+                if score > best_score:
+                    best_score = score
+                    best_u     = u
+            temp.append(best_u)
+            in_tour.add(best_u)
+            temp = best_insertion(distance_matrix, temp)
+        route = temp + [temp[0]]
+        route = [x + 1 for x in route]
+        val   = distance_calc(distance_matrix, [route, 1])
+        if local_search:
+            seed         = [route, val]
+            route2, val2 = local_search_2_opt(distance_matrix, seed, -1, True)
+            route, val   = route2, val2
+        if (val < best_val):
+            best_val   = val
+            best_route = [item for item in route]
+        if (verbose == True):
+            print('Iteration = ', i1 + 1, 'Distance = ', round(best_val, 2))
+        if (initial_location != -1):
+            break
+    return best_route, best_val
+
+############################################################################

pycombinatorial-2.1.2/pyCombinatorial/algorithm/ssi.py

@@ -0,0 +1,143 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: pyCombinatorial - SSI (Spectral Seriation Initializer)
+ 
+# 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
+
+############################################################################
+
+# Function: Tour Lenght
+@njit(fastmath = True)
+def tour_length(tour, D):
+    n = len(tour)
+    L = 0.0
+    for i in range(n):
+        L = L + D[tour[i], tour[(i + 1) % n]]
+    return L
+
+# Function: 2-opt Passes
+@njit(fastmath = True)
+def two_opt(tour, D, max_passes):
+    n        = len(tour)
+    improved = True
+    passes   = 0  
+    while improved and passes < max_passes:
+        improved = False
+        passes   = passes + 1
+        for i in range(0, n - 1):
+            a_idx = tour[i]
+            b_idx = tour[(i + 1)]
+            k_end = n - 1 if i == 0 else n 
+            for k in range(i + 2, k_end):
+                c_idx        = tour[k]
+                d_idx        = tour[(k + 1) % n]
+                current_cost = D[a_idx, b_idx] + D[c_idx, d_idx]
+                new_cost     = D[a_idx, c_idx] + D[b_idx, d_idx]       
+                if new_cost < current_cost:
+                    p1 = i + 1
+                    p2 = k
+                    while p1 < p2:
+                        temp     = tour[p1]
+                        tour[p1] = tour[p2]
+                        tour[p2] = temp
+                        p1       = p1 + 1
+                        p2       = p2 - 1
+                    improved = True  
+    return tour
+
+############################################################################
+
+# Function: KNN
+def knn_indices(D, k):
+    return np.argsort(D, axis=1)[:, 1 : k + 1]
+
+# Function: Affinity
+def build_affinity_sparse(D, k, sigma_mode, sigma_fixed):
+    n    = D.shape[0]
+    nbrs = knn_indices(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: Laplacian
+def laplacian_from_W(W):
+    d = np.array(W.sum(axis = 1)).reshape(-1)
+    return (diags(d) - W).tocsr()
+
+# Function: Fiedler Vector
+def fiedler_vector(L):
+    vals, vecs = eigsh(L, k = 4, which = 'SM')
+    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 == 0 and len(vals) > 1:
+        j = 1
+    j = min(j, len(vals) - 1)
+    return vecs[:, j].copy()
+
+############################################################################
+
+# Spectral Seriation Initializer
+def spectral_seriation_initializer(D, k = 12, iterations = 800, sigma_noise = 0.003, sigma_mode = 'adaptive', sigma_fixed = 250.0, two_opt_passes = 10, rnd = 7, verbose = True):
+    D         = np.asarray(D)
+    n         = D.shape[0]
+    rng       = np.random.default_rng(rnd)
+    W         = build_affinity_sparse(D, k, sigma_mode, sigma_fixed)
+    L         = laplacian_from_W(W)
+    x         = fiedler_vector(L)
+    best_L    = float("inf")
+    best_tour = None
+    for nt in range(0, iterations):
+        x_noisy = x + rng.normal(0.0, sigma_noise, size = n)
+        tour    = np.argsort(x_noisy).astype(np.int32)
+        if rng.random() < 0.5:
+            tour = tour[::-1]
+        shift = int(rng.integers(0, n))
+        tour  = np.roll(tour, shift)
+        tour  = two_opt(tour, D, two_opt_passes)
+        Lc    = tour_length(tour, D)
+        if Lc < best_L:
+            best_L    = Lc
+            best_tour = tour
+        if verbose:
+            print('Iteration = ', nt, 'Distance = ', best_L)
+    best_tour = [item + 1 for item in best_tour]
+    best_tour.append(best_tour[0])
+    return best_tour, int(best_L)
+
+############################################################################

{pycombinatorial-2.1.1 → pycombinatorial-2.1.2}/pycombinatorial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.1
+Version: 2.1.2
 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); **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**; **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
 
@@ -121,6 +121,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))
 - 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.1 → pycombinatorial-2.1.2}/pycombinatorial.egg-info/SOURCES.txt

@@ -56,6 +56,7 @@ pyCombinatorial/algorithm/som.py
 pyCombinatorial/algorithm/spfc_h.py
 pyCombinatorial/algorithm/spfc_m.py
 pyCombinatorial/algorithm/spfc_s.py
+pyCombinatorial/algorithm/ssi.py
 pyCombinatorial/algorithm/swp.py
 pyCombinatorial/algorithm/tat.py
 pyCombinatorial/algorithm/tbb.py

{pycombinatorial-2.1.1 → pycombinatorial-2.1.2}/setup.py

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

pycombinatorial-2.1.1/pyCombinatorial/algorithm/ins_f.py

@@ -1,112 +0,0 @@
-############################################################################
-
-# Created by: Prof. Valdecy Pereira, D.Sc.
-# UFF - Universidade Federal Fluminense (Brazil)
-# email:  valdecy.pereira@gmail.com
-# Lesson: Farthest Insertion
- 
-# GitHub Repository: <https://github.com/Valdecy>
-
-############################################################################
-
-# Required Libraries
-import copy
-import numpy as np
-
-############################################################################
-
-# Function: Tour Distance
-def distance_calc(distance_matrix, city_tour):
-    distance = 0
-    for k in range(0, len(city_tour[0])-1):
-        m        = k + 1
-        distance = distance + distance_matrix[city_tour[0][k]-1, city_tour[0][m]-1]            
-    return distance
-
-# Function: 2_opt
-def local_search_2_opt(distance_matrix, city_tour, recursive_seeding = -1, verbose = True):
-    if (recursive_seeding < 0):
-        count = -2
-    else:
-        count = 0
-    city_list = copy.deepcopy(city_tour)
-    distance  = city_list[1]*2
-    iteration = 0
-    while (count < recursive_seeding):
-        if (verbose == True):
-            print('Iteration = ', iteration, 'Distance = ', round(city_list[1], 2))  
-        best_route = copy.deepcopy(city_list)
-        seed       = copy.deepcopy(city_list)        
-        for i in range(0, len(city_list[0]) - 2):
-            for j in range(i+1, len(city_list[0]) - 1):
-                best_route[0][i:j+1] = list(reversed(best_route[0][i:j+1]))           
-                best_route[0][-1]    = best_route[0][0]     
-                best_route[1]        = distance_calc(distance_matrix, best_route)                    
-                if (city_list[1] > best_route[1]):
-                    city_list = copy.deepcopy(best_route)         
-                best_route = copy.deepcopy(seed)
-        count     = count + 1
-        iteration = iteration + 1  
-        if (distance > city_list[1] and recursive_seeding < 0):
-             distance          = city_list[1]
-             count             = -2
-             recursive_seeding = -1
-        elif(city_list[1] >= distance and recursive_seeding < 0):
-            count              = -1
-            recursive_seeding  = -2
-    return city_list[0], city_list[1]
-
-############################################################################
-
-# Function: Best Insertion
-def best_insertion(distance_matrix, temp):
-    temp_    = [item+1 for item in temp]
-    temp_    = temp_ + [temp_[0]]
-    d        = distance_calc(distance_matrix, [temp_, 1])
-    seed     = [temp_, d]
-    temp_, _ = local_search_2_opt(distance_matrix, seed, recursive_seeding = -1, verbose = False)
-    temp     = [item-1 for item in temp_[:-1]]
-    return temp
-
-############################################################################
-
-# Function: Farthest Insertion
-def farthest_insertion(distance_matrix, initial_location = -1, verbose = True):
-    maximum    = float('+inf')
-    distance   = float('+inf')
-    route      = []
-    for i1 in range(0, distance_matrix.shape[0]):
-        if (initial_location != -1):
-            i1 = initial_location-1
-        temp       = []
-        dist       = np.copy(distance_matrix)
-        dist       = dist.astype(float)
-        np.fill_diagonal(dist, float('-inf'))
-        idx        = dist[i1,:].argmax()
-        dist[i1,:] = float('-inf')
-        dist[:,i1] = float('-inf')
-        temp.append(i1)
-        temp.append(idx)
-        for j in range(0, distance_matrix.shape[0]-2):
-            i2         = idx
-            idx        = dist[i2,:].argmax()  
-            dist[i2,:] = float('-inf')
-            dist[:,i2] = float('-inf')
-            temp.append(idx)
-            temp       = best_insertion(distance_matrix, temp)
-        temp = temp + [temp[0]]
-        temp = [item + 1 for item in temp]
-        val  = distance_calc(distance_matrix, [temp, 1])
-        if (val < maximum):
-            maximum  = val
-            distance = val
-            route    = [item for item in temp]
-        if (verbose == True):
-            print('Iteration = ', i1, 'Distance = ', round(distance, 2))
-        if (initial_location == -1):
-            continue
-        else: 
-            break
-    return route, distance
-
-############################################################################