Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

هل يمكنك اعادة كتابة كود بايثون التالي بالماتلاب مع مراعاة الفهارس في ماتلاب تبدأ ب 1…

  1. User

    هل يمكنك اعادة كتابة كود بايثون التالي بالماتلاب مع مراعاة الفهارس في ماتلاب تبدأ ب 1 بدل 0 #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Thu Sep 13 13:23:01 2018

    @author: krupa """

    =============================================================================

    INITIAL ENCODING GA

    1. For each particle record:

    a. Route list [[cust1, cust20,...]....[cust7,cust80...]]

    b Distance list [Dr1, .......Drk]

    c distance

    d num_routes

    2. record fitness table : distance, num_routes, fitness function value

    =============================================================================

    #%%

    import os import math import multiprocessing import numpy as np import pandas as pd import random from initial_pop_generation import initial_population from initial_routing_phase2 import initial_routing_phase2 #%% #Paths cwd = os.getcwd() customer_path = cwd +'/solomon25_csv/customers' dataInfo_path = cwd +'/solomon25_csv/data_info' distanceMatrix_path = cwd +'/solomon25_csv/distance_matrix' initial_path = cwd + '/initial'

    #%%

    LIST FILE NAMES

    r1_list_datasets = [] c1_list_datasets = [] rc1_list_datasets = [] r2_list_datasets = [] c2_list_datasets = [] rc2_list_datasets = []

    for i in range(101,110): c1_list_datasets.append('c'+'%s' %(i) )

    for i in range(101,113): r1_list_datasets.append('r'+'%s' %(i) )

    for i in range(101,109): rc1_list_datasets.append('rc'+'%s' %(i) )

    for i in range(201,209): c2_list_datasets.append('c'+'%s' %(i) )

    for i in range(201,212): r2_list_datasets.append('r'+'%s' %(i) )

    for i in range(201,209): rc2_list_datasets.append('rc'+'%s' %(i) )

    dataset_list = c1_list_datasets + r1_list_datasets + rc1_list_datasets + c2_list_datasets + r2_list_datasets + rc2_list_datasets

    r1_list_dataInfo = [] c1_list_dataInfo = [] rc1_list_dataInfo = [] r2_list_dataInfo = [] c2_list_dataInfo = [] rc2_list_dataInfo = []

    for i in range(101,110): c1_list_dataInfo.append('c'+'%s' %(i) + 'dataInfo.csv')

    for i in range(101,113): r1_list_dataInfo.append('r'+'%s' %(i) + 'dataInfo.csv')

    for i in range(101,109): rc1_list_dataInfo.append('rc'+'%s' %(i) + 'dataInfo.csv')

    for i in range(201,209): c2_list_dataInfo.append('c'+'%s' %(i) + 'dataInfo.csv')

    for i in range(201,212): r2_list_dataInfo.append('r'+'%s' %(i) + 'dataInfo.csv')

    for i in range(201,209): rc2_list_dataInfo.append('rc'+'%s' %(i) + 'dataInfo.csv')

    dataInfo_files_list = c1_list_dataInfo + r1_list_dataInfo + rc1_list_dataInfo + c2_list_dataInfo + r2_list_dataInfo + rc2_list_dataInfo

    #customers r1_list_customers = [] c1_list_customers = [] rc1_list_customers = [] r2_list_customers = [] c2_list_customers = [] rc2_list_customers = []

    for i in range(101,110): c1_list_customers.append('c'+'%s' %(i) + 'customers.csv')

    for i in range(101,113): r1_list_customers.append('r'+'%s' %(i) + 'customers.csv')

    for i in range(101,109): rc1_list_customers.append('rc'+'%s' %(i) + 'customers.csv')

    for i in range(201,209): c2_list_customers.append('c'+'%s' %(i) + 'customers.csv')

    for i in range(201,212): r2_list_customers.append('r'+'%s' %(i) + 'customers.csv')

    for i in range(201,209): rc2_list_customers.append('rc'+'%s' %(i) + 'customers.csv')

    customers_files_list = c1_list_customers + r1_list_customers + rc1_list_customers + c2_list_customers + r2_list_customers + rc2_list_customers

    #distance matrix #customers r1_list_distanceMatrix = [] c1_list_distanceMatrix = [] rc1_list_distanceMatrix = [] r2_list_distanceMatrix = [] c2_list_distanceMatrix = [] rc2_list_distanceMatrix = []

    for i in range(101,110): c1_list_distanceMatrix.append('c'+'%s' %(i) + 'distanceMatrix.csv')

    for i in range(101,113): r1_list_distanceMatrix.append('r'+'%s' %(i) + 'distanceMatrix.csv')

    for i in range(101,109): rc1_list_distanceMatrix.append('rc'+'%s' %(i) + 'distanceMatrix.csv')

    for i in range(201,209): c2_list_distanceMatrix.append('c'+'%s' %(i) + 'distanceMatrix.csv')

    for i in range(201,212): r2_list_distanceMatrix.append('r'+'%s' %(i) + 'distanceMatrix.csv')

    for i in range(201,209): rc2_list_distanceMatrix.append('rc'+'%s' %(i) + 'distanceMatrix.csv')

    distanceMatrix_files_list = c1_list_distanceMatrix + r1_list_distanceMatrix + rc1_list_distanceMatrix + c2_list_distanceMatrix + r2_list_distanceMatrix + rc2_list_distanceMatrix

    #write out files

    r1_list_initialPop = [] c1_list_initialPop = [] rc1_list_initialPop = [] r2_list_initialPop = [] c2_list_initialPop = [] rc2_list_initialPop = []

    for i in range(101,110): c1_list_initialPop.append('c'+'%s' %(i) + 'initialPop.npy')

    for i in range(101,113): r1_list_initialPop.append('r'+'%s' %(i) + 'initialPop.npy')

    for i in range(101,109): rc1_list_initialPop.append('rc'+'%s' %(i) + 'initialPop.npy')

    for i in range(201,209): c2_list_initialPop.append('c'+'%s' %(i) + 'initialPop.npy')

    for i in range(201,212): r2_list_initialPop.append('r'+'%s' %(i) + 'initialPop.npy')

    for i in range(201,209): rc2_list_initialPop.append('rc'+'%s' %(i) + 'initialPop.npy')

    initialPop_files_list = c1_list_initialPop + r1_list_initialPop + rc1_list_initialPop + c2_list_initialPop + r2_list_initialPop + rc2_list_initialPop

    r1_list_initialDistance = [] c1_list_initialDistance = [] rc1_list_initialDistance = [] r2_list_initialDistance = [] c2_list_initialDistance = [] rc2_list_initialDistance = []

    for i in range(101,110): c1_list_initialDistance.append('c'+'%s' %(i) + 'initialDistance.npy')

    for i in range(101,113): r1_list_initialDistance.append('r'+'%s' %(i) + 'initialDistance.npy')

    for i in range(101,109): rc1_list_initialDistance.append('rc'+'%s' %(i) + 'initialDistance.npy')

    for i in range(201,209): c2_list_initialDistance.append('c'+'%s' %(i) + 'initialDistance.npy')

    for i in range(201,212): r2_list_initialDistance.append('r'+'%s' %(i) + 'initialDistance.npy')

    for i in range(201,209): rc2_list_initialDistance.append('rc'+'%s' %(i) + 'initialDistance.npy')

    initialDistance_files_list = c1_list_initialDistance + r1_list_initialDistance + rc1_list_initialDistance + c2_list_initialDistance + r2_list_initialDistance + rc2_list_initialDistance

    r1_list_initialResults = [] c1_list_initialResults = [] rc1_list_initialResults = [] r2_list_initialResults = [] c2_list_initialResults = [] rc2_list_initialResults = []

    for i in range(101,110): c1_list_initialResults.append('c'+'%s' %(i) + 'initialResults.csv')

    for i in range(101,113): r1_list_initialResults.append('r'+'%s' %(i) + 'initialResults.csv')

    for i in range(101,109): rc1_list_initialResults.append('rc'+'%s' %(i) + 'initialResults.csv')

    for i in range(201,209): c2_list_initialResults.append('c'+'%s' %(i) + 'initialResults.csv')

    for i in range(201,212): r2_list_initialResults.append('r'+'%s' %(i) + 'initialResults.csv')

    for i in range(201,209): rc2_list_initialResults.append('rc'+'%s' %(i) + 'initialResults.csv')

    initialResults_files_list = c1_list_initialResults + r1_list_initialResults + rc1_list_initialResults + c2_list_initialResults + r2_list_initialResults + rc2_list_initialResults

    #%% #EXPERIMENTAL VARIABLES num_experiments = 30 num_cores = multiprocessing.cpu_count() #number of cores to use

    #GLOBAL VARIABLES: N = 300#population size greedy_percent = 0.10#percentage to be greedily initialised random_percent = 0.90#percentage to be randomily initialised alpha = 100 beta = 0.001

    #%% i = 0 experiment = 0 #%% #FOR EACH DATASET for i in range(len(dataset_list)): dataSet = dataset_list[i] #READ IN DATA PERTAINING TO THE DATASET customer_file = os.path.join(customer_path, customers_files_list[i]) dataInfo_file = os.path.join(dataInfo_path, dataInfo_files_list[i]) distanceMatrix_file = os.path.join(distanceMatrix_path, distanceMatrix_files_list[i])

    df_customers = pd.read_csv(customer_file)
    df_distance_matrix = pd.read_csv(distanceMatrix_file)
    df_dataInfo = pd.read_csv(dataInfo_file)
    
    num_customers = df_customers.shape[0]
    num_customers_depot = num_customers + 1
    df_customers.index = range(1,num_customers_depot)
    
    number_random_chromosomes = math.floor(N*random_percent)-1
    number_nearest_nn_chromosomes = 1
    number_greedy_chromosomes = N-number_random_chromosomes-1#int(N*greedy_percent)
    
    #CONVERT TO NUMPY ARRAY
    #distance array
    arr_distance_matrix = np.asarray(df_distance_matrix)
    #greedy radius 
    dataset_radius = (np.nanmax(arr_distance_matrix) - np.nanmin(arr_distance_matrix))/2
    #customer array
    

    customer_index = 0

    demand = 1

    service_time = 2

    ready_time = 3

    due_time = 4

    complete_time = 5

    arr_customers = np.empty((num_customers, 6))
    arr_customers[:,0] = np.arange(1, num_customers_depot) 
    arr_customers[:,1] = df_customers.loc[:,'demand']
    arr_customers[:,2] = df_customers.loc[:,'serviceTime']
    arr_customers[:,3] = df_customers.loc[:,'readyTime']
    arr_customers[:,4] = df_customers.loc[:,'dueTime']
    arr_customers[:,5] = df_customers.loc[:,'completeTime']
    

    fleet max details

    total_time = df_dataInfo.loc[0, 'fleet_max_working_time']
    total_capacity = df_dataInfo.loc[0, 'fleet_capacity']
    
    all_customers_list = list(range(1,num_customers_depot))
    

    FOR EACH EXPERIMENT

    for experiment in range(num_experiments):
    

    READ OUT FILES

        initial_pop_output_file = os.path.join(initial_path + '/%s/experiment%d' %(dataSet,experiment), initialPop_files_list[i])
        initial_pop_distance_output_file = os.path.join(initial_path + '/%s/experiment%d' %(dataSet,experiment), initialDistance_files_list[i])
        initial_result_output_file = os.path.join(initial_path + '/%s/experiment%d' %(dataSet,experiment), initialResults_files_list[i])
        
        radius = dataset_radius*(random.uniform(0.5,1)) #assumed NOTE: NOT STATED IN PAPER
        #phase1
        pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance = initial_population(N, num_cores, number_random_chromosomes, number_greedy_chromosomes, number_nearest_nn_chromosomes, num_customers, arr_customers, arr_distance_matrix,  total_capacity, total_time, all_customers_list, radius)
        #phase2
    

    pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance = initial_population_phase2(N, num_cores, arr_customers, arr_distance_matrix, total_capacity, total_time, pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance, alpha, beta)

        pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_pop_results = initial_routing_phase2(num_cores,N, alpha, beta, pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_distance_matrix, arr_customers, total_time, total_capacity)
        
        np.save(initial_pop_output_file, pop_chromosome_routeList_array)
        np.save(initial_pop_distance_output_file, pop_chromosome_distanceList_array)
        
        df_initial_results = pd.DataFrame(np.zeros((N, 3)))
        df_initial_results.columns = ['num_vehicles', 'distance', 'fitness']
        df_initial_results.loc[:, 'num_vehicles'] = pop_num_routes
        df_initial_results.loc[:, 'distance'] = pop_total_distance
        #METRIC: GA PAPER alpha*numV + beta*distance
        df_initial_results.loc[:,'fitness'] = (alpha*pop_num_routes)+(beta*pop_total_distance)
        
        df_initial_results.to_csv(initial_result_output_file, index=False)
        
        print('experiment: ', experiment)
    print('Dataset:', dataSet)
        
    
    
    

    #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Fri Sep 14 13:32:53 2018

    @author: krupa """

    =============================================================================

    GENERATE THE INITIAL POPULATION ROUTES USING THE 3 SCHEMES;

    1. RANDOM

    2. GREEDY

    =============================================================================

    from initial_routing import random_neighbour, greedy_neighbour, nearest_neighbour import concurrent.futures as cf from itertools import chain import numpy as np #%%

    def initial_population(N, num_cores, number_random_chromosomes, number_greedy_chromosomes, number_nearest_nn_chromosomes, num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list, radius): with cf.ProcessPoolExecutor(num_cores) as executor: results_list = [] for i in range(number_random_chromosomes): results_list.append(executor.submit(random_neighbour, num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list)) for j in range(number_greedy_chromosomes): results_list.append(executor.submit(greedy_neighbour, num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list, radius))

    results_list.append(nearest_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list))

    chromosome_route_list, chromosome_distance_list, num_routes, total_distance

    temp = list(chain.from_iterable(f.result() for f in cf.as_completed(results_list))) 
    
    pop_chromosome_routeList_array = np.empty(N, object)
    pop_chromosome_distanceList_array = np.empty(N, object)
    pop_num_routes = np.empty(N)
    pop_total_distance = np.empty(N)
    
    chromosome_route_list, chromosome_distance_list, num_routes, total_distance = nearest_neighbour(num_customers, arr_customers, arr_distance_matrix,  total_capacity, total_time, all_customers_list)
    pop_chromosome_routeList_array[0] = chromosome_route_list
    pop_chromosome_distanceList_array[0] = chromosome_distance_list
    pop_num_routes[0] = num_routes
    pop_total_distance[0] = total_distance
    
    pop_chromosome_routeList_array[1::] = temp[0::4]
    pop_chromosome_distanceList_array[1::] = temp[1::4]
    pop_num_routes[1::] = temp[2::4]
    pop_total_distance[1::] = temp[3::4]
    
    return pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance
    

    #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Fri Sep 14 14:41:23 2018

    @author: krupa

    """ #%%

    =============================================================================

    PHASE II ROUTING:

    1. REMOVE LAST CUSTOMER OF R1

    2. ADD LASTE CUSTOMER TO BE FIRST CUSTOME OF R2

    3. IF BOTH FEASIBLE AND NEW SUM DISTANCE IS LESS OR REDUCES NUMBER OF VEHICLES THEN ACCEPT

    =============================================================================

    #%% #import copy #import collections from validity import route_validity import numpy as np from joblib import Parallel, delayed

    #%%

    def routing_phase2(alpha, beta, chromosome, chromosome_distance_list, total_capacity, total_time, arr_distance_matrix, arr_customers): index_list = np.arange(0, len(chromosome)+1) index_list[len(chromosome)] = 0 for i in range(len(index_list)-1): r1_index = index_list[i] r2_index = index_list[i+1] route_r1 = chromosome[r1_index].copy() route_r2 = chromosome[r2_index].copy() dist_r1 = chromosome_distance_list[r1_index] dist_r2 = chromosome_distance_list[r2_index] customer_r1 = route_r1[-2] route_r2.insert(1, customer_r1) route_validity_status, new_r2_dist = route_validity(route_r2, arr_distance_matrix, arr_customers, total_time, total_capacity) if route_validity == True: if len(route_r1)>3: new_r1_dist = dist_r1 - arr_distance_matrix[route_r1[-2],0]+ arr_distance_matrix[route_r1[-3],0] if (dist_r1+dist_r2)>(new_r1_dist+new_r2_dist): del route_r1[-1] chromosome[r1_index] = route_r1 chromosome[r2_index] = route_r2 chromosome_distance_list[r1_index] = new_r1_dist chromosome_distance_list[r2_index] = new_r2_dist else: del chromosome[r1_index] chromosome[r2_index] = route_r2 del chromosome_distance_list[r1_index] chromosome_distance_list[r2_index] = new_r2_dist total_distance = sum(chromosome_distance_list) num_vehicles = len(chromosome) fitness = (alphanum_vehicles)+(betatotal_distance) return chromosome, chromosome_distance_list, num_vehicles, total_distance, fitness

    #%%

    def initial_routing_phase2(num_cores,N, alpha, beta, pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_distance_matrix, arr_customers, total_time, total_capacity): inputs = range(0,N) results_list = Parallel(num_cores)(delayed(routing_phase2)(alpha, beta, pop_chromosome_routeList_array[i], pop_chromosome_distanceList_array[i], total_capacity, total_time, arr_distance_matrix, arr_customers ) for i in inputs)

    chromosome, chromosome_distance_list, num_vehicles, total_distance, fitness

    unzipped = zip(*results_list) #groups the same return for each particle and returns a list of tuples each of lenth M
    results_list = list(unzipped)
    pop_chromosome_routeList_array = np.empty(N, object)
    pop_chromosome_distanceList_array = np.empty(N, object)
    pop_chromosome_routeList_array[:] = results_list[0]
    pop_chromosome_distanceList_array[:] = results_list[1]
    arr_pop_results = np.empty((N,3), float)
    arr_pop_results[:,0] = results_list[2]
    arr_pop_results[:,1] = results_list[3]
    arr_pop_results[:,2] = results_list[4]
    return pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_pop_results
    
    

    #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Thu Sep 13 17:04:34 2018

    @author: krupa """ from feasible_neighbours import feasible_neighbours import random #%%

    =============================================================================

    INITIAL ROUTING SCHEME

    1. Random

    2. Greedy

    3. Phase 2

    =============================================================================

    #%% def random_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list): available_customers_list = all_customers_list.copy()

    chromosome_route_list = []
    chromosome_distance_list = []
    route_list = [0] 
    curr_capacity = 0
    curr_time = 0
    curr_customer = 0
    curr_distance = 0
    
    while len(available_customers_list)!=0:
        arr_feasible_neighbours =  feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, available_customers_list, total_time, total_capacity, curr_time, curr_capacity, curr_customer)    
        if arr_feasible_neighbours.shape[0]!=0:#has neighbours, append them
            feasible_neighbours_list = arr_feasible_neighbours[:,0].tolist()
            curr_customer = int(random.choice(feasible_neighbours_list))
            curr_customer_index = feasible_neighbours_list.index(curr_customer)
            route_list.append(curr_customer)
            curr_distance += arr_feasible_neighbours[curr_customer_index, 6]
            curr_capacity = arr_feasible_neighbours[curr_customer_index, 1]
            curr_time = arr_feasible_neighbours[curr_customer_index, 10]
            available_customers_list.remove(curr_customer)
        else: #end route and initialise a new route
            route_list.append(0)
            chromosome_route_list.append(route_list)
            curr_distance += arr_distance_matrix[curr_customer,0]
            chromosome_distance_list.append(curr_distance)
            #initialise new route 
            route_list = [0] 
            curr_capacity = 0
            curr_time = 0
            curr_customer = 0
            curr_distance = 0
    #end last route        
    route_list.append(0)
    chromosome_route_list.append(route_list)
    curr_distance += arr_distance_matrix[curr_customer,0]
    chromosome_distance_list.append(curr_distance)
    
    num_routes= len(chromosome_distance_list)
    total_distance = sum(chromosome_distance_list)
    
    random_route_results = (chromosome_route_list, chromosome_distance_list, num_routes, total_distance)
    return random_route_results   
    

    #%% def greedy_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list, radius): available_customers_list = all_customers_list.copy()

    chromosome_route_list = []
    chromosome_distance_list = []
    route_list = [0] 
    curr_capacity = 0
    curr_time = 0
    curr_customer = 0
    curr_distance = 0
    
    while len(available_customers_list)!=0:
        arr_feasible_neighbours =  feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, available_customers_list, total_time, total_capacity, curr_time, curr_capacity, curr_customer)    
        if arr_feasible_neighbours.shape[0]!=0:#has neighbours, append them
            if arr_feasible_neighbours[arr_feasible_neighbours[:,6]<=radius].shape[0] !=0:
                arr_feasible_neighbours = arr_feasible_neighbours[arr_feasible_neighbours[:,6]<=radius] #reduce search space to feasible neighbours withn radius
            feasible_neighbours_list = arr_feasible_neighbours[:,0].tolist()
            curr_customer = int(random.choice(feasible_neighbours_list))
            curr_customer_index = feasible_neighbours_list.index(curr_customer)
            route_list.append(curr_customer)
            curr_distance += arr_feasible_neighbours[curr_customer_index, 6]
            curr_capacity = arr_feasible_neighbours[curr_customer_index, 1]
            curr_time = arr_feasible_neighbours[curr_customer_index, 10]
            available_customers_list.remove(curr_customer)
    
                
        else: #end route and initialise a new route
            route_list.append(0)
            chromosome_route_list.append(route_list)
            curr_distance += arr_distance_matrix[curr_customer,0]
            chromosome_distance_list.append(curr_distance)
            #initialise new route 
            route_list = [0] 
            curr_capacity = 0
            curr_time = 0
            curr_customer = 0
            curr_distance = 0
    #end last route        
    route_list.append(0)
    chromosome_route_list.append(route_list)
    curr_distance += arr_distance_matrix[curr_customer,0]
    chromosome_distance_list.append(curr_distance)
    
    num_routes= len(chromosome_distance_list)
    total_distance = sum(chromosome_distance_list)
    
    greedy_route_results = (chromosome_route_list, chromosome_distance_list, num_routes, total_distance)
    return greedy_route_results
    

    #%% def nearest_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list): available_customers_list = all_customers_list.copy()

    chromosome_route_list = []
    chromosome_distance_list = []
    route_list = [0] 
    curr_capacity = 0
    curr_time = 0
    curr_customer = 0
    curr_distance = 0
    
    while len(available_customers_list)!=0:
        arr_feasible_neighbours =  feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, available_customers_list, total_time, total_capacity, curr_time, curr_capacity, curr_customer)    
        if arr_feasible_neighbours.shape[0]!=0:#has neighbours, append them
            #find minimum travel distance
            curr_customer_index = arr_feasible_neighbours[:,6].argmin()
            curr_customer = int(arr_feasible_neighbours[curr_customer_index,0] )
            route_list.append(curr_customer)
            curr_distance += arr_feasible_neighbours[curr_customer_index, 6]
            curr_capacity = arr_feasible_neighbours[curr_customer_index, 1]
            curr_time = arr_feasible_neighbours[curr_customer_index, 10]
            available_customers_list.remove(curr_customer)
        else: #end route and initialise a new route
            route_list.append(0)
            chromosome_route_list.append(route_list)
            curr_distance += arr_distance_matrix[curr_customer,0]
            chromosome_distance_list.append(curr_distance)
            #initialise new route 
            route_list = [0] 
            curr_capacity = 0
            curr_time = 0
            curr_customer = 0
            curr_distance = 0
    #end last route        
    route_list.append(0)
    chromosome_route_list.append(route_list)
    curr_distance += arr_distance_matrix[curr_customer,0]
    chromosome_distance_list.append(curr_distance)
    
    num_routes= len(chromosome_distance_list)
    total_distance = sum(chromosome_distance_list)
    
    return chromosome_route_list, chromosome_distance_list, num_routes, total_distance
    

    #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Thu Sep 13 16:08:53 2018

    @author: krupa """ #%% import numpy as np

    #%%

    =============================================================================

    FEASIBLE NEIGHBOURS

    copy array of all customers from arr_customers

    to arr_feasible_customers with the following columns

    customer_index = 0

    demand = 1

    service_time = 2

    ready_time = 3

    due_time = 4

    complete_time = 5

    distance_curr_next = 6

    arrival_time = 7

    waiting_time = 8

    start_time = 9

    finish_time = 10

    return_time = 11

    =============================================================================

    #%% def feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, available_customers_list, total_time, total_capacity, curr_time, curr_capacity, curr_customer): arr_feasible_customers = np.empty((len(available_customers_list), 12)) available_customers_list_index = available_customers_list.copy() available_customers_list_index[:] = [x - 1 for x in available_customers_list_index] arr_feasible_customers[:,0:6] = arr_customers[available_customers_list_index, :]

    #curr capacity 
    arr_feasible_customers[:, 1] = arr_feasible_customers[:, 1] + curr_capacity 
    #distance_curr_next
    arr_feasible_customers[:, 6] = arr_distance_matrix[curr_customer, available_customers_list]
    #arrival_time 
    arr_feasible_customers[:, 7] = arr_feasible_customers[:, 6] + curr_time
    #waiting_time
    arr_feasible_customers[:, 8] = arr_feasible_customers[:, 3] - arr_feasible_customers[:, 7]
    arr_feasible_customers[:, 8] = arr_feasible_customers[:, 8].clip(min=0)
    #start time
    arr_feasible_customers[:, 9] = arr_feasible_customers[:, 7] + arr_feasible_customers[:, 8] #arrival + waiting
    #finish_time 
    arr_feasible_customers[:, 10] = arr_feasible_customers[:, 9] + arr_feasible_customers[:, 2] #(arrival + waiting )+ service
    #return_time 
    arr_feasible_customers[:, 11] = arr_distance_matrix[available_customers_list, 0] + arr_feasible_customers[:, 10]
    
    
    #keep only those that adhere to constraints    
    arr_feasible_customers = arr_feasible_customers[(arr_feasible_customers[:,1]<=total_capacity) & (arr_feasible_customers[:,11]<=total_time) & (arr_feasible_customers[:,9]>=arr_feasible_customers[:,3]) & (arr_feasible_customers[:,10]<=arr_feasible_customers[:,5])]
    
    return arr_feasible_customers
    
    
    
    

    #!/usr/bin/env python3

    -- coding: utf-8 --

    """ Created on Mon Sep 17 10:46:08 2018

    @author: krupa """

    #import numpy as np #%%

    =============================================================================

    Given a route [depot, c1, ....cn, 0]

    check validity of the route: time, capacity constraints.

    want to see if the sequence of the route is valid

    =============================================================================

    #%% def route_validity(route, arr_distance_matrix, arr_customers, total_time, total_capacity): route_validity_status = True curr_dist = arr_distance_matrix[route[0], route[1]] curr_capacity = arr_customers[route[1]-1, 1] #demand of customer (route[1]) -1 index postion ready_time = arr_customers[route[1]-1, 3] due_time = arr_customers[route[1]-1, 4] curr_time = arr_distance_matrix[route[0], route[1]] waiting_time = max(0, ready_time-curr_time) curr_time += waiting_time + arr_customers[route[1]-1, 2] #service time

    route_customers = route[1:-1]
    for i in range(len(route_customers)-1):
        curr_dist += arr_distance_matrix[route_customers[i], route_customers[i+1]]
        curr_time += arr_distance_matrix[route_customers[i], route_customers[i+1]]
        ready_time = arr_customers[route_customers[i+1]-1, 3]
        due_time = arr_customers[route_customers[i+1]-1, 4]
        service_time = arr_customers[route_customers[i+1]-1, 2]
        curr_capacity += arr_customers[route_customers[i+1]-1, 1]
        if curr_time<=due_time and curr_capacity<total_capacity:
            #accept
            waiting_time = max(0, ready_time - curr_time)
            if (curr_time + waiting_time>=ready_time) and (curr_time + waiting_time + service_time <= total_time):
                #accept next customer 
                curr_time += waiting_time + service_time
            else:
                #route invalid
                route_validity_status = False
                break
        else:
            #route invalid
            route_validity_status = False
            break
    
    if route_validity_status == True:
        curr_dist += arr_distance_matrix[route[-2], route[-1]]
        curr_time += arr_distance_matrix[route[-2], route[-1]]
        if curr_time>total_time:
            route_validity_status = False
            
    return route_validity_status, curr_dist
    
  2. Assistant

    Translating the provided Python code to MATLAB involves several steps, mainly due to differences in syntax, programming paradigms, and built-in functions between the two languages. Additionally, MATLAB uses 1-based indexing, which requires careful adjustments throughout the code.

    Below is a comprehensive translation of your Python scripts into MATLAB. The translation includes:

    1. Main Script (main.m): Corresponds to your primary Python script.
    2. Helper Functions: Each Python script is translated into a separate MATLAB function:
      • initial_population.m
      • initial_routing_phase2.m
      • routing_phase2.m
      • random_neighbour.m
      • greedy_neighbour.m
      • nearest_neighbour.m
      • feasible_neighbours.m
      • route_validity.m

    1. Main Script (main.m)

    % main.m
    % MATLAB translation of the provided Python script
    
    % Clear workspace and command window
    clear; clc;
    
    % Define paths
    cwd = pwd;
    customer_path = fullfile(cwd, 'solomon25_csv', 'customers');
    dataInfo_path = fullfile(cwd, 'solomon25_csv', 'data_info');
    distanceMatrix_path = fullfile(cwd, 'solomon25_csv', 'distance_matrix');
    initial_path = fullfile(cwd, 'initial');
    
    % Initialize dataset lists
    c1_list_datasets = arrayfun(@(x) sprintf('c%d', x), 101:109, 'UniformOutput', false);
    r1_list_datasets = arrayfun(@(x) sprintf('r%d', x), 101:112, 'UniformOutput', false);
    rc1_list_datasets = arrayfun(@(x) sprintf('rc%d', x), 101:108, 'UniformOutput', false);
    c2_list_datasets = arrayfun(@(x) sprintf('c%d', x), 201:208, 'UniformOutput', false);
    r2_list_datasets = arrayfun(@(x) sprintf('r%d', x), 201:211, 'UniformOutput', false);
    rc2_list_datasets = arrayfun(@(x) sprintf('rc%d', x), 201:208, 'UniformOutput', false);
    
    dataset_list = [c1_list_datasets, r1_list_datasets, rc1_list_datasets, ...
                   c2_list_datasets, r2_list_datasets, rc2_list_datasets];
    
    % Generate file lists with extensions
    generate_file_list = @(prefix, range, suffix) arrayfun(@(x) sprintf('%s%d%s', prefix, x, suffix), range, 'UniformOutput', false);
    
    dataInfo_files_list = [generate_file_list('c', 101:109, 'dataInfo.csv'), ...
                          generate_file_list('r', 101:112, 'dataInfo.csv'), ...
                          generate_file_list('rc', 101:108, 'dataInfo.csv'), ...
                          generate_file_list('c', 201:208, 'dataInfo.csv'), ...
                          generate_file_list('r', 201:211, 'dataInfo.csv'), ...
                          generate_file_list('rc', 201:208, 'dataInfo.csv')];
    
    customers_files_list = [generate_file_list('c', 101:109, 'customers.csv'), ...
                            generate_file_list('r', 101:112, 'customers.csv'), ...
                            generate_file_list('rc', 101:108, 'customers.csv'), ...
                            generate_file_list('c', 201:208, 'customers.csv'), ...
                            generate_file_list('r', 201:211, 'customers.csv'), ...
                            generate_file_list('rc', 201:208, 'customers.csv')];
    
    distanceMatrix_files_list = [generate_file_list('c', 101:109, 'distanceMatrix.csv'), ...
                                 generate_file_list('r', 101:112, 'distanceMatrix.csv'), ...
                                 generate_file_list('rc', 101:108, 'distanceMatrix.csv'), ...
                                 generate_file_list('c', 201:208, 'distanceMatrix.csv'), ...
                                 generate_file_list('r', 201:211, 'distanceMatrix.csv'), ...
                                 generate_file_list('rc', 201:208, 'distanceMatrix.csv')];
    
    initialPop_files_list = [generate_file_list('c', 101:109, 'initialPop.mat'), ...
                             generate_file_list('r', 101:112, 'initialPop.mat'), ...
                             generate_file_list('rc', 101:108, 'initialPop.mat'), ...
                             generate_file_list('c', 201:208, 'initialPop.mat'), ...
                             generate_file_list('r', 201:211, 'initialPop.mat'), ...
                             generate_file_list('rc', 201:208, 'initialPop.mat')];
    
    initialDistance_files_list = [generate_file_list('c', 101:109, 'initialDistance.mat'), ...
                                   generate_file_list('r', 101:112, 'initialDistance.mat'), ...
                                   generate_file_list('rc', 101:108, 'initialDistance.mat'), ...
                                   generate_file_list('c', 201:208, 'initialDistance.mat'), ...
                                   generate_file_list('r', 201:211, 'initialDistance.mat'), ...
                                   generate_file_list('rc', 201:208, 'initialDistance.mat')];
    
    initialResults_files_list = [generate_file_list('c', 101:109, 'initialResults.csv'), ...
                                 generate_file_list('r', 101:112, 'initialResults.csv'), ...
                                 generate_file_list('rc', 101:108, 'initialResults.csv'), ...
                                 generate_file_list('c', 201:208, 'initialResults.csv'), ...
                                 generate_file_list('r', 201:211, 'initialResults.csv'), ...
                                 generate_file_list('rc', 201:208, 'initialResults.csv')];
    
    % Experiment variables
    num_experiments = 30;
    num_cores = feature('numcores'); % MATLAB's equivalent to multiprocessing.cpu_count()
    
    % Global variables
    N = 300; % population size
    greedy_percent = 0.10; % percentage to be greedily initialized
    random_percent = 0.90; % percentage to be randomly initialized
    alpha = 100;
    beta = 0.001;
    
    % Loop through each dataset
    for i = 1:length(dataset_list)
        dataSet = dataset_list{i};
        
        % File paths
        customer_file = fullfile(customer_path, customers_files_list{i});
        dataInfo_file = fullfile(dataInfo_path, dataInfo_files_list{i});
        distanceMatrix_file = fullfile(distanceMatrix_path, distanceMatrix_files_list{i});
        
        % Read data
        df_customers = readtable(customer_file);
        df_distance_matrix = readtable(distanceMatrix_file);
        df_dataInfo = readtable(dataInfo_file);
        
        num_customers = height(df_customers);
        num_customers_depot = num_customers + 1;
        
        % Adjust customer indexing
        df_customers.Properties.RowNames = arrayfun(@num2str, 1:num_customers_depot, 'UniformOutput', false)';
        
        number_random_chromosomes = floor(N * random_percent) - 1;
        number_nearest_nn_chromosomes = 1;
        number_greedy_chromosomes = N - number_random_chromosomes - 1; % int(N*greedy_percent)
        
        % Convert to arrays
        arr_distance_matrix = table2array(df_distance_matrix);
        
        % Calculate dataset radius
        dataset_radius = (max(arr_distance_matrix(:), [], 'omitnan') - min(arr_distance_matrix(:), [], 'omitnan')) / 2;
        
        % Customer array
        arr_customers = zeros(num_customers, 6);
        arr_customers(:,1) = (1:num_customers)';
        arr_customers(:,2) = df_customers.demand;
        arr_customers(:,3) = df_customers.serviceTime;
        arr_customers(:,4) = df_customers.readyTime;
        arr_customers(:,5) = df_customers.dueTime;
        arr_customers(:,6) = df_customers.completeTime;
        
        % Fleet max details
        total_time = df_dataInfo.fleet_max_working_time(1);
        total_capacity = df_dataInfo.fleet_capacity(1);
        
        all_customers_list = 1:num_customers_depot - 1;
        
        % Loop through each experiment
        parfor experiment = 0:num_experiments-1
            % Define experiment-specific output paths
            exp_initial_path = fullfile(initial_path, dataSet, sprintf('experiment%d', experiment));
            if ~exist(exp_initial_path, 'dir')
                mkdir(exp_initial_path);
            end
            
            initial_pop_output_file = fullfile(exp_initial_path, initialPop_files_list{i});
            initial_pop_distance_output_file = fullfile(exp_initial_path, initialDistance_files_list{i});
            initial_result_output_file = fullfile(exp_initial_path, initialResults_files_list{i});
            
            % Randomize radius
            radius = dataset_radius * (0.5 + (1-0.5) * rand()); % random.uniform(0.5,1)
            
            % Phase 1: Initial Population
            [pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance] = ...
                initial_population(N, num_cores, number_random_chromosomes, number_greedy_chromosomes, ...
                                  number_nearest_nn_chromosomes, num_customers, arr_customers, arr_distance_matrix, ...
                                  total_capacity, total_time, all_customers_list, radius);
                              
            % Phase 2: Initial Routing
            [pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_pop_results] = ...
                initial_routing_phase2(num_cores, N, alpha, beta, pop_chromosome_routeList_array, ...
                                       pop_chromosome_distanceList_array, arr_distance_matrix, ...
                                       arr_customers, total_time, total_capacity);
                                   
            % Save outputs
            save(initial_pop_output_file, 'pop_chromosome_routeList_array');
            save(initial_pop_distance_output_file, 'pop_chromosome_distanceList_array');
            
            % Prepare initial results table
            df_initial_results = table(pop_num_routes, pop_total_distance, ...
                                       alpha * pop_num_routes + beta * pop_total_distance, ...
                                       'VariableNames', {'num_vehicles', 'distance', 'fitness'});
                                   
            writetable(df_initial_results, initial_result_output_file);
            
            fprintf('Dataset: %s, Experiment: %d completed.\n', dataSet, experiment);
        end
        fprintf('Dataset: %s processing completed.\n', dataSet);
    end
    

    2. Helper Functions

    Each helper function from the Python scripts is translated into a separate MATLAB function. Below are the translations:

    a. initial_population.m

    % initial_population.m
    function [pop_chromosome_routeList_array, pop_chromosome_distanceList_array, pop_num_routes, pop_total_distance] = ...
        initial_population(N, num_cores, number_random_chromosomes, number_greedy_chromosomes, number_nearest_nn_chromosomes, ...
                          num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, ...
                          all_customers_list, radius)
                      
        % Initialize cell arrays to store results
        chromosome_route_list = cell(N, 1);
        chromosome_distance_list = zeros(N, 1);
        pop_num_routes = zeros(N,1);
        pop_total_distance = zeros(N,1);
        
        % Initialize parallel pool if not already open
        pool = gcp('nocreate');
        if isempty(pool)
            parpool('local', num_cores);
        end
        
        % Phase 1: Generate random and greedy chromosomes
        temp = cell(number_random_chromosomes + number_greedy_chromosomes, 1);
        parfor idx = 1:(number_random_chromosomes + number_greedy_chromosomes)
            if idx <= number_random_chromosomes
                [route, distance, num_routes, total_dist] = random_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list);
            else
                [route, distance, num_routes, total_dist] = greedy_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list, radius);
            end
            temp{idx} = {route, distance, num_routes, total_dist};
        end
        
        % Phase 1 Results
        for idx = 1:length(temp)
            pop_chromosome_routeList_array{idx+1} = temp{idx}{1}; % Start from 2 since 1 is for nearest_neighbour
            pop_chromosome_distanceList_array(idx+1) = temp{idx}{2};
            pop_num_routes(idx+1) = temp{idx}{3};
            pop_total_distance(idx+1) = temp{idx}{4};
        end
        
        % Phase 1: Nearest Neighbour Chromosome
        [nn_route, nn_distance, nn_num_routes, nn_total_distance] = nearest_neighbour(num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list);
        pop_chromosome_routeList_array{1} = nn_route;
        pop_chromosome_distanceList_array(1) = nn_distance;
        pop_num_routes(1) = nn_num_routes;
        pop_total_distance(1) = nn_total_distance;
        
    end
    

    b. initial_routing_phase2.m

    % initial_routing_phase2.m
    function [pop_chromosome_routeList_array, pop_chromosome_distanceList_array, arr_pop_results] = ...
        initial_routing_phase2(num_cores, N, alpha, beta, pop_chromosome_routeList_array, pop_chromosome_distanceList_array, ...
                               arr_distance_matrix, arr_customers, total_time, total_capacity)
    
        % Initialize cell arrays for updated routes and distances
        updated_routes = cell(N,1);
        updated_distances = zeros(N,1);
        arr_pop_results = zeros(N,3); % num_vehicles, distance, fitness
        
        % Initialize parallel pool if not already open
        pool = gcp('nocreate');
        if isempty(pool)
            parpool('local', num_cores);
        end
        
        parfor i = 1:N
            [updated_route, updated_distance, num_vehicles, total_distance, fitness] = ...
                routing_phase2(alpha, beta, pop_chromosome_routeList_array{i}, pop_chromosome_distanceList_array(i), ...
                              total_capacity, total_time, arr_distance_matrix, arr_customers);
            updated_routes{i} = updated_route;
            updated_distances(i) = updated_distance;
            arr_pop_results(i, :) = [num_vehicles, total_distance, fitness];
        end
        
        % Assign updated values back
        pop_chromosome_routeList_array = updated_routes;
        pop_chromosome_distanceList_array = updated_distances;
    end
    

    c. routing_phase2.m

    % routing_phase2.m
    function [chromosome, chromosome_distance_list, num_vehicles, total_distance, fitness] = ...
        routing_phase2(alpha, beta, chromosome, chromosome_distance_list, total_capacity, total_time, arr_distance_matrix, arr_customers)
    
        index_list = 1:(length(chromosome)+1);
        index_list(end) = 1; % MATLAB indices start at 1; replacing 0 with 1 for depot
        
        for i = 1:(length(index_list)-1)
            r1_index = index_list(i);
            r2_index = index_list(i+1);
            
            route_r1 = chromosome{r1_index};
            route_r2 = chromosome{r2_index};
            dist_r1 = chromosome_distance_list(r1_index);
            dist_r2 = chromosome_distance_list(r2_index);
            
            customer_r1 = route_r1(end-1); % Last customer in R1
            
            % Insert customer_r1 into route_r2 at position 2 (after depot)
            route_r2 = [route_r2(1), customer_r1, route_r2(2:end)];
            
            % Check validity
            [route_valid_status, new_r2_dist] = route_validity(route_r2, arr_distance_matrix, arr_customers, total_time, total_capacity);
            
            if route_valid_status
                if length(route_r1) > 3
                    new_r1_dist = dist_r1 - arr_distance_matrix(route_r1(end-1), 1) + arr_distance_matrix(route_r1(end-2), 1);
                    if (dist_r1 + dist_r2) > (new_r1_dist + new_r2_dist)
                        route_r1(end) = []; % Remove last depot
                        chromosome{r1_index} = route_r1;
                        chromosome{r2_index} = route_r2;
                        chromosome_distance_list(r1_index) = new_r1_dist;
                        chromosome_distance_list(r2_index) = new_r2_dist;
                    end
                else
                    % Remove route_r1 and update route_r2
                    chromosome(r1_index) = [];
                    chromosome{r2_index} = route_r2;
                    chromosome_distance_list(r2_index) = new_r2_dist;
                end
            end
        end
        
        % Calculate total distance and number of vehicles
        total_distance = sum(chromosome_distance_list);
        num_vehicles = length(chromosome);
        fitness = (alpha * num_vehicles) + (beta * total_distance);
    end
    

    d. random_neighbour.m

    % random_neighbour.m
    function [chromosome_route_list, chromosome_distance_list, num_routes, total_distance] = random_neighbour( ...
        num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list)
    
        available_customers_list = all_customers_list;
        
        chromosome_route_list = {};
        chromosome_distance_list = [];
        route_list = 0; % Depot represented by 0
        curr_capacity = 0;
        curr_time = 0;
        curr_customer = 0;
        curr_distance = 0;
        
        while ~isempty(available_customers_list)
            arr_feasible_neighbours = feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, ...
                                                          available_customers_list, total_time, total_capacity, ...
                                                          curr_time, curr_capacity, curr_customer);
            if size(arr_feasible_neighbours,1) ~=0
                feasible_neighbours_list = arr_feasible_neighbours(:,1)';
                chosen_idx = randi(length(feasible_neighbours_list));
                curr_customer = feasible_neighbours_list(chosen_idx);
                route_list(end+1) = curr_customer;
                curr_distance = curr_distance + arr_feasible_neighbours(chosen_idx,6);
                curr_capacity = arr_feasible_neighbours(chosen_idx,2);
                curr_time = arr_feasible_neighbours(chosen_idx,10);
                available_customers_list(available_customers_list == curr_customer) = [];
            else
                % End current route
                route_list(end+1) = 0; % Return to depot
                chromosome_route_list{end+1} = route_list;
                curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
                chromosome_distance_list(end+1) = curr_distance;
                % Initialize new route
                route_list = [0];
                curr_capacity = 0;
                curr_time = 0;
                curr_customer = 0;
                curr_distance = 0;
            end
        end
        
        % End last route
        if route_list(end) ~=0
            route_list(end+1) = 0;
            chromosome_route_list{end+1} = route_list;
            curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
            chromosome_distance_list(end+1) = curr_distance;
        end
        
        num_routes = length(chromosome_distance_list);
        total_distance = sum(chromosome_distance_list);
    end
    

    e. greedy_neighbour.m

    % greedy_neighbour.m
    function [chromosome_route_list, chromosome_distance_list, num_routes, total_distance] = greedy_neighbour( ...
        num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list, radius)
    
        available_customers_list = all_customers_list;
        
        chromosome_route_list = {};
        chromosome_distance_list = [];
        route_list = 0; % Depot
        curr_capacity = 0;
        curr_time = 0;
        curr_customer = 0;
        curr_distance = 0;
        
        while ~isempty(available_customers_list)
            arr_feasible_neighbours = feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, ...
                                                          available_customers_list, total_time, total_capacity, ...
                                                          curr_time, curr_capacity, curr_customer);
            if size(arr_feasible_neighbours,1) ~=0
                % Filter by radius
                within_radius = arr_feasible_neighbours(arr_feasible_neighbours(:,6) <= radius, :);
                if ~isempty(within_radius)
                    arr_feasible_neighbours = within_radius;
                end
                feasible_neighbours_list = arr_feasible_neighbours(:,1)';
                chosen_idx = randi(length(feasible_neighbours_list));
                curr_customer = feasible_neighbours_list(chosen_idx);
                route_list(end+1) = curr_customer;
                curr_distance = curr_distance + arr_feasible_neighbours(chosen_idx,6);
                curr_capacity = arr_feasible_neighbours(chosen_idx,2);
                curr_time = arr_feasible_neighbours(chosen_idx,10);
                available_customers_list(available_customers_list == curr_customer) = [];
            else
                % End current route
                route_list(end+1) = 0; % Return to depot
                chromosome_route_list{end+1} = route_list;
                curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
                chromosome_distance_list(end+1) = curr_distance;
                % Initialize new route
                route_list = [0];
                curr_capacity = 0;
                curr_time = 0;
                curr_customer = 0;
                curr_distance = 0;
            end
        end
        
        % End last route
        if route_list(end) ~=0
            route_list(end+1) = 0;
            chromosome_route_list{end+1} = route_list;
            curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
            chromosome_distance_list(end+1) = curr_distance;
        end
        
        num_routes = length(chromosome_distance_list);
        total_distance = sum(chromosome_distance_list);
    end
    

    f. nearest_neighbour.m

    % nearest_neighbour.m
    function [chromosome_route_list, chromosome_distance_list, num_routes, total_distance] = nearest_neighbour( ...
        num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list)
    
        available_customers_list = all_customers_list;
        
        chromosome_route_list = {};
        chromosome_distance_list = [];
        route_list = 0; % Depot
        curr_capacity = 0;
        curr_time = 0;
        curr_customer = 0;
        curr_distance = 0;
        
        while ~isempty(available_customers_list)
            arr_feasible_neighbours = feasible_neighbours(num_customers, arr_customers, arr_distance_matrix, ...
                                                          available_customers_list, total_time, total_capacity, ...
                                                          curr_time, curr_capacity, curr_customer);
            if size(arr_feasible_neighbours,1) ~=0
                % Find minimum travel distance
                [min_dist, min_idx] = min(arr_feasible_neighbours(:,6));
                curr_customer = arr_feasible_neighbours(min_idx,1);
                route_list(end+1) = curr_customer;
                curr_distance = curr_distance + min_dist;
                curr_capacity = arr_feasible_neighbours(min_idx,2);
                curr_time = arr_feasible_neighbours(min_idx,10);
                available_customers_list(available_customers_list == curr_customer) = [];
            else
                % End current route
                route_list(end+1) = 0; % Return to depot
                chromosome_route_list{end+1} = route_list;
                curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
                chromosome_distance_list(end+1) = curr_distance;
                % Initialize new route
                route_list = [0];
                curr_capacity = 0;
                curr_time = 0;
                curr_customer = 0;
                curr_distance = 0;
            end
        end
        
        % End last route
        if route_list(end) ~=0
            route_list(end+1) = 0;
            chromosome_route_list{end+1} = route_list;
            curr_distance = curr_distance + arr_distance_matrix(curr_customer+1,1); % MATLAB 1-based
            chromosome_distance_list(end+1) = curr_distance;
        end
        
        num_routes = length(chromosome_distance_list);
        total_distance = sum(chromosome_distance_list);
        
    end
    

    g. feasible_neighbours.m

    % feasible_neighbours.m
    function arr_feasible_customers = feasible_neighbours( ...
        num_customers, arr_customers, arr_distance_matrix, available_customers_list, ...
        total_time, total_capacity, curr_time, curr_capacity, curr_customer)
    
        num_available = length(available_customers_list);
        arr_feasible_customers = zeros(num_available, 12);
        
        % Adjust indices for MATLAB (assuming customers are 1-indexed)
        available_indices = available_customers_list;
        
        % Populate arr_feasible_customers
        arr_feasible_customers(:,1:6) = arr_customers(available_indices, :);
        
        % Update capacities
        arr_feasible_customers(:,2) = arr_feasible_customers(:,2) + curr_capacity;
        
        % Distance from current customer to next
        arr_feasible_customers(:,6) = arr_distance_matrix(curr_customer+1, available_customers_list)';
        
        % Arrival time
        arr_feasible_customers(:,7) = arr_feasible_customers(:,6) + curr_time;
        
        % Waiting time
        arr_feasible_customers(:,8) = arr_customers(available_indices,4) - arr_feasible_customers(:,7);
        arr_feasible_customers(:,8) = max(arr_feasible_customers(:,8), 0);
        
        % Start time
        arr_feasible_customers(:,9) = arr_feasible_customers(:,7) + arr_feasible_customers(:,8);
        
        % Finish time
        arr_feasible_customers(:,10) = arr_feasible_customers(:,9) + arr_feasible_customers(:,3);
        
        % Return time to depot
        arr_feasible_customers(:,11) = arr_distance_matrix(available_customers_list+1,1) + arr_feasible_customers(:,10);
        
        % Constraints:
        % Capacity
        capacity_ok = arr_feasible_customers(:,2) <= total_capacity;
        % Time to return to depot
        return_time_ok = arr_feasible_customers(:,11) <= total_time;
        % Start time within ready time
        start_time_ok = arr_feasible_customers(:,9) >= arr_feasible_customers(:,4);
        % Finish time within complete time
        finish_time_ok = arr_feasible_customers(:,10) <= arr_feasible_customers(:,6);
        
        % Apply constraints
        feasible_indices = capacity_ok & return_time_ok & start_time_ok & finish_time_ok;
        arr_feasible_customers = arr_feasible_customers(feasible_indices, :);
    end
    

    h. route_validity.m

    % route_validity.m
    function [route_valid_status, curr_dist] = route_validity(route, arr_distance_matrix, arr_customers, total_time, total_capacity)
    
        route_valid_status = true;
        curr_dist = 0;
        
        % Initialize route parameters
        curr_dist = curr_dist + arr_distance_matrix(route(1)+1, route(2)+1); % MATLAB 1-based
        curr_capacity = arr_customers(route(2), 2);
        ready_time = arr_customers(route(2), 4);
        due_time = arr_customers(route(2), 5);
        curr_time = arr_distance_matrix(route(1)+1, route(2)+1); % Travel time
        waiting_time = max(0, ready_time - curr_time);
        curr_time = curr_time + waiting_time + arr_customers(route(2), 3); % Service time
        
        % Iterate through the route
        for i = 2:(length(route)-1)
            next_customer = route(i+1);
            travel_time = arr_distance_matrix(route(i)+1, next_customer+1);
            curr_dist = curr_dist + travel_time;
            curr_time = curr_time + travel_time;
            
            ready_time = arr_customers(next_customer, 4);
            due_time = arr_customers(next_customer, 5);
            service_time = arr_customers(next_customer, 3);
            curr_capacity = curr_capacity + arr_customers(next_customer, 2);
            
            if curr_time <= due_time && curr_capacity <= total_capacity
                waiting_time = max(0, ready_time - curr_time);
                if (curr_time + waiting_time >= ready_time) && (curr_time + waiting_time + service_time <= total_time)
                    curr_time = curr_time + waiting_time + service_time;
                else
                    route_valid_status = false;
                    return;
                end
            else
                route_valid_status = false;
                return;
            end
        end
        
        % Final return to depot
        curr_dist = curr_dist + arr_distance_matrix(route(end-1)+1, route(end)+1);
        curr_time = curr_time + arr_distance_matrix(route(end-1)+1, route(end)+1);
        
        if curr_time > total_time
            route_valid_status = false;
        end
    end
    

    3. Notes and Considerations

    1. Indexing Adjustments: MATLAB uses 1-based indexing, whereas Python uses 0-based indexing. In the translation:

      • All customer indices are assumed to start at 1 in MATLAB.
      • Depot is represented as 0 in Python but adjusted appropriately in MATLAB (often by using 1).
    2. Parallel Processing: MATLAB's parfor loops are used to parallelize operations, similar to Python's multiprocessing. Ensure that MATLAB's Parallel Computing Toolbox is installed and configured.

    3. Data Storage:

      • MATLAB does not have a direct equivalent to Python's numpy.save. Instead, .mat files are used to store data structures efficiently.
      • Adjustments are made to save and load data accordingly.
    4. Cell Arrays vs. MATLAB Arrays:

      • Cell arrays are used to store variable-length routes (chromosome_route_list) since MATLAB arrays require uniformity in dimensions.
      • Regular numeric arrays are used for fixed-size data like distances.
    5. Error Handling and Validation:

      • Basic error checks are included to ensure route validity.
      • Additional validation may be required based on specific data and requirements.
    6. Function Dependencies: Ensure all helper functions are placed in the MATLAB path or the same directory as main.m.

    7. Performance Considerations: MATLAB's performance characteristics differ from Python. Profiling and optimization may be necessary for large datasets or numerous experiments.

    8. File Formats:

      • The code assumes .mat and .csv file formats. Ensure consistency with your data storage and usage.

    4. Running the MATLAB Code

    1. Setup Directory Structure: Ensure that the directory structure matches the paths defined in the main.m script (solomon25_csv, initial, etc.).

    2. Place All Functions in Path: Save each helper function (initial_population.m, initial_routing_phase2.m, etc.) in the same directory as main.m or add their locations to MATLAB's search path.

    3. Execute Main Script: Run the main.m script in MATLAB. Ensure that the necessary data files are present in the specified directories.

    4. Monitor Outputs: The script will generate .mat and .csv files containing the initial populations, distances, and results for each experiment and dataset.

    5. Example Function Call

    Here's how you might call one of the helper functions independently for testing:

    % Example: Testing the nearest_neighbour function
    num_customers = 5;
    arr_customers = [
        1, 10, 5, 0, 50, 55;
        2, 15, 3, 10, 60, 63;
        3, 20, 4, 20, 70, 74;
        4, 25, 2, 30, 80, 82;
        5, 30, 6, 40, 90, 96
    ];
    arr_distance_matrix = [
        0, 10, 20, 30, 40, 50;
        10, 0, 15, 25, 35, 45;
        20, 15, 0, 18, 28, 38;
        30, 25, 18, 0, 12, 22;
        40, 35, 28, 12, 0, 14;
        50, 45, 38, 22, 14, 0
    ];
    total_capacity = 100;
    total_time = 100;
    all_customers_list = 1:5;
    
    [chromosome_route_list, chromosome_distance_list, num_routes, total_distance] = nearest_neighbour(...
        num_customers, arr_customers, arr_distance_matrix, total_capacity, total_time, all_customers_list);
    
    disp(chromosome_route_list);
    disp(chromosome_distance_list);
    disp(num_routes);
    disp(total_distance);
    

    6. Conclusion

    Translating complex Python scripts to MATLAB requires meticulous attention to detail, especially when dealing with indexing and data structures. The provided translations aim to maintain the original logic and functionality while adapting to MATLAB's paradigms. Thorough testing is recommended to ensure that all functionalities perform as expected in the MATLAB environment.

    If you encounter specific issues or require further assistance with particular sections of the code, feel free to ask!