pycombinatorial 1.8.2__py3-none-any.whl

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/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/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
+
+############################################################################

pyCombinatorial/algorithm/bb.py

@@ -0,0 +1,81 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: Branch & Bound
+ 
+# GitHub Repository: <https://github.com/Valdecy>
+
+############################################################################
+
+# Required Libraries
+import numpy as np
+
+############################################################################
+
+# Function: First Minimum Distance
+def min_1(distance_matrix, i): 
+    vector = distance_matrix[i,:].tolist()
+    idx    = np.argsort(vector)
+    m1     = vector[idx[1]]
+    return m1
+
+# Function: Second Minimum Distance
+def min_2(distance_matrix, i): 
+    vector = distance_matrix[i,:].tolist()
+    idx    = np.argsort(vector)
+    m2     = vector[idx[2]]
+    return m2 
+
+############################################################################
+
+# Function: Branch
+def explore_path(route, distance, distance_matrix, bound, weight, level, path, visited):  
+    if (level == distance_matrix.shape[0]): 
+        if (distance_matrix[path[level - 1], path[0]] != 0): 
+            dist = weight + distance_matrix[path[level - 1], path[0]] 
+            if (dist < distance): 
+                distance                             = dist 
+                route[:distance_matrix.shape[0] + 1] = path[:]
+                route[distance_matrix.shape[0]]      = path[0]
+        return route, distance, bound, weight, path, visited
+    for i in range(0, distance_matrix.shape[0]): 
+        if (distance_matrix[path[level-1], i] != 0 and visited[i] == False): 
+            temp   = bound 
+            weight = weight + distance_matrix[path[level - 1], i] 
+            if (level == 1): 
+                bound = bound - ((min_1(distance_matrix, path[level - 1]) + min_1(distance_matrix, i)) / 2) 
+            else: 
+                bound = bound - ((min_2(distance_matrix, path[level - 1]) + min_1(distance_matrix, i)) / 2)  
+            if (bound + weight < distance): 
+                path[level] = i 
+                visited[i]  = True
+                route, distance, bound, weight, path, visited = explore_path(route, distance, distance_matrix, bound, weight, level + 1, path, visited) 
+            weight  = weight - distance_matrix[path[level - 1], i] 
+            bound   = temp
+            visited = [False] * len(visited) 
+            for j in range(level): 
+                if (path[j] != -1): 
+                    visited[path[j]] = True
+    return route, distance, bound, weight, path, visited
+
+############################################################################
+
+# Function: Branch and Bound (Adapted from: https://www.geeksforgeeks.org/traveling-salesman-problem-using-branch-and-bound-2/)
+def branch_and_bound(distance_matrix): 
+    distance   = float('+inf')
+    path       = [  -1   ] * (distance_matrix.shape[0] + 1) 
+    path[0]    = 0
+    visited    = [ False ] *  distance_matrix.shape[0]
+    visited[0] = True
+    route      = [ None  ] * (distance_matrix.shape[0] + 1)
+    weight     = 0
+    level      = 1
+    bound      = np.ceil(sum([ (min_1(distance_matrix, i) + min_2(distance_matrix, i)) for i in range(0, distance_matrix.shape[0])])/2) 
+    route, distance, bound, weight, path, visited = explore_path(route, distance, distance_matrix, bound, weight, level, path, visited) 
+    route      = [item+1 for item in route]
+    return route, distance
+
+############################################################################
+

pyCombinatorial/algorithm/bf.py

@@ -0,0 +1,41 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: Brute Force
+ 
+# GitHub Repository: <https://github.com/Valdecy>
+
+############################################################################
+
+# Required Libraries
+import itertools
+
+############################################################################
+
+# 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: BF
+def brute_force_analysis(distance_matrix):
+    n          = distance_matrix.shape[1]
+    candidates = []
+    for p in itertools.permutations(range(2, n+1)):
+        if (p <= p[::-1]):
+            candidates.append(list(p))
+    routes    = [ [1] + item + [1] for item in candidates ]
+    distances = [ distance_calc(distance_matrix, [item, 1]) for item in routes ]
+    idx       = distances.index(min(distances))
+    route     = routes[idx]
+    distance  = distances[idx]
+    return route, distance
+
+############################################################################

pyCombinatorial/algorithm/bhk.py

@@ -0,0 +1,54 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: Bellman-Held-Karp Exact Algorithm
+ 
+# GitHub Repository: <https://github.com/Valdecy>
+
+############################################################################
+
+# Required Libraries
+import itertools
+
+############################################################################
+
+# Function: Bellman-Held-Karp Exact Algorithm  (adapted from https://github.com/CarlEkerot/held-karp)
+def bellman_held_karp_exact_algorithm(distance_matrix, verbose = True):
+    n = distance_matrix.shape[0]
+    C = {}
+    for k in range(1, n):
+        C[(2**k, k)] = (distance_matrix[0, k], 0)
+    for j in range(2, n):
+        combinations = list(itertools.combinations(range(1, n), j))
+        for i in combinations:
+            bits = 0
+            for bit in i:
+                bits = bits + 2**bit
+            for k in i:
+                prev = bits - 2**k
+                res = []
+                for m in i:
+                    if( m == 0 or m == k):
+                        continue
+                    res.append((C[(prev, m)][0] + distance_matrix[m, k], m))
+                C[(bits, k)] = min(res)
+        if (verbose == True):
+            print('Iteration: ', j, ' of ', n-1, ' Analysed Combinations: ', len(combinations))
+    bits = (2**n - 1) - 1
+    res  = []
+    for k in range(1, n):
+        res.append((C[(bits, k)][0] + distance_matrix[k, 0], k))
+    distance, parent = min(res)
+    route            = []
+    for i in range(n - 1):
+        route.append(parent)
+        bits_     = bits - 2**parent
+        _, parent = C[(bits, parent)]
+        bits      = bits_
+    route = [0] + route + [0]
+    route = [item + 1 for item in route]
+    return route, distance
+
+############################################################################

pyCombinatorial/algorithm/brkga.py

@@ -0,0 +1,156 @@
+############################################################################
+
+# Created by: Prof. Valdecy Pereira, D.Sc.
+# UFF - Universidade Federal Fluminense (Brazil)
+# email:  valdecy.pereira@gmail.com
+# Lesson: BRKGA (Biased Random Key Genetic Algorithm)
+ 
+# GitHub Repository: <https://github.com/Valdecy>
+
+############################################################################
+
+# Required Libraries
+import copy
+import numpy  as np
+import random
+import os
+
+############################################################################
+
+# Function: Encoder
+def encoder(seed):
+    route      = seed[0][:-1]
+    route      = [item - 1 for item in route]
+    individual = [item - 1 for item in route]
+    count      = 0
+    for item in route:
+        individual[item] = count*(1/len(route))
+        count            = count + 1
+    return individual
+
+# Function: Decoder
+def decoder(individual, distance_matrix, cost_only = False):
+    dec      = sorted(range(0, len(individual)), key = individual.__getitem__)
+    dec      = [item + 1 for item in dec]
+    route    = dec + [dec[0]]
+    distance = distance_calc(distance_matrix, [route, 1])
+    if (cost_only == True):
+        return distance
+    else:
+        return route, distance
+
+############################################################################
+
+# 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: Elite Local Search
+def elite_ls(population, distance_matrix, elite):
+    print('Preparing Elite...')
+    for i in range(0, elite):
+        idx             = random.sample(range(0, len(population) - 1), 1)[0]
+        r, d            = decoder(population[idx], distance_matrix, cost_only = False)
+        seed            = [r, d]
+        r, d            = local_search_2_opt(distance_matrix, seed, recursive_seeding = -1, verbose = False)
+        seed            = [r, d]
+        population[idx] = encoder(seed)
+    return population
+
+############################################################################
+
+# Function: Initialize Variables
+def initial_population(population_size, min_values, max_values):
+    population = np.zeros((population_size, len(min_values)))
+    for i in range(0, population_size):
+        for j in range(0, len(min_values)):
+             population[i,j] = random.uniform(min_values[j], max_values[j]) 
+    return population
+
+# Function: Offspring
+def breeding(population, elite, bias):
+    offspring = np.copy(population)
+    for i in range (elite, offspring.shape[0]):
+        parent_1 = random.sample(range(0, elite), 1)[0]
+        parent_2 = random.sample(range(elite, len(population) - 1), 1)[0]
+        for j in range(0, offspring.shape[1]):
+            rand = int.from_bytes(os.urandom(8), byteorder = 'big') / ((1 << 64) - 1)                                
+            if (rand <= bias):
+                offspring[i,j] = population[parent_1, j]
+            else:
+                offspring[i,j] = population[parent_2, j]
+    return offspring
+ 
+# Function: Mutation
+def mutation(population, mutants, min_values, max_values):
+    mutated = initial_population(mutants, min_values, max_values)
+    population[population.shape[0]-mutated.shape[0]:, :] = mutated
+    return population
+
+############################################################################
+
+# BRKGA Function
+def biased_random_key_genetic_algorithm(distance_matrix, population_size = 25, elite = 1, bias = 0.5, mutants = 10, generations = 50000, verbose = True): 
+    count      = 0
+    min_values = [0]*distance_matrix.shape[0]
+    max_values = [1]*distance_matrix.shape[0]
+    population = initial_population(population_size, min_values, max_values)
+    population = elite_ls(population, distance_matrix, 1)
+    cost       = [decoder(population[i,:].tolist(), distance_matrix, cost_only = True) for i in range(0, population.shape[0])]   
+    idx        = sorted(range(0, len(cost)), key = cost.__getitem__)
+    cost       = [cost[i] for i in idx]
+    population = population[idx,:]
+    elite_ind  = [population[0,:], cost[0]]
+    while (count <= generations):  
+        if (verbose == True):
+            print('Generation = ', count, 'Distance = ', round(elite_ind[1], 2))  
+        offspring  = breeding(population, elite, bias) 
+        cost       = [decoder(offspring[i,:].tolist(), distance_matrix, cost_only = True) for i in range(0, offspring.shape[0])] 
+        idx        = sorted(range(0, len(cost)), key = cost.__getitem__)
+        cost       = [cost[i] for i in idx]
+        population = offspring[idx,:]
+        population = mutation(population, mutants, min_values, max_values)
+        if(elite_ind[1] > cost[0]):
+            elite_ind = [population[0,:], cost[0]]
+        count = count + 1 
+    route, distance = decoder(elite_ind[0].tolist(), distance_matrix, cost_only = False)
+    return route, distance
+
+############################################################################