pycombinatorial 1.8.2__tar.gz

pycombinatorial-1.8.2/LICENSE

@@ -0,0 +1,14 @@
+Copyright © 2023 by Valdecy Pereira
+
+pyCombinatorial is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+pyCombinatorial is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with pyCombinatorial.  If not, see <http://www.gnu.org/licenses/>.

pycombinatorial-1.8.2/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: pycombinatorial
+Version: 1.8.2
+Summary: A library to solve TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics and Metaheuristics
+Home-page: https://github.com/Valdecy/pyCombinatorial
+Author: Valdecy Pereira
+Author-email: valdecy.pereira@gmail.com
+License: GNU
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyCombinatorial
+
+## Introduction
+
+A library to solve the TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics and Metaheuristics : **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**; **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**; **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); **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**.
+
+## Usage
+
+1. Install
+
+```bash
+pip install pyCombinatorial
+```
+
+2. Import
+
+```py3
+
+
+# Required Libraries
+import pandas as pd
+
+# GA
+from pyCombinatorial.algorithm import genetic_algorithm
+from pyCombinatorial.utils import graphs, util
+
+# Loading Coordinates # Berlin 52 (Minimum Distance = 7544.3659)
+coordinates = pd.read_csv('https://bit.ly/3Oyn3hN', sep = '\t') 
+coordinates = coordinates.values
+
+# Obtaining the Distance Matrix
+distance_matrix = util.build_distance_matrix(coordinates)
+
+# GA - Parameters
+parameters = {
+            'population_size': 15,
+            'elite': 1,
+            'mutation_rate': 0.1,
+            'mutation_search': 8,
+            'generations': 1000,
+            'verbose': True
+             }
+
+# GA - Algorithm
+route, distance = genetic_algorithm(distance_matrix, **parameters)
+
+# Plot Locations and Tour
+graphs.plot_tour(coordinates, city_tour = route, view = 'browser', size = 10)
+print('Total Distance: ', round(distance, 2))
+
+```
+
+3. Try it in **Colab** 
+
+- Using Lat Long ([ Colab Demo ](https://colab.research.google.com/drive/17jFw4z1R9gOoAfB-ZCZa6c-PukVKdrt3?usp=sharing))
+
+- 2-opt ([ Colab Demo ](https://colab.research.google.com/drive/1SLkM8r_VdlFCpNpm-2yTfr_ynSC5WIX9?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/167074)) 
+- 2.5-opt ([ Colab Demo ](https://colab.research.google.com/drive/17bJ-I26prnryAU8p-xf0l7R91cJzb85N?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10955-007-9382-1))     
+- 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))
+- 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))
+- 4-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1igWrUMVSInzyeOdhPcGuMjyooZ6elvLY?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- 5-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/13vS5MCeFqb3F4ntxrw3iCsMbJTfEVyeo?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- Ant Colony Optimization ([ Colab Demo ](https://colab.research.google.com/drive/1O2qogrjE4mZUZX3nsSxw43crumlBnd-D?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/4235.585892)) 
+- Adaptive Large Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1vShK5fe2xRCpMkurgd4PzmstGtn6d_LQ?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/25769321)) 
+- Bellman-Held-Karp Exact Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1HSnArk-v8PWY4dlCvT5zcSAnT1FJEDaf?usp=sharing)) ( [ Paper ](https://dl.acm.org/doi/10.1145/321105.321111))
+- Branch & Bound ([ Colab Demo ](https://colab.research.google.com/drive/1oDHrECSW3g4vBEsrO8T7qSHID4fxFiqs?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/j.disopt.2016.01.005))
+- BRKGA (Biased Random Key Genetic Algorithm) ([ Colab Demo ](https://colab.research.google.com/drive/1lwnpUBl1P1LIvzN1saLgEvnaKZRMWLHn?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10732-010-9143-1))
+- Brute Force ([ Colab Demo ](https://colab.research.google.com/drive/10vOkBz3Cv9UdHPlcBWkDmJO7EvDg96ar?usp=sharing)) ( [ Paper ](https://swarm.cs.pub.ro/~mbarbulescu/cripto/Understanding%20Cryptography%20by%20Christof%20Paar%20.pdf))
+- Cheapest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1QOg8FDvrFUgojwLXD2BBvEuB9Mu7q88a?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- Christofides Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1Wbm-YQ9TeH2OU-IjZzVdDkWGQILv4Pj_?usp=sharing)) ( [ Paper ](https://apps.dtic.mil/dtic/tr/fulltext/u2/a025602.pdf))
+- Clarke & Wright  (Savings Heuristic) ([ Colab Demo ](https://colab.research.google.com/drive/1XC2yoVe6wTsjt7u2fBaL3LcKUu42FG8r?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.12.4.568))
+- Concave Hull Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1P96DerRe7CLyC9dQNr96nEkNHnxpGYY4?usp=sharing)) ( [ Paper ](http://repositorium.sdum.uminho.pt/bitstream/1822/6429/1/ConcaveHull_ACM_MYS.pdf))
+- Convex Hull Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1Wn2OWccZukOfMtJuGV9laklLTc8vjOFq?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/TSMC.1974.4309370))
+- Elastic Net ([ Colab Demo ](https://colab.research.google.com/drive/1F7IlkKdZ3_zQ_MkhknkIPHvE5RqJG7YC?usp=sharing)) ( [ Paper ](https://doi.org/10.1038/326689a0))
+- Extremal Optimization ([ Colab Demo ](https://colab.research.google.com/drive/1Y5YH0eYKjr1nj_IfhJXaILRDIXm-LWLs?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/5992.881710))
+- Farthest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/13pWiLL_dO9Y1lvQO0zD50MXk4mD0Tn1W?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- Genetic Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1zO9rm-G6HOMeg1Q_ptMHJr48EpHcCAIS?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/BF02125403))  
+- GRASP (Greedy Randomized Adaptive Search Procedure) ([ Colab Demo ](https://colab.research.google.com/drive/1OnRyCc6C_QL6wr6-l5RlQI4eGbMdwuhS?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/BF01096763)) 
+- Greedy Karp-Steele Patching ([ Colab Demo ](https://colab.research.google.com/drive/1to3u45QWWQK8REj1_YiF5rUqUqNjB18q?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0377-2217(99)00468-3))
+- Guided Search ([ Colab Demo ](https://colab.research.google.com/drive/1uT9mlDoo37Ni7hqziGNELEGQCGBKQ83o?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0377-2217(98)00099-X)) 
+- Hopfield Network ([ Colab Demo ](https://colab.research.google.com/drive/1Io20FFsndsRT3Bc1nimLBcpH5WtEt7Pe?usp=sharing)) ( [ Paper ](https://doi.org/10.1515/dema-1996-0126)) 
+- Iterated Search ([ Colab Demo ](https://colab.research.google.com/drive/1U3sPpknulwsCUQq9mK7Ywfb8ap2GIXZv?usp=sharing)) ( [ Paper ](https://doi.org/10.1063/1.36219)) 
+- Karp-Steele Patching ([ Colab Demo ](https://colab.research.google.com/drive/12xLLDNIk6OOSNQXqYSYtdwhupZ9Kt5xb?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/0208045))
+- Large Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1t4cafHRRzOLN4xth96jE-2qHoPQOLsn5?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/3-540-49481-2_30))
+- Multifragment Heuristic ([ Colab Demo ](https://colab.research.google.com/drive/1YNHVjS6P35bAnqGZyP7ERNrTnG9tNuhF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=08D176AEFA57EF1941645F2B31DF1686?doi=10.1.1.92.1635&rep=rep1&type=pdf))
+- Nearest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1R4mz604EG-unKktu8ON_Hpoywi3OIRHK?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- 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))
+- 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))
+- Scatter Search ([ Colab Demo ](https://colab.research.google.com/drive/115Ql6KegvOjlNUUfsbY4fA8Vab-db26N?usp=sharing)) ( [ Paper ](https://doi.org/10.1111/j.1540-5915.1977.tb01074.x)) 
+- Simulated Annealing ([ Colab Demo ](https://colab.research.google.com/drive/10Th0yLaAeSqp9FhYB0H00e4sXTbg7Jp2?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/1690046))
+- SOM (Self Organizing Maps) ([ Colab Demo ](https://colab.research.google.com/drive/1-ZwSFnXf1_kCeY_p3SC3N21T8QeSWsg6?usp=sharing)) ( [ Paper ](https://arxiv.org/pdf/2201.07208.pdf))
+- 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))
+- 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))
+- Truncated Branch & Bound ([ Colab Demo ](https://colab.research.google.com/drive/16m72PrBZN8mWMCer12dgsStcNGs4DVdQ?usp=sharing)) ( [ Paper ](https://research.ijcaonline.org/volume65/number5/pxc3885866.pdf)) 
+- Twice-Around the Tree Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1tf5tc5DxvEUc89JaaFgzmK1TtD1e4fkc?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0196-6774(84)90029-4)) 
+- Variable Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1yMWjYuurzpcijsCFDTA76fAwJmSaDkZq?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0305-0548(97)00031-2)) 
+
+# Single Objective Optimization
+For Single Objective Optimization try [pyMetaheuristic](https://github.com/Valdecy/pyMetaheuristic)
+
+# Multiobjective Optimization or Many Objectives Optimization
+For Multiobjective Optimization or Many Objectives Optimization try [pyMultiobjective](https://github.com/Valdecy/pyMultiobjective)

pycombinatorial-1.8.2/README.md

@@ -0,0 +1,114 @@
+# pyCombinatorial
+
+## Introduction
+
+A library to solve the TSP (Travelling Salesman Problem) using Exact Algorithms, Heuristics and Metaheuristics : **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**; **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**; **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); **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**.
+
+## Usage
+
+1. Install
+
+```bash
+pip install pyCombinatorial
+```
+
+2. Import
+
+```py3
+
+
+# Required Libraries
+import pandas as pd
+
+# GA
+from pyCombinatorial.algorithm import genetic_algorithm
+from pyCombinatorial.utils import graphs, util
+
+# Loading Coordinates # Berlin 52 (Minimum Distance = 7544.3659)
+coordinates = pd.read_csv('https://bit.ly/3Oyn3hN', sep = '\t') 
+coordinates = coordinates.values
+
+# Obtaining the Distance Matrix
+distance_matrix = util.build_distance_matrix(coordinates)
+
+# GA - Parameters
+parameters = {
+            'population_size': 15,
+            'elite': 1,
+            'mutation_rate': 0.1,
+            'mutation_search': 8,
+            'generations': 1000,
+            'verbose': True
+             }
+
+# GA - Algorithm
+route, distance = genetic_algorithm(distance_matrix, **parameters)
+
+# Plot Locations and Tour
+graphs.plot_tour(coordinates, city_tour = route, view = 'browser', size = 10)
+print('Total Distance: ', round(distance, 2))
+
+```
+
+3. Try it in **Colab** 
+
+- Using Lat Long ([ Colab Demo ](https://colab.research.google.com/drive/17jFw4z1R9gOoAfB-ZCZa6c-PukVKdrt3?usp=sharing))
+
+- 2-opt ([ Colab Demo ](https://colab.research.google.com/drive/1SLkM8r_VdlFCpNpm-2yTfr_ynSC5WIX9?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/167074)) 
+- 2.5-opt ([ Colab Demo ](https://colab.research.google.com/drive/17bJ-I26prnryAU8p-xf0l7R91cJzb85N?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10955-007-9382-1))     
+- 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))
+- 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))
+- 4-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/1igWrUMVSInzyeOdhPcGuMjyooZ6elvLY?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- 5-opt Stochastic ([ Colab Demo ](https://colab.research.google.com/drive/13vS5MCeFqb3F4ntxrw3iCsMbJTfEVyeo?usp=sharing)) ( [ Paper ](https://isd.ktu.lt/it2011//material/Proceedings/1_AI_5.pdf))
+- Ant Colony Optimization ([ Colab Demo ](https://colab.research.google.com/drive/1O2qogrjE4mZUZX3nsSxw43crumlBnd-D?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/4235.585892)) 
+- Adaptive Large Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1vShK5fe2xRCpMkurgd4PzmstGtn6d_LQ?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/25769321)) 
+- Bellman-Held-Karp Exact Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1HSnArk-v8PWY4dlCvT5zcSAnT1FJEDaf?usp=sharing)) ( [ Paper ](https://dl.acm.org/doi/10.1145/321105.321111))
+- Branch & Bound ([ Colab Demo ](https://colab.research.google.com/drive/1oDHrECSW3g4vBEsrO8T7qSHID4fxFiqs?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/j.disopt.2016.01.005))
+- BRKGA (Biased Random Key Genetic Algorithm) ([ Colab Demo ](https://colab.research.google.com/drive/1lwnpUBl1P1LIvzN1saLgEvnaKZRMWLHn?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/s10732-010-9143-1))
+- Brute Force ([ Colab Demo ](https://colab.research.google.com/drive/10vOkBz3Cv9UdHPlcBWkDmJO7EvDg96ar?usp=sharing)) ( [ Paper ](https://swarm.cs.pub.ro/~mbarbulescu/cripto/Understanding%20Cryptography%20by%20Christof%20Paar%20.pdf))
+- Cheapest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1QOg8FDvrFUgojwLXD2BBvEuB9Mu7q88a?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- Christofides Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1Wbm-YQ9TeH2OU-IjZzVdDkWGQILv4Pj_?usp=sharing)) ( [ Paper ](https://apps.dtic.mil/dtic/tr/fulltext/u2/a025602.pdf))
+- Clarke & Wright  (Savings Heuristic) ([ Colab Demo ](https://colab.research.google.com/drive/1XC2yoVe6wTsjt7u2fBaL3LcKUu42FG8r?usp=sharing)) ( [ Paper ](http://dx.doi.org/10.1287/opre.12.4.568))
+- Concave Hull Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1P96DerRe7CLyC9dQNr96nEkNHnxpGYY4?usp=sharing)) ( [ Paper ](http://repositorium.sdum.uminho.pt/bitstream/1822/6429/1/ConcaveHull_ACM_MYS.pdf))
+- Convex Hull Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1Wn2OWccZukOfMtJuGV9laklLTc8vjOFq?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/TSMC.1974.4309370))
+- Elastic Net ([ Colab Demo ](https://colab.research.google.com/drive/1F7IlkKdZ3_zQ_MkhknkIPHvE5RqJG7YC?usp=sharing)) ( [ Paper ](https://doi.org/10.1038/326689a0))
+- Extremal Optimization ([ Colab Demo ](https://colab.research.google.com/drive/1Y5YH0eYKjr1nj_IfhJXaILRDIXm-LWLs?usp=sharing)) ( [ Paper ](https://doi.org/10.1109/5992.881710))
+- Farthest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/13pWiLL_dO9Y1lvQO0zD50MXk4mD0Tn1W?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- Genetic Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1zO9rm-G6HOMeg1Q_ptMHJr48EpHcCAIS?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/BF02125403))  
+- GRASP (Greedy Randomized Adaptive Search Procedure) ([ Colab Demo ](https://colab.research.google.com/drive/1OnRyCc6C_QL6wr6-l5RlQI4eGbMdwuhS?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/BF01096763)) 
+- Greedy Karp-Steele Patching ([ Colab Demo ](https://colab.research.google.com/drive/1to3u45QWWQK8REj1_YiF5rUqUqNjB18q?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0377-2217(99)00468-3))
+- Guided Search ([ Colab Demo ](https://colab.research.google.com/drive/1uT9mlDoo37Ni7hqziGNELEGQCGBKQ83o?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0377-2217(98)00099-X)) 
+- Hopfield Network ([ Colab Demo ](https://colab.research.google.com/drive/1Io20FFsndsRT3Bc1nimLBcpH5WtEt7Pe?usp=sharing)) ( [ Paper ](https://doi.org/10.1515/dema-1996-0126)) 
+- Iterated Search ([ Colab Demo ](https://colab.research.google.com/drive/1U3sPpknulwsCUQq9mK7Ywfb8ap2GIXZv?usp=sharing)) ( [ Paper ](https://doi.org/10.1063/1.36219)) 
+- Karp-Steele Patching ([ Colab Demo ](https://colab.research.google.com/drive/12xLLDNIk6OOSNQXqYSYtdwhupZ9Kt5xb?usp=sharing)) ( [ Paper ](https://doi.org/10.1137/0208045))
+- Large Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1t4cafHRRzOLN4xth96jE-2qHoPQOLsn5?usp=sharing)) ( [ Paper ](https://doi.org/10.1007/3-540-49481-2_30))
+- Multifragment Heuristic ([ Colab Demo ](https://colab.research.google.com/drive/1YNHVjS6P35bAnqGZyP7ERNrTnG9tNuhF?usp=sharing)) ( [ Paper ](https://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=08D176AEFA57EF1941645F2B31DF1686?doi=10.1.1.92.1635&rep=rep1&type=pdf))
+- Nearest Insertion ([ Colab Demo ](https://colab.research.google.com/drive/1R4mz604EG-unKktu8ON_Hpoywi3OIRHK?usp=sharing)) ( [ Paper ](https://disco.ethz.ch/courses/fs16/podc/readingAssignment/1.pdf))
+- 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))
+- 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))
+- Scatter Search ([ Colab Demo ](https://colab.research.google.com/drive/115Ql6KegvOjlNUUfsbY4fA8Vab-db26N?usp=sharing)) ( [ Paper ](https://doi.org/10.1111/j.1540-5915.1977.tb01074.x)) 
+- Simulated Annealing ([ Colab Demo ](https://colab.research.google.com/drive/10Th0yLaAeSqp9FhYB0H00e4sXTbg7Jp2?usp=sharing)) ( [ Paper ](https://www.jstor.org/stable/1690046))
+- SOM (Self Organizing Maps) ([ Colab Demo ](https://colab.research.google.com/drive/1-ZwSFnXf1_kCeY_p3SC3N21T8QeSWsg6?usp=sharing)) ( [ Paper ](https://arxiv.org/pdf/2201.07208.pdf))
+- 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))
+- 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))
+- Truncated Branch & Bound ([ Colab Demo ](https://colab.research.google.com/drive/16m72PrBZN8mWMCer12dgsStcNGs4DVdQ?usp=sharing)) ( [ Paper ](https://research.ijcaonline.org/volume65/number5/pxc3885866.pdf)) 
+- Twice-Around the Tree Algorithm ([ Colab Demo ](https://colab.research.google.com/drive/1tf5tc5DxvEUc89JaaFgzmK1TtD1e4fkc?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/0196-6774(84)90029-4)) 
+- Variable Neighborhood Search ([ Colab Demo ](https://colab.research.google.com/drive/1yMWjYuurzpcijsCFDTA76fAwJmSaDkZq?usp=sharing)) ( [ Paper ](https://doi.org/10.1016/S0305-0548(97)00031-2)) 
+
+# Single Objective Optimization
+For Single Objective Optimization try [pyMetaheuristic](https://github.com/Valdecy/pyMetaheuristic)
+
+# Multiobjective Optimization or Many Objectives Optimization
+For Multiobjective Optimization or Many Objectives Optimization try [pyMultiobjective](https://github.com/Valdecy/pyMultiobjective)

pycombinatorial-1.8.2/pyCombinatorial/algorithm/__init__.py

@@ -0,0 +1,52 @@
+from .aco import ant_colony_optimization 
+from .alns import adaptive_large_neighborhood_search
+from .bb import branch_and_bound
+from .bf import brute_force_analysis
+from .bhk import bellman_held_karp_exact_algorithm
+from .brkga import biased_random_key_genetic_algorithm
+from .christofides import christofides_algorithm
+from .conc_hull import concave_hull_algorithm
+from .conv_hull import convex_hull_algorithm
+from .cw import clarke_wright_savings
+from .eln import elastic_net_tsp
+from .eo import extremal_optimization
+from .ga import genetic_algorithm
+from .grasp import greedy_randomized_adaptive_search_procedure
+from .gksp import greedy_karp_steele_patching
+from .hpn import hopfield_network_tsp
+from .ins_c import cheapest_insertion
+from .ins_f import farthest_insertion
+from .ins_n import nearest_insertion
+from .ins_r import random_insertion
+from .ksp import karp_steele_patching
+from .lns import large_neighborhood_search
+from .mf import  multifragment_heuristic
+from .nn import nearest_neighbour
+from .opt_2 import local_search_2_opt
+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_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
+from .opt_4s import local_search_4_opt_stochastic
+from .opt_5s import local_search_5_opt_stochastic
+from .rt import random_tour
+from .rl_ql import q_learning
+from .rl_double_ql import double_q_learning
+from .rl_sarsa import sarsa
+from .s_gui import guided_search
+from .s_itr import iterated_search
+from .s_sct import scatter_search
+from .s_shc import stochastic_hill_climbing
+from .s_tabu import tabu_search
+from .s_vns import variable_neighborhood_search
+from .sa import simulated_annealing_tsp
+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 .swp import sweep
+from .tat import tat_algorithm
+from .tbb import truncated_branch_and_bound

pycombinatorial-1.8.2/pyCombinatorial/algorithm/aco.py

@@ -0,0 +1,117 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: pyCombinatorial - Ant Colony Optimization
+ 
+# GitHub Repository: <https://github.com/Valdecy> 
+
+############################################################################
+
+# Required Libraries
+import copy
+import numpy as np
+
+############################################################################
+
+# Helper: Calculate Path Distance
+def calculate_distance(distance_matrix, city_list):
+    path_distance = 0
+    for i in range(0, len(city_list) - 1):
+        path_distance = path_distance + distance_matrix[city_list[i]-1, city_list[i+1]-1]
+    path_distance = path_distance + distance_matrix[city_list[-1]-1, city_list[0]-1]
+    return path_distance
+
+# Helper: Perform Local Search (Optional)
+def local_search_2_opt(distance_matrix, city_tour, recursive_seeding = -1):
+    city_list, best_path_distance = city_tour[0], city_tour[1]
+    improved                      = True
+    while (improved == True):
+        improved = False
+        for i in range(1, len(city_list) - 2):
+            for j in range(i + 1, len(city_list) - 1):
+                new_city_list      = city_list[:]
+                new_city_list[i:j] = city_list[i:j][::-1]
+                new_distance       = calculate_distance(distance_matrix, new_city_list)
+                if (new_distance < best_path_distance):
+                    best_path_distance = new_distance
+                    city_list          = new_city_list
+                    improved           = True
+    return city_list, best_path_distance
+
+############################################################################
+
+# Helper: Calculate Attractiveness
+def attractiveness(distance_matrix):
+    h = 1 / (distance_matrix + 1e-10) 
+    np.fill_diagonal(h, 0)
+    return h
+
+# Helper: Update Pheromone Matrix
+def update_thau(distance_matrix, thau, city_list):
+    path_distance = 0
+    for i in range(len(city_list) - 1):
+        path_distance = path_distance + distance_matrix[city_list[i]-1, city_list[i+1]-1]
+    path_distance = path_distance + distance_matrix[city_list[-1]-1, city_list[0]-1]  
+    for i in range(len(city_list) - 1):
+        thau[city_list[ i ]-1, city_list[i+1]-1] = thau[city_list[ i ]-1, city_list[i+1]-1] + 1 / path_distance
+        thau[city_list[i+1]-1, city_list[ i ]-1] = thau[city_list[i+1]-1, city_list[ i ]-1] + 1 / path_distance
+    thau[city_list[-1]-1, city_list[ 0]-1] = thau[city_list[-1]-1, city_list[ 0]-1] + 1 / path_distance
+    thau[city_list[ 0]-1, city_list[-1]-1] = thau[city_list[ 0]-1, city_list[-1]-1] + 1 / path_distance
+    return thau
+
+# Helper: Generate Ant Paths
+def ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search):
+    best_path_distance = float('inf')
+    best_city_list     = None
+    for _ in range(0, ants):
+        city_list = [np.random.choice(full_list)]
+        while (len(city_list) < len(full_list)):
+            current_city  = city_list[-1]
+            probabilities = []
+            for next_city in full_list:
+                if (next_city not in city_list):
+                    p = (thau[current_city-1, next_city-1] ** alpha) * (h[current_city-1, next_city-1] ** beta)
+                    probabilities.append(p)
+                else:
+                    probabilities.append(0)
+            probabilities = np.array(probabilities) / np.sum(probabilities)
+            next_city     = np.random.choice(full_list, p = probabilities)
+            city_list.append(next_city)
+        path_distance = calculate_distance(distance_matrix, city_list)
+        if (path_distance < best_path_distance):
+            best_city_list     = copy.deepcopy(city_list)
+            best_path_distance = path_distance
+            
+    if (local_search == True):
+        best_city_list, best_path_distance = local_search_2_opt(distance_matrix, city_tour = [best_city_list, best_path_distance])
+    thau = update_thau(distance_matrix, thau, city_list = best_city_list)
+    return best_city_list, best_path_distance, thau
+
+############################################################################
+
+# ACO Function
+def ant_colony_optimization(distance_matrix, ants = 5, iterations = 50, alpha = 1, beta = 2, decay = 0.05, local_search = True, verbose = True):
+    count      = 0
+    best_route = []
+    full_list  = list(range(1, distance_matrix.shape[0] + 1))
+    distance   = np.sum(distance_matrix.sum())
+    h          = attractiveness(distance_matrix)
+    thau       = np.ones((distance_matrix.shape[0], distance_matrix.shape[0]))
+    while (count <= iterations):
+        if (verbose == True and count > 0):
+            print(f'Iteration = {count}, Distance = {round(best_route[1], 2)}')
+        city_list, path_distance, thau = ants_path(distance_matrix, h, thau, alpha, beta, full_list, ants, local_search)
+        thau                           = thau*(1 - decay)
+        if (distance > path_distance):
+            best_route = copy.deepcopy([city_list])
+            best_route.append(path_distance)
+            distance   = best_route[1]
+        count = count + 1
+    init_city = best_route[0][0]
+    best_route[0].append(init_city)
+    return best_route[0], best_route[1]
+
+############################################################################
+

pycombinatorial-1.8.2/pyCombinatorial/algorithm/alns.py

@@ -0,0 +1,148 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: pyCombinatorial - ALNS - Adaptive Large Neighborhood Search 
+ 
+# GitHub Repository: <https://github.com/Valdecy> 
+
+############################################################################
+
+# Required Libraries
+import copy
+import numpy as np
+import random
+
+############################################################################
+
+# Function: Euclidean Distance
+def euclidean_distance(point1, point2):
+    return np.sqrt((point1[0] - point2[0])**2 + (point1[1] - point2[1])**2)
+
+# 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: Tour Distance
+def distance_point(distance_matrix, city_tour):
+    distance = 0
+    for i in range(0, len(city_tour) - 1):
+        distance = distance + distance_matrix[city_tour[i]][city_tour[i + 1]]
+    distance = distance + distance_matrix[city_tour[-1]][city_tour[0]]
+    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
+    if (verbose == True):
+        print('')
+        print('Local Search')
+        print('')
+    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: Removal
+def removal_operators():
+    def random_removal(city_tour, num_removals):
+        removed = set()
+        while (len(removed) < num_removals):
+            removed.add(random.choice(city_tour[1:]))
+        return list(removed)
+    return [random_removal]
+
+# Function: Insertion
+def insertion_operators():
+    def cheapest_insertion(removed_nodes, city_tour, distance_matrix):
+        for node in removed_nodes:
+            best_insertion_cost  = float('inf')
+            best_insertion_index = -1
+            for i in range(1, len(city_tour) + 1):
+                insertion_cost = (distance_matrix[city_tour[i - 1]][node] + distance_matrix[node][city_tour[i % len(city_tour)]] - distance_matrix[city_tour[i - 1]][city_tour[i % len(city_tour)]])
+                if (insertion_cost < best_insertion_cost):
+                    best_insertion_cost  = insertion_cost
+                    best_insertion_index = i
+            city_tour.insert(best_insertion_index, node)
+        return city_tour
+    return [cheapest_insertion]
+
+############################################################################
+
+# Function: Adaptive Large Neighborhood Search
+def adaptive_large_neighborhood_search(distance_matrix, iterations = 100, removal_fraction = 0.2, rho = 0.1, local_search = True, verbose = True):
+    initial_tour       = list(range(0, distance_matrix.shape[0]))
+    random.shuffle(initial_tour)
+    route              = initial_tour.copy()
+    distance           = distance_point(distance_matrix, route)
+    removal_ops        = removal_operators()
+    insertion_ops      = insertion_operators()
+    weights_removal    = [1.0] * len(removal_ops)
+    weights_insertion  = [1.0] * len(insertion_ops)
+    count              = 0
+    while (count <= iterations):
+        if (verbose == True and count > 0):
+            print('Iteration = ', count, 'Distance = ', round(distance, 2))     
+        city_tour     = route.copy()
+        removal_op    = random.choices(removal_ops,   weights = weights_removal)[0]
+        insertion_op  = random.choices(insertion_ops, weights = weights_insertion)[0]
+        num_removals  = int(removal_fraction * distance_matrix.shape[0])
+        removed_nodes = removal_op(city_tour, num_removals)
+        for node in removed_nodes:
+            city_tour.remove(node)
+        new_tour          = insertion_op(removed_nodes, city_tour, distance_matrix)
+        new_tour_distance = distance_point(distance_matrix, new_tour)
+        if (new_tour_distance < distance):
+            route                                                = new_tour
+            distance                                             = new_tour_distance
+            weights_removal[removal_ops.index(removal_op)]       = weights_removal[removal_ops.index(removal_op)]       * (1 + rho)
+            weights_insertion[insertion_ops.index(insertion_op)] = weights_insertion[insertion_ops.index(insertion_op)] * (1 + rho)
+        else:
+            weights_removal[removal_ops.index(removal_op)]       = weights_removal[removal_ops.index(removal_op)]       * (1 - rho)
+            weights_insertion[insertion_ops.index(insertion_op)] = weights_insertion[insertion_ops.index(insertion_op)] * (1 - rho)
+        total_weight_removal   = sum(weights_removal)
+        total_weight_insertion = sum(weights_insertion)
+        weights_removal        = [w / total_weight_removal   for w in weights_removal]
+        weights_insertion      = [w / total_weight_insertion for w in weights_insertion]
+        count                  = count + 1
+    route = route + [route[0]]
+    route = [item + 1 for item in route]
+    if (local_search == True):
+        route, distance = local_search_2_opt(distance_matrix, [route, distance], -1, verbose)
+    return route, distance
+
+############################################################################