pycombinatorial 2.1.0__tar.gz → 2.1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.0
+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**; **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
 
@@ -76,6 +76,7 @@ print('Total Distance: ', round(distance, 2))
 - 3-opt ([ Colab Demo ](https://colab.research.google.com/drive/1iAZLawLBZ-7yaPCyobMtel1SvBamxtjL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf)) 
 - 4-opt ([ Colab Demo ](https://colab.research.google.com/drive/1N8HKhVY4s20sfqo8IWIaCY-NHVk6gARS?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
 - 5-opt ([ Colab Demo ](https://colab.research.google.com/drive/15Qrk-7H4oRaTR77ADvwkiN0sLvycgFDH?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- Or-opt ([ Colab Demo ](https://colab.research.google.com/drive/1p7JwrFLH83ZroCzIweXLCAXYgA3FKAI0?usp=sharing)) ( [ Paper ](https://doi.org/10.1057/palgrave.jors.2602160))
 - 2-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1xTm__7OwQVC_KX2b-eExLGgG1DgnJ10a?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/j.trpro.2014.10.001)) 
 - 2.5-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/16W_QqJ1PebVgqUx8NFOSS5kG3DsJ51UQ?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10955-007-9382-1))  
 - 3-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1A5lPW6BSDD2rLNDlnpQo44U8jwKcAGXL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
@@ -120,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.0 → 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**; **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
 
@@ -65,6 +65,7 @@ print('Total Distance: ', round(distance, 2))
 - 3-opt ([ Colab Demo ](https://colab.research.google.com/drive/1iAZLawLBZ-7yaPCyobMtel1SvBamxtjL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf)) 
 - 4-opt ([ Colab Demo ](https://colab.research.google.com/drive/1N8HKhVY4s20sfqo8IWIaCY-NHVk6gARS?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
 - 5-opt ([ Colab Demo ](https://colab.research.google.com/drive/15Qrk-7H4oRaTR77ADvwkiN0sLvycgFDH?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- Or-opt ([ Colab Demo ](https://colab.research.google.com/drive/1p7JwrFLH83ZroCzIweXLCAXYgA3FKAI0?usp=sharing)) ( [ Paper ](https://doi.org/10.1057/palgrave.jors.2602160))
 - 2-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1xTm__7OwQVC_KX2b-eExLGgG1DgnJ10a?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/j.trpro.2014.10.001)) 
 - 2.5-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/16W_QqJ1PebVgqUx8NFOSS5kG3DsJ51UQ?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10955-007-9382-1))  
 - 3-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1A5lPW6BSDD2rLNDlnpQo44U8jwKcAGXL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
@@ -109,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.0 → pycombinatorial-2.1.2}/pyCombinatorial/algorithm/__init__.py

@@ -29,6 +29,7 @@ from .opt_2_5      import local_search_2h_opt
 from .opt_3        import local_search_3_opt
 from .opt_4        import local_search_4_opt
 from .opt_5        import local_search_5_opt
+from .opt_or       import local_search_or_opt
 from .opt_2s       import local_search_2_opt_stochastic
 from .opt_2_5s     import local_search_2h_opt_stochastic
 from .opt_3s       import local_search_3_opt_stochastic
@@ -37,8 +38,8 @@ from .opt_5s       import local_search_5_opt_stochastic
 from .rl_double_ql import double_q_learning
 from .rl_ql        import q_learning
 from .rl_sarsa     import sarsa
-from .rt           import random_tour
 from .rr           import ruin_and_recreate
+from .rt           import random_tour
 from .s_gui        import guided_search
 from .s_itr        import iterated_search
 from .s_sct        import scatter_search
@@ -50,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/opt_or.py

@@ -0,0 +1,192 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: Or-Opt
+#
+# 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: Insertion
+def insertion(city_tour, distance_matrix, chain_length = 5, k_min = 1, k_max = 10, lambda_val = 0.1, vf_mode = True):
+
+    # -------------------------------------------------------------------------
+
+    def total_distance(dist_mat, route_idxs):
+        total = 0.0
+        for idx in range(1, len(route_idxs)):
+            total = total + dist_mat[route_idxs[idx - 1]][route_idxs[idx]]
+        return total
+
+    # -------------------------------------------------------------------------
+
+    route = copy.deepcopy(city_tour[0])
+    if route[0] != route[-1]:
+        route = route + [route[0]]
+    current_distance = total_distance(distance_matrix, route)
+    n                = len(route) - 1  
+    if isinstance(distance_matrix, np.ndarray):
+        if distance_matrix.ndim != 2 or distance_matrix.shape[0] != distance_matrix.shape[1]:
+            raise ValueError("distance_matrix must be a square 2D array.")
+        if n <= 1:
+            avg_graph_cost = 1.0
+        else:
+            avg_graph_cost = distance_matrix[np.triu_indices(n, k=1)].mean()
+            if not np.isfinite(avg_graph_cost) or avg_graph_cost <= 0:
+                avg_graph_cost = 1.0
+    else:
+        if n <= 1:
+            avg_graph_cost = 1.0
+        else:
+            s   = 0.0
+            cnt = 0
+            for a in range(n):
+                for b in range(a + 1, n):
+                    s   = s + distance_matrix[a][b]
+                    cnt = cnt + 1
+            avg_graph_cost = s / cnt if cnt else 1.0
+
+    k_sequence = list(range(int(k_max), int(k_min) - 1, -1))
+    max_passes = max(1, int(chain_length))
+    for _pass in range(0, max_passes):
+        improved_any = False
+        if vf_mode:
+            for i in range(1, len(route) - 1):
+                for k in k_sequence:         
+                    if i + k >= len(route):
+                        continue
+                    i1, i2 = route[i - 1], route[i]
+                    i3, i4 = route[i + k - 1], route[i + k]
+                    g      = (distance_matrix[i1][i2] +
+                              distance_matrix[i3][i4] -
+                              distance_matrix[i1][i4])
+                    d_bar  = current_distance / max(1, n)
+                    l_bar  = (2.0 * avg_graph_cost) - d_bar
+                    if g <= lambda_val * l_bar:
+                        continue
+                    segment = route[i:i + k]
+                    rem     = route[:i] + route[i + k:]
+                    moved   = False
+                    for j in range(1, len(rem)):
+                        temp = rem[:j] + segment + rem[j:]
+                        cost = total_distance(distance_matrix, temp)
+                        if cost + 1e-12 < current_distance:
+                            route            = temp
+                            current_distance = cost
+                            improved_any     = True
+                            moved            = True
+                            break  
+                    if moved:
+                        break
+        else:
+            for k in k_sequence:
+                improved_k = True
+                while improved_k:
+                    improved_k = False
+                    last_idx   = len(route) - 1
+                    for i in range(1, last_idx):
+                        if i + k > last_idx:
+                            continue
+                        i1, i2 = route[i - 1], route[i]
+                        i3, i4 = route[i + k - 1], route[i + k]
+                        g      = (distance_matrix[i1][i2] +
+                                  distance_matrix[i3][i4] -
+                                  distance_matrix[i1][i4])
+                        d_bar  = current_distance / max(1, n)
+                        l_bar  = (2.0 * avg_graph_cost) - d_bar
+                        if g <= lambda_val * l_bar:
+                            continue
+                        segment = route[i:i + k]
+                        rem     = route[:i] + route[i + k:]
+                        for j in range(1, len(rem)):
+                            temp = rem[:j] + segment + rem[j:]
+                            cost = total_distance(distance_matrix, temp)
+                            if cost + 1e-12 < current_distance:
+                                route            = temp
+                                current_distance = cost
+                                improved_k       = True
+                                improved_any     = True
+                                break  
+                        if improved_k:
+                            break  
+        if not improved_any:
+            break
+    return route, current_distance
+
+# Function: Or - Opt
+def local_search_or_opt(city_tour, distance_matrix, iterations = 100, chain_length = 3, k1 = 1, k2 = 5, lbd = 0.1, vf = True, local_search = True, verbose = True):
+    route      = city_tour[0]
+    distance   = city_tour[1]
+    route      = [item - 1 for item in route]
+    no_improve = 0
+    for i in range(0, iterations):
+        new_route, new_distance = insertion([route, distance], distance_matrix, chain_length, k1, k2, lbd, vf)
+        if new_distance < distance:
+            route      = copy.deepcopy(new_route)
+            distance   = new_distance
+            no_improve = 0  
+        else:
+            no_improve = no_improve + 1
+        if no_improve >= 2:
+            break  
+        if (verbose == True):
+            print('Iteration = ', i, 'Distance = ', round(distance, 2)) 
+    route = [item + 1 for item in route]
+    if (local_search == True):
+        print('')
+        print('Local Search:')
+        route, distance = local_search_2_opt(distance_matrix, [route, distance], recursive_seeding = -1, verbose = verbose)
+    return route, distance
+
+############################################################################

{pycombinatorial-2.1.0 → pycombinatorial-2.1.2}/pyCombinatorial/algorithm/rr.py

@@ -97,8 +97,7 @@ def ruin_and_recreate(city_tour, distance_matrix, iterations = 100, ruin_rate =
     distance  = city_list[1]
     best_r    = copy.deepcopy(route)
     best_d    = distance
-    iteration = 0
-    for _ in range(0, iterations):
+    for i in range(0, iterations):
         n_remove  = max(1, int(len(removable) * ruin_rate))
         to_remove = set(np.random.choice(removable, min(n_remove, len(removable)), replace = False))
         route     = [city for city in route if city not in to_remove]
@@ -107,11 +106,10 @@ def ruin_and_recreate(city_tour, distance_matrix, iterations = 100, ruin_rate =
         route    = regret2_insertion(route, to_remove, distance_matrix)
         distance = distance_calc(distance_matrix, [route, distance])
         if (verbose == True):
-            print('Iteration = ', iteration, 'Distance = ', round(best_d, 2))  
+            print('Iteration = ', i, 'Distance = ', round(best_d, 2))  
         if distance < best_d:
             best_r = copy.deepcopy(route)
             best_d = distance
-        iteration = iteration + 1
     if (local_search == True):
         print('')
         print('Local Search:')

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.0 → pycombinatorial-2.1.2}/pycombinatorial.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycombinatorial
-Version: 2.1.0
+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**; **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
 
@@ -76,6 +76,7 @@ print('Total Distance: ', round(distance, 2))
 - 3-opt ([ Colab Demo ](https://colab.research.google.com/drive/1iAZLawLBZ-7yaPCyobMtel1SvBamxtjL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf)) 
 - 4-opt ([ Colab Demo ](https://colab.research.google.com/drive/1N8HKhVY4s20sfqo8IWIaCY-NHVk6gARS?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
 - 5-opt ([ Colab Demo ](https://colab.research.google.com/drive/15Qrk-7H4oRaTR77ADvwkiN0sLvycgFDH?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- Or-opt ([ Colab Demo ](https://colab.research.google.com/drive/1p7JwrFLH83ZroCzIweXLCAXYgA3FKAI0?usp=sharing)) ( [ Paper ](https://doi.org/10.1057/palgrave.jors.2602160))
 - 2-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1xTm__7OwQVC_KX2b-eExLGgG1DgnJ10a?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/j.trpro.2014.10.001)) 
 - 2.5-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/16W_QqJ1PebVgqUx8NFOSS5kG3DsJ51UQ?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10955-007-9382-1))  
 - 3-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1A5lPW6BSDD2rLNDlnpQo44U8jwKcAGXL?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
@@ -120,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.0 → pycombinatorial-2.1.2}/pycombinatorial.egg-info/SOURCES.txt

@@ -39,6 +39,7 @@ pyCombinatorial/algorithm/opt_4.py
 pyCombinatorial/algorithm/opt_4s.py
 pyCombinatorial/algorithm/opt_5.py
 pyCombinatorial/algorithm/opt_5s.py
+pyCombinatorial/algorithm/opt_or.py
 pyCombinatorial/algorithm/rl_double_ql.py
 pyCombinatorial/algorithm/rl_ql.py
 pyCombinatorial/algorithm/rl_sarsa.py
@@ -55,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.0 → pycombinatorial-2.1.2}/setup.py

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

pycombinatorial-2.1.0/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
-
-############################################################################