pycombinatorial 2.1.7__tar.gz → 2.1.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.7
+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))

{pycombinatorial-2.1.7 → 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))

{pycombinatorial-2.1.7 → 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.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.7 → 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.7 → pycombinatorial-2.1.8}/pycombinatorial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.7
+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))

{pycombinatorial-2.1.7 → 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.7 → pycombinatorial-2.1.8}/setup.py

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