supported_int_types = [int, numpy.int, numpy.int8, numpy.int16, numpy.int32, numpy.int64, numpy.uint, numpy.uint8, numpy.uint16, numpy.uint32, numpy.uint64]

supported_float_types = [float, numpy.float, numpy.float16, numpy.float32, numpy.float64]

supported_int_float_types = supported_int_types + supported_float_types

def __init__(self,

num_generations,

num_parents_mating,

fitness_func,

initial_population=None,

sol_per_pop=None,

num_genes=None,

init_range_low=-4,

init_range_high=4,

gene_type=float,

parent_selection_type="sss",

keep_parents=-1,

K_tournament=3,

crossover_type="single_point",

crossover_probability=None,

mutation_type="random",

mutation_probability=None,

mutation_by_replacement=False,

mutation_percent_genes='default',

mutation_num_genes=None,

random_mutation_min_val=-1.0,

random_mutation_max_val=1.0,

gene_space=None,

allow_duplicate_genes=True,

on_start=None,

on_fitness=None,

on_parents=None,

on_crossover=None,

on_mutation=None,

callback_generation=None,

on_generation=None,

on_stop=None,

delay_after_gen=0.0,

save_best_solutions=False,

save_solutions=False,

suppress_warnings=False,

stop_criteria=None):

"""

# If suppress_warnings is bool and its valud is False, then print warning messages.

if type(suppress_warnings) is bool:

self.suppress_warnings = suppress_warnings

else:

self.valid_parameters = False

raise TypeError("The expected type of the 'suppress_warnings' parameter is bool but {suppress_warnings_type} found.".format(suppress_warnings_type=type(suppress_warnings)))

# Validating mutation_by_replacement

if not (type(mutation_by_replacement) is bool):

self.valid_parameters = False

raise TypeError("The expected type of the 'mutation_by_replacement' parameter is bool but ({mutation_by_replacement_type}) found.".format(mutation_by_replacement_type=type(mutation_by_replacement)))

self.mutation_by_replacement = mutation_by_replacement

# Validate gene_space

self.gene_space_nested = False

if type(gene_space) is type(None):

pass

elif type(gene_space) in [list, tuple, range, numpy.ndarray]:

if len(gene_space) == 0:

self.valid_parameters = False

raise TypeError("'gene_space' cannot be empty (i.e. its length must be >= 0).")

else:

for index, el in enumerate(gene_space):

if type(el) in [list, tuple, range, numpy.ndarray]:

if len(el) == 0:

self.valid_parameters = False

raise TypeError("The element indexed {index} of 'gene_space' with type {el_type} cannot be empty (i.e. its length must be >= 0).".format(index=index, el_type=type(el)))

else:

for val in el:

if not (type(val) in [type(None)] + GA.supported_int_float_types):

raise TypeError("All values in the sublists inside the 'gene_space' attribute must be numeric of type int/float/None but ({val}) of type {typ} found.".format(val=val, typ=type(val)))

self.gene_space_nested = True

elif type(el) == type(None):

pass

# self.gene_space_nested = True

elif type(el) is dict:

if len(el.items()) == 2:

if ('low' in el.keys()) and ('high' in el.keys()):

pass

else:

self.valid_parameters = False

raise TypeError("When an element in the 'gene_space' parameter is of type dict, then it can have the keys 'low', 'high', and 'step' (optional) but the following keys found: {gene_space_dict_keys}".format(gene_space_dict_keys=el.keys()))

elif len(el.items()) == 3:

if ('low' in el.keys()) and ('high' in el.keys()) and ('step' in el.keys()):

pass

else:

self.valid_parameters = False

raise TypeError("When an element in the 'gene_space' parameter is of type dict, then it can have the keys 'low', 'high', and 'step' (optional) but the following keys found: {gene_space_dict_keys}".format(gene_space_dict_keys=el.keys()))

else:

self.valid_parameters = False

raise TypeError("When an element in the 'gene_space' parameter is of type dict, then it must have only 2 items but ({num_items}) items found.".format(num_items=len(el.items())))

self.gene_space_nested = True

elif not (type(el) in GA.supported_int_float_types):

self.valid_parameters = False

raise TypeError("Unexpected type {el_type} for the element indexed {index} of 'gene_space'. The accepted types are list/tuple/range/numpy.ndarray of numbers, a single number (int/float), or None.".format(index=index, el_type=type(el)))

elif type(gene_space) is dict:

if len(gene_space.items()) == 2:

if ('low' in gene_space.keys()) and ('high' in gene_space.keys()):

pass

else:

self.valid_parameters = False

raise TypeError("When the 'gene_space' parameter is of type dict, then it can have only the keys 'low', 'high', and 'step' (optional) but the following keys found: {gene_space_dict_keys}".format(gene_space_dict_keys=gene_space.keys()))

elif len(gene_space.items()) == 3:

if ('low' in gene_space.keys()) and ('high' in gene_space.keys()) and ('step' in gene_space.keys()):

pass

else:

self.valid_parameters = False

raise TypeError("When the 'gene_space' parameter is of type dict, then it can have only the keys 'low', 'high', and 'step' (optional) but the following keys found: {gene_space_dict_keys}".format(gene_space_dict_keys=gene_space.keys()))

else:

self.valid_parameters = False

raise TypeError("When the 'gene_space' parameter is of type dict, then it must have only 2 items but ({num_items}) items found.".format(num_items=len(gene_space.items())))

else:

self.valid_parameters = False

raise TypeError("The expected type of 'gene_space' is list, tuple, range, or numpy.ndarray but ({gene_space_type}) found.".format(gene_space_type=type(gene_space)))

self.gene_space = gene_space

# Validate init_range_low and init_range_high

if type(init_range_low) in GA.supported_int_float_types:

if type(init_range_high) in GA.supported_int_float_types:

self.init_range_low = init_range_low

self.init_range_high = init_range_high

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'init_range_high' parameter must be either integer or floating-point number but the value ({init_range_high_value}) of type {init_range_high_type} found.".format(init_range_high_value=init_range_high, init_range_high_type=type(init_range_high)))

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'init_range_low' parameter must be either integer or floating-point number but the value ({init_range_low_value}) of type {init_range_low_type} found.".format(init_range_low_value=init_range_low, init_range_low_type=type(init_range_low)))

# Validate random_mutation_min_val and random_mutation_max_val

if type(random_mutation_min_val) in GA.supported_int_float_types:

if type(random_mutation_max_val) in GA.supported_int_float_types:

if random_mutation_min_val == random_mutation_max_val:

if not self.suppress_warnings: warnings.warn("The values of the 2 parameters 'random_mutation_min_val' and 'random_mutation_max_val' are equal and this causes a fixed change to all genes.")

else:

self.valid_parameters = False

raise TypeError("The expected type of the 'random_mutation_max_val' parameter is numeric but ({random_mutation_max_val_type}) found.".format(random_mutation_max_val_type=type(random_mutation_max_val)))

else:

self.valid_parameters = False

raise TypeError("The expected type of the 'random_mutation_min_val' parameter is numeric but ({random_mutation_min_val_type}) found.".format(random_mutation_min_val_type=type(random_mutation_min_val)))

self.random_mutation_min_val = random_mutation_min_val

self.random_mutation_max_val = random_mutation_max_val

# Validate gene_type

if gene_type in GA.supported_int_float_types:

self.gene_type = [gene_type, None]

self.gene_type_single = True

# A single data type of float with precision.

elif len(gene_type) == 2 and gene_type[0] in GA.supported_float_types and (type(gene_type[1]) in GA.supported_int_types or gene_type[1] is None):

self.gene_type = gene_type

self.gene_type_single = True

elif type(gene_type) in [list, tuple, numpy.ndarray]:

if not len(gene_type) == num_genes:

self.valid_parameters = False

raise TypeError("When the parameter 'gene_type' is nested, then it can be either [float, int<precision>] or with length equal to the value passed to the 'num_genes' parameter. Instead, value {gene_type_val} with len(gene_type) ({len_gene_type}) != len(num_genes) ({num_genes}) found.".format(gene_type_val=gene_type, len_gene_type=len(gene_type), num_genes=num_genes))

for gene_type_idx, gene_type_val in enumerate(gene_type):

if gene_type_val in GA.supported_float_types:

# If the gene type is float and no precision is passed, set it to None.

gene_type[gene_type_idx] = [gene_type_val, None]

elif gene_type_val in GA.supported_int_types:

gene_type[gene_type_idx] = [gene_type_val, None]

elif type(gene_type_val) in [list, tuple, numpy.ndarray]:

# A float type is expected in a list/tuple/numpy.ndarray of length 2.

if len(gene_type_val) == 2:

if gene_type_val[0] in GA.supported_float_types:

if type(gene_type_val[1]) in GA.supported_int_types:

pass

else:

self.valid_parameters = False

raise ValueError("In the 'gene_type' parameter, the precision for float gene data types must be an integer but the element {gene_type_val} at index {gene_type_idx} has a precision of {gene_type_precision_val} with type {gene_type_type} .".format(gene_type_val=gene_type_val, gene_type_precision_val=gene_type_val[1], gene_type_type=gene_type_val[0], gene_type_idx=gene_type_idx))

else:

self.valid_parameters = False

raise ValueError("In the 'gene_type' parameter, a precision is expected only for float gene data types but the element {gene_type} found at index {gene_type_idx}. Note that the data type must be at index 0 followed by precision at index 1.".format(gene_type=gene_type_val, gene_type_idx=gene_type_idx))

else:

self.valid_parameters = False

raise ValueError("In the 'gene_type' parameter, a precision is specified in a list/tuple/numpy.ndarray of length 2 but value ({gene_type_val}) of type {gene_type_type} with length {gene_type_length} found at index {gene_type_idx}.".format(gene_type_val=gene_type_val, gene_type_type=type(gene_type_val), gene_type_idx=gene_type_idx, gene_type_length=len(gene_type_val)))

else:

self.valid_parameters = False

raise ValueError("When a list/tuple/numpy.ndarray is assigned to the 'gene_type' parameter, then its elements must be of integer, floating-point, list, tuple, or numpy.ndarray data types but the value ({gene_type_val}) of type {gene_type_type} found at index {gene_type_idx}.".format(gene_type_val=gene_type_val, gene_type_type=type(gene_type_val), gene_type_idx=gene_type_idx))

self.gene_type = gene_type

self.gene_type_single = False

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'gene_type' parameter must be either a single integer, floating-point, list, tuple, or numpy.ndarray but ({gene_type_val}) of type {gene_type_type} found.".format(gene_type_val=gene_type, gene_type_type=type(gene_type)))

# Build the initial population

if initial_population is None:

if (sol_per_pop is None) or (num_genes is None):

self.valid_parameters = False

raise ValueError("Error creating the initail population\n\nWhen the parameter initial_population is None, then neither of the 2 parameters sol_per_pop and num_genes can be None at the same time.\nThere are 2 options to prepare the initial population:\n1) Create an initial population and assign it to the initial_population parameter. In this case, the values of the 2 parameters sol_per_pop and num_genes will be deduced.\n2) Allow the genetic algorithm to create the initial population automatically by passing valid integer values to the sol_per_pop and num_genes parameters.")

elif (type(sol_per_pop) is int) and (type(num_genes) is int):

# Validating the number of solutions in the population (sol_per_pop)

if sol_per_pop <= 0:

self.valid_parameters = False

raise ValueError("The number of solutions in the population (sol_per_pop) must be > 0 but ({sol_per_pop}) found. \nThe following parameters must be > 0: \n1) Population size (i.e. number of solutions per population) (sol_per_pop).\n2) Number of selected parents in the mating pool (num_parents_mating).\n".format(sol_per_pop=sol_per_pop))

# Validating the number of gene.

if (num_genes <= 0):

self.valid_parameters = False

raise ValueError("The number of genes cannot be <= 0 but ({num_genes}) found.\n".format(num_genes=num_genes))

# When initial_population=None and the 2 parameters sol_per_pop and num_genes have valid integer values, then the initial population is created.

# Inside the initialize_population() method, the initial_population attribute is assigned to keep the initial population accessible.

self.num_genes = num_genes # Number of genes in the solution.

# In case the 'gene_space' parameter is nested, then make sure the number of its elements equals to the number of genes.

if self.gene_space_nested:

if len(gene_space) != self.num_genes:

self.valid_parameters = False

raise TypeError("When the parameter 'gene_space' is nested, then its length must be equal to the value passed to the 'num_genes' parameter. Instead, length of gene_space ({len_gene_space}) != num_genes ({num_genes})".format(len_gene_space=len(gene_space), num_genes=self.num_genes))

self.sol_per_pop = sol_per_pop # Number of solutions in the population.

self.initialize_population(self.init_range_low, self.init_range_high, allow_duplicate_genes, True, self.gene_type)

else:

self.valid_parameters = False

raise TypeError("The expected type of both the sol_per_pop and num_genes parameters is int but ({sol_per_pop_type}) and {num_genes_type} found.".format(sol_per_pop_type=type(sol_per_pop), num_genes_type=type(num_genes)))

elif numpy.array(initial_population).ndim != 2:

self.valid_parameters = False

raise ValueError("A 2D list is expected to the initail_population parameter but a ({initial_population_ndim}-D) list found.".format(initial_population_ndim=numpy.array(initial_population).ndim))

else:

# Forcing the initial_population array to have the data type assigned to the gene_type parameter.

if self.gene_type_single == True:

if self.gene_type[1] == None:

self.initial_population = numpy.array(initial_population, dtype=self.gene_type[0])

else:

self.initial_population = numpy.round(numpy.array(initial_population, dtype=self.gene_type[0]), self.gene_type[1])

else:

initial_population = numpy.array(initial_population)

self.initial_population = numpy.zeros(shape=(initial_population.shape[0], initial_population.shape[1]), dtype=object)

for gene_idx in range(initial_population.shape[1]):

if self.gene_type[gene_idx][1] is None:

self.initial_population[:, gene_idx] = numpy.asarray(initial_population[:, gene_idx],

dtype=self.gene_type[gene_idx][0])

else:

self.initial_population[:, gene_idx] = numpy.round(numpy.asarray(initial_population[:, gene_idx],

dtype=self.gene_type[gene_idx][0]),

self.gene_type[gene_idx][1])

self.population = self.initial_population.copy() # A NumPy array holding the initial population.

self.num_genes = self.initial_population.shape[1] # Number of genes in the solution.

self.sol_per_pop = self.initial_population.shape[0] # Number of solutions in the population.

self.pop_size = (self.sol_per_pop,self.num_genes) # The population size.

# Round initial_population and population

self.initial_population = self.round_genes(self.initial_population)

self.population = self.round_genes(self.population)

# In case the 'gene_space' parameter is nested, then make sure the number of its elements equals to the number of genes.

if self.gene_space_nested:

if len(gene_space) != self.num_genes:

self.valid_parameters = False

raise TypeError("When the parameter 'gene_space' is nested, then its length must be equal to the value passed to the 'num_genes' parameter. Instead, length of gene_space ({len_gene_space}) != num_genes ({len_num_genes})".format(len_gene_space=len(gene_space), len_num_genes=self.num_genes))

# Validating the number of parents to be selected for mating (num_parents_mating)

if num_parents_mating <= 0:

self.valid_parameters = False

raise ValueError("The number of parents mating (num_parents_mating) parameter must be > 0 but ({num_parents_mating}) found. \nThe following parameters must be > 0: \n1) Population size (i.e. number of solutions per population) (sol_per_pop).\n2) Number of selected parents in the mating pool (num_parents_mating).\n".format(num_parents_mating=num_parents_mating))

# Validating the number of parents to be selected for mating: num_parents_mating

if (num_parents_mating > self.sol_per_pop):

self.valid_parameters = False

raise ValueError("The number of parents to select for mating ({num_parents_mating}) cannot be greater than the number of solutions in the population ({sol_per_pop}) (i.e., num_parents_mating must always be <= sol_per_pop).\n".format(num_parents_mating=num_parents_mating, sol_per_pop=self.sol_per_pop))

self.num_parents_mating = num_parents_mating

# crossover: Refers to the method that applies the crossover operator based on the selected type of crossover in the crossover_type property.

# Validating the crossover type: crossover_type

if (crossover_type is None):

self.crossover = None

elif not (type(crossover_type) is str):

self.valid_parameters = False

raise TypeError("The expected type of the 'crossover_type' parameter is str but ({crossover_type}) found.".format(crossover_type=type(crossover_type)))

else: # type crossover_type is str

crossover_type = crossover_type.lower()

if (crossover_type == "single_point"):

self.crossover = self.single_point_crossover

elif (crossover_type == "two_points"):

self.crossover = self.two_points_crossover

elif (crossover_type == "uniform"):

self.crossover = self.uniform_crossover

elif (crossover_type == "scattered"):

self.crossover = self.scattered_crossover

else:

self.valid_parameters = False

raise ValueError("Undefined crossover type. \nThe assigned value to the crossover_type ({crossover_type}) argument does not refer to one of the supported crossover types which are: \n-single_point (for single point crossover)\n-two_points (for two points crossover)\n-uniform (for uniform crossover)\n-scattered (for scattered crossover).\n".format(crossover_type=crossover_type))

self.crossover_type = crossover_type

# Calculate the value of crossover_probability

if crossover_probability is None:

self.crossover_probability = None

elif type(crossover_probability) in GA.supported_int_float_types:

if crossover_probability >= 0 and crossover_probability <= 1:

self.crossover_probability = crossover_probability

else:

self.valid_parameters = False

raise ValueError("The value assigned to the 'crossover_probability' parameter must be between 0 and 1 inclusive but ({crossover_probability_value}) found.".format(crossover_probability_value=crossover_probability))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for the 'crossover_probability' parameter. Float is expected but ({crossover_probability_value}) of type {crossover_probability_type} found.".format(crossover_probability_value=crossover_probability, crossover_probability_type=type(crossover_probability)))

# mutation: Refers to the method that applies the mutation operator based on the selected type of mutation in the mutation_type property.

# Validating the mutation type: mutation_type

# "adaptive" mutation is supported starting from PyGAD 2.10.0

if mutation_type is None:

self.mutation = None

elif not (type(mutation_type) is str):

self.valid_parameters = False

raise TypeError("The expected type of the 'mutation_type' parameter is str but ({mutation_type}) found.".format(mutation_type=type(mutation_type)))

else: # type mutation_type is str

mutation_type = mutation_type.lower()

if (mutation_type == "random"):

self.mutation = self.random_mutation

elif (mutation_type == "swap"):

self.mutation = self.swap_mutation

elif (mutation_type == "scramble"):

self.mutation = self.scramble_mutation

elif (mutation_type == "inversion"):

self.mutation = self.inversion_mutation

elif (mutation_type == "adaptive"):

self.mutation = self.adaptive_mutation

else:

self.valid_parameters = False

raise ValueError("Undefined mutation type. \nThe assigned value to the mutation_type argument ({mutation_type}) does not refer to one of the supported mutation types which are: \n-random (for random mutation)\n-swap (for swap mutation)\n-inversion (for inversion mutation)\n-scramble (for scramble mutation)\n-adaptive (for adaptive mutation).\n".format(mutation_type=mutation_type))

self.mutation_type = mutation_type

# Calculate the value of mutation_probability

if not (self.mutation_type is None):

if mutation_probability is None:

self.mutation_probability = None

elif (mutation_type != "adaptive"):

# Mutation probability is fixed not adaptive.

if type(mutation_probability) in GA.supported_int_float_types:

if mutation_probability >= 0 and mutation_probability <= 1:

self.mutation_probability = mutation_probability

else:

self.valid_parameters = False

raise ValueError("The value assigned to the 'mutation_probability' parameter must be between 0 and 1 inclusive but ({mutation_probability_value}) found.".format(mutation_probability_value=mutation_probability))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for the 'mutation_probability' parameter. A numeric value is expected but ({mutation_probability_value}) of type {mutation_probability_type} found.".format(mutation_probability_value=mutation_probability, mutation_probability_type=type(mutation_probability)))

else:

# Mutation probability is adaptive not fixed.

if type(mutation_probability) in [list, tuple, numpy.ndarray]:

if len(mutation_probability) == 2:

for el in mutation_probability:

if type(el) in GA.supported_int_float_types:

if el >= 0 and el <= 1:

pass

else:

self.valid_parameters = False

raise ValueError("The values assigned to the 'mutation_probability' parameter must be between 0 and 1 inclusive but ({mutation_probability_value}) found.".format(mutation_probability_value=el))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for a value assigned to the 'mutation_probability' parameter. A numeric value is expected but ({mutation_probability_value}) of type {mutation_probability_type} found.".format(mutation_probability_value=el, mutation_probability_type=type(el)))

if mutation_probability[0] < mutation_probability[1]:

if not self.suppress_warnings: warnings.warn("The first element in the 'mutation_probability' parameter is {first_el} which is smaller than the second element {second_el}. This means the mutation rate for the high-quality solutions is higher than the mutation rate of the low-quality ones. This causes high disruption in the high qualitiy solutions while making little changes in the low quality solutions. Please make the first element higher than the second element.".format(first_el=mutation_probability[0], second_el=mutation_probability[1]))

self.mutation_probability = mutation_probability

else:

self.valid_parameters = False

raise ValueError("When mutation_type='adaptive', then the 'mutation_probability' parameter must have only 2 elements but ({mutation_probability_length}) element(s) found.".format(mutation_probability_length=len(mutation_probability)))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for the 'mutation_probability' parameter. When mutation_type='adaptive', then list/tuple/numpy.ndarray is expected but ({mutation_probability_value}) of type {mutation_probability_type} found.".format(mutation_probability_value=mutation_probability, mutation_probability_type=type(mutation_probability)))

else:

pass

# Calculate the value of mutation_num_genes

if not (self.mutation_type is None):

if mutation_num_genes is None:

# The mutation_num_genes parameter does not exist. Checking whether adaptive mutation is used.

if (mutation_type != "adaptive"):

# The percent of genes to mutate is fixed not adaptive.

if mutation_percent_genes == 'default'.lower():

mutation_percent_genes = 10

# Based on the mutation percentage in the 'mutation_percent_genes' parameter, the number of genes to mutate is calculated.

mutation_num_genes = numpy.uint32((mutation_percent_genes*self.num_genes)/100)

# Based on the mutation percentage of genes, if the number of selected genes for mutation is less than the least possible value which is 1, then the number will be set to 1.

if mutation_num_genes == 0:

if self.mutation_probability is None:

if not self.suppress_warnings: warnings.warn("The percentage of genes to mutate (mutation_percent_genes={mutation_percent}) resutled in selecting ({mutation_num}) genes. The number of genes to mutate is set to 1 (mutation_num_genes=1).\nIf you do not want to mutate any gene, please set mutation_type=None.".format(mutation_percent=mutation_percent_genes, mutation_num=mutation_num_genes))

mutation_num_genes = 1

elif type(mutation_percent_genes) in GA.supported_int_float_types:

if (mutation_percent_genes <= 0 or mutation_percent_genes > 100):

self.valid_parameters = False

raise ValueError("The percentage of selected genes for mutation (mutation_percent_genes) must be > 0 and <= 100 but ({mutation_percent_genes}) found.\n".format(mutation_percent_genes=mutation_percent_genes))

else:

# If mutation_percent_genes equals the string "default", then it is replaced by the numeric value 10.

if mutation_percent_genes == 'default'.lower():

mutation_percent_genes = 10

# Based on the mutation percentage in the 'mutation_percent_genes' parameter, the number of genes to mutate is calculated.

mutation_num_genes = numpy.uint32((mutation_percent_genes*self.num_genes)/100)

# Based on the mutation percentage of genes, if the number of selected genes for mutation is less than the least possible value which is 1, then the number will be set to 1.

if mutation_num_genes == 0:

if self.mutation_probability is None:

if not self.suppress_warnings: warnings.warn("The percentage of genes to mutate (mutation_percent_genes={mutation_percent}) resutled in selecting ({mutation_num}) genes. The number of genes to mutate is set to 1 (mutation_num_genes=1).\nIf you do not want to mutate any gene, please set mutation_type=None.".format(mutation_percent=mutation_percent_genes, mutation_num=mutation_num_genes))

mutation_num_genes = 1

else:

self.valid_parameters = False

raise ValueError("Unexpected value or type of the 'mutation_percent_genes' parameter. It only accepts the string 'default' or a numeric value but ({mutation_percent_genes_value}) of type {mutation_percent_genes_type} found.".format(mutation_percent_genes_value=mutation_percent_genes, mutation_percent_genes_type=type(mutation_percent_genes)))

else:

# The percent of genes to mutate is adaptive not fixed.

if type(mutation_percent_genes) in [list, tuple, numpy.ndarray]:

if len(mutation_percent_genes) == 2:

mutation_num_genes = numpy.zeros_like(mutation_percent_genes, dtype=numpy.uint32)

for idx, el in enumerate(mutation_percent_genes):

if type(el) in GA.supported_int_float_types:

if (el <= 0 or el > 100):

self.valid_parameters = False

raise ValueError("The values assigned to the 'mutation_percent_genes' must be > 0 and <= 100 but ({mutation_percent_genes}) found.\n".format(mutation_percent_genes=mutation_percent_genes))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for a value assigned to the 'mutation_percent_genes' parameter. An integer value is expected but ({mutation_percent_genes_value}) of type {mutation_percent_genes_type} found.".format(mutation_percent_genes_value=el, mutation_percent_genes_type=type(el)))

# At this point of the loop, the current value assigned to the parameter 'mutation_percent_genes' is validated.

# Based on the mutation percentage in the 'mutation_percent_genes' parameter, the number of genes to mutate is calculated.

mutation_num_genes[idx] = numpy.uint32((mutation_percent_genes[idx]*self.num_genes)/100)

# Based on the mutation percentage of genes, if the number of selected genes for mutation is less than the least possible value which is 1, then the number will be set to 1.

if mutation_num_genes[idx] == 0:

if not self.suppress_warnings: warnings.warn("The percentage of genes to mutate ({mutation_percent}) resutled in selecting ({mutation_num}) genes. The number of genes to mutate is set to 1 (mutation_num_genes=1).\nIf you do not want to mutate any gene, please set mutation_type=None.".format(mutation_percent=mutation_percent_genes[idx], mutation_num=mutation_num_genes[idx]))

mutation_num_genes[idx] = 1

if mutation_percent_genes[0] < mutation_percent_genes[1]:

if not self.suppress_warnings: warnings.warn("The first element in the 'mutation_percent_genes' parameter is ({first_el}) which is smaller than the second element ({second_el}).\nThis means the mutation rate for the high-quality solutions is higher than the mutation rate of the low-quality ones. This causes high disruption in the high qualitiy solutions while making little changes in the low quality solutions.\nPlease make the first element higher than the second element.".format(first_el=mutation_percent_genes[0], second_el=mutation_percent_genes[1]))

# At this point outside the loop, all values of the parameter 'mutation_percent_genes' are validated. Eveyrthing is OK.

else:

self.valid_parameters = False

raise ValueError("When mutation_type='adaptive', then the 'mutation_percent_genes' parameter must have only 2 elements but ({mutation_percent_genes_length}) element(s) found.".format(mutation_percent_genes_length=len(mutation_percent_genes)))

else:

if self.mutation_probability is None:

self.valid_parameters = False

raise ValueError("Unexpected type for the 'mutation_percent_genes' parameter. When mutation_type='adaptive', then the 'mutation_percent_genes' parameter should exist and assigned a list/tuple/numpy.ndarray with 2 values but ({mutation_percent_genes_value}) found.".format(mutation_percent_genes_value=mutation_percent_genes))

# The mutation_num_genes parameter exists. Checking whether adaptive mutation is used.

elif (mutation_type != "adaptive"):

# Number of genes to mutate is fixed not adaptive.

if type(mutation_num_genes) in GA.supported_int_types:

if (mutation_num_genes <= 0):

self.valid_parameters = False

raise ValueError("The number of selected genes for mutation (mutation_num_genes) cannot be <= 0 but ({mutation_num_genes}) found. If you do not want to use mutation, please set mutation_type=None\n".format(mutation_num_genes=mutation_num_genes))

elif (mutation_num_genes > self.num_genes):

self.valid_parameters = False

raise ValueError("The number of selected genes for mutation (mutation_num_genes), which is ({mutation_num_genes}), cannot be greater than the number of genes ({num_genes}).\n".format(mutation_num_genes=mutation_num_genes, num_genes=self.num_genes))

else:

self.valid_parameters = False

raise ValueError("The 'mutation_num_genes' parameter is expected to be a positive integer but the value ({mutation_num_genes_value}) of type {mutation_num_genes_type} found.\n".format(mutation_num_genes_value=mutation_num_genes, mutation_num_genes_type=type(mutation_num_genes)))

else:

# Number of genes to mutate is adaptive not fixed.

if type(mutation_num_genes) in [list, tuple, numpy.ndarray]:

if len(mutation_num_genes) == 2:

for el in mutation_num_genes:

if type(el) in GA.supported_int_types:

if (el <= 0):

self.valid_parameters = False

raise ValueError("The values assigned to the 'mutation_num_genes' cannot be <= 0 but ({mutation_num_genes_value}) found. If you do not want to use mutation, please set mutation_type=None\n".format(mutation_num_genes_value=el))

elif (el > self.num_genes):

self.valid_parameters = False

raise ValueError("The values assigned to the 'mutation_num_genes' cannot be greater than the number of genes ({num_genes}) but ({mutation_num_genes_value}) found.\n".format(mutation_num_genes_value=el, num_genes=self.num_genes))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for a value assigned to the 'mutation_num_genes' parameter. An integer value is expected but ({mutation_num_genes_value}) of type {mutation_num_genes_type} found.".format(mutation_num_genes_value=el, mutation_num_genes_type=type(el)))

# At this point of the loop, the current value assigned to the parameter 'mutation_num_genes' is validated.

if mutation_num_genes[0] < mutation_num_genes[1]:

if not self.suppress_warnings: warnings.warn("The first element in the 'mutation_num_genes' parameter is {first_el} which is smaller than the second element {second_el}. This means the mutation rate for the high-quality solutions is higher than the mutation rate of the low-quality ones. This causes high disruption in the high qualitiy solutions while making little changes in the low quality solutions. Please make the first element higher than the second element.".format(first_el=mutation_num_genes[0], second_el=mutation_num_genes[1]))

# At this point outside the loop, all values of the parameter 'mutation_num_genes' are validated. Eveyrthing is OK.

else:

self.valid_parameters = False

raise ValueError("When mutation_type='adaptive', then the 'mutation_num_genes' parameter must have only 2 elements but ({mutation_num_genes_length}) element(s) found.".format(mutation_num_genes_length=len(mutation_num_genes)))

else:

self.valid_parameters = False

raise ValueError("Unexpected type for the 'mutation_num_genes' parameter. When mutation_type='adaptive', then list/tuple/numpy.ndarray is expected but ({mutation_num_genes_value}) of type {mutation_num_genes_type} found.".format(mutation_num_genes_value=mutation_num_genes, mutation_num_genes_type=type(mutation_num_genes)))

else:

pass

# Validating mutation_by_replacement and mutation_type

if self.mutation_type != "random" and self.mutation_by_replacement:

if not self.suppress_warnings: warnings.warn("The mutation_by_replacement parameter is set to True while the mutation_type parameter is not set to random but ({mut_type}). Note that the mutation_by_replacement parameter has an effect only when mutation_type='random'.".format(mut_type=mutation_type))

# Check if crossover and mutation are both disabled.

if (self.mutation_type is None) and (self.crossover_type is None):

if not self.suppress_warnings: warnings.warn("The 2 parameters mutation_type and crossover_type are None. This disables any type of evolution the genetic algorithm can make. As a result, the genetic algorithm cannot find a better solution that the best solution in the initial population.")

# select_parents: Refers to a method that selects the parents based on the parent selection type specified in the parent_selection_type attribute.

# Validating the selected type of parent selection: parent_selection_type

if not (type(parent_selection_type) is str):

self.valid_parameters = False

raise TypeError("The expected type of the 'parent_selection_type' parameter is str but ({parent_selection_type}) found.".format(parent_selection_type=type(parent_selection_type)))

parent_selection_type = parent_selection_type.lower()

if (parent_selection_type == "sss"):

self.select_parents = self.steady_state_selection

elif (parent_selection_type == "rws"):

self.select_parents = self.roulette_wheel_selection

elif (parent_selection_type == "sus"):

self.select_parents = self.stochastic_universal_selection

elif (parent_selection_type == "random"):

self.select_parents = self.random_selection

elif (parent_selection_type == "tournament"):

self.select_parents = self.tournament_selection

elif (parent_selection_type == "rank"):

self.select_parents = self.rank_selection

else:

self.valid_parameters = False

raise ValueError("Undefined parent selection type: {parent_selection_type}. \nThe assigned value to the parent_selection_type argument does not refer to one of the supported parent selection techniques which are: \n-sss (for steady state selection)\n-rws (for roulette wheel selection)\n-sus (for stochastic universal selection)\n-rank (for rank selection)\n-random (for random selection)\n-tournament (for tournament selection).\n".format(parent_selection_type=parent_selection_type))

# For tournament selection, validate the K value.

if(parent_selection_type == "tournament"):

if (K_tournament > self.sol_per_pop):

K_tournament = self.sol_per_pop

if not self.suppress_warnings: warnings.warn("K of the tournament selection ({K_tournament}) should not be greater than the number of solutions within the population ({sol_per_pop}).\nK will be clipped to be equal to the number of solutions in the population (sol_per_pop).\n".format(K_tournament=K_tournament, sol_per_pop=self.sol_per_pop))

elif (K_tournament <= 0):

self.valid_parameters = False

raise ValueError("K of the tournament selection cannot be <=0 but ({K_tournament}) found.\n".format(K_tournament=K_tournament))

self.K_tournament = K_tournament

# Validating the number of parents to keep in the next population: keep_parents

if (keep_parents > self.sol_per_pop or keep_parents > self.num_parents_mating or keep_parents < -1):

self.valid_parameters = False

raise ValueError("Incorrect value to the keep_parents parameter: {keep_parents}. \nThe assigned value to the keep_parent parameter must satisfy the following conditions: \n1) Less than or equal to sol_per_pop\n2) Less than or equal to num_parents_mating\n3) Greater than or equal to -1.".format(keep_parents=keep_parents))

self.keep_parents = keep_parents

if parent_selection_type == "sss" and self.keep_parents == 0:

if not self.suppress_warnings: warnings.warn("The steady-state parent (sss) selection operator is used despite that no parents are kept in the next generation.")

# Validate keep_parents.

if (self.keep_parents == -1): # Keep all parents in the next population.

self.num_offspring = self.sol_per_pop - self.num_parents_mating

elif (self.keep_parents == 0): # Keep no parents in the next population.

self.num_offspring = self.sol_per_pop

elif (self.keep_parents > 0): # Keep the specified number of parents in the next population.

self.num_offspring = self.sol_per_pop - self.keep_parents

# Check if the fitness_func is a function.

if callable(fitness_func):

# Check if the fitness function accepts 2 paramaters.

if (fitness_func.__code__.co_argcount == 2):

self.fitness_func = fitness_func

else:

self.valid_parameters = False

raise ValueError("The fitness function must accept 2 parameters representing the solution to which the fitness value is calculated and the solution index within the population.\nThe passed fitness function named '{funcname}' accepts {argcount} argument(s).".format(funcname=fitness_func.__code__.co_name, argcount=fitness_func.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the fitness_func parameter is expected to be of type function but ({fitness_func_type}) found.".format(fitness_func_type=type(fitness_func)))

# Check if the on_start exists.

if not (on_start is None):

# Check if the on_start is a function.

if callable(on_start):

# Check if the on_start function accepts only a single paramater.

if (on_start.__code__.co_argcount == 1):

self.on_start = on_start

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_start parameter must accept only 1 parameter representing the instance of the genetic algorithm.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_start.__code__.co_name, argcount=on_start.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_start parameter is expected to be of type function but ({on_start_type}) found.".format(on_start_type=type(on_start)))

else:

self.on_start = None

# Check if the on_fitness exists.

if not (on_fitness is None):

# Check if the on_fitness is a function.

if callable(on_fitness):

# Check if the on_fitness function accepts 2 paramaters.

if (on_fitness.__code__.co_argcount == 2):

self.on_fitness = on_fitness

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_fitness parameter must accept 2 parameters representing the instance of the genetic algorithm and the fitness values of all solutions.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_fitness.__code__.co_name, argcount=on_fitness.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_fitness parameter is expected to be of type function but ({on_fitness_type}) found.".format(on_fitness_type=type(on_fitness)))

else:

self.on_fitness = None

# Check if the on_parents exists.

if not (on_parents is None):

# Check if the on_parents is a function.

if callable(on_parents):

# Check if the on_parents function accepts 2 paramaters.

if (on_parents.__code__.co_argcount == 2):

self.on_parents = on_parents

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_parents parameter must accept 2 parameters representing the instance of the genetic algorithm and the fitness values of all solutions.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_parents.__code__.co_name, argcount=on_parents.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_parents parameter is expected to be of type function but ({on_parents_type}) found.".format(on_parents_type=type(on_parents)))

else:

self.on_parents = None

# Check if the on_crossover exists.

if not (on_crossover is None):

# Check if the on_crossover is a function.

if callable(on_crossover):

# Check if the on_crossover function accepts 2 paramaters.

if (on_crossover.__code__.co_argcount == 2):

self.on_crossover = on_crossover

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_crossover parameter must accept 2 parameters representing the instance of the genetic algorithm and the offspring generated using crossover.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_crossover.__code__.co_name, argcount=on_crossover.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_crossover parameter is expected to be of type function but ({on_crossover_type}) found.".format(on_crossover_type=type(on_crossover)))

else:

self.on_crossover = None

# Check if the on_mutation exists.

if not (on_mutation is None):

# Check if the on_mutation is a function.

if callable(on_mutation):

# Check if the on_mutation function accepts 2 paramaters.

if (on_mutation.__code__.co_argcount == 2):

self.on_mutation = on_mutation

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_mutation parameter must accept 2 parameters representing the instance of the genetic algorithm and the offspring after applying the mutation operation.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_mutation.__code__.co_name, argcount=on_mutation.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_mutation parameter is expected to be of type function but ({on_mutation_type}) found.".format(on_mutation_type=type(on_mutation)))

else:

self.on_mutation = None

# Check if the callback_generation exists.

if not (callback_generation is None):

# Check if the callback_generation is a function.

if callable(callback_generation):

# Check if the callback_generation function accepts only a single paramater.

if (callback_generation.__code__.co_argcount == 1):

self.callback_generation = callback_generation

on_generation = callback_generation

if not self.suppress_warnings: warnings.warn("Starting from PyGAD 2.6.0, the callback_generation parameter is deprecated and will be removed in a later release of PyGAD. Please use the on_generation parameter instead.")

else:

self.valid_parameters = False

raise ValueError("The function assigned to the callback_generation parameter must accept only 1 parameter representing the instance of the genetic algorithm.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=callback_generation.__code__.co_name, argcount=callback_generation.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the callback_generation parameter is expected to be of type function but ({callback_generation_type}) found.".format(callback_generation_type=type(callback_generation)))

else:

self.callback_generation = None

# Check if the on_generation exists.

if not (on_generation is None):

# Check if the on_generation is a function.

if callable(on_generation):

# Check if the on_generation function accepts only a single paramater.

if (on_generation.__code__.co_argcount == 1):

self.on_generation = on_generation

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_generation parameter must accept only 1 parameter representing the instance of the genetic algorithm.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_generation.__code__.co_name, argcount=on_generation.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the on_generation parameter is expected to be of type function but ({on_generation_type}) found.".format(on_generation_type=type(on_generation)))

else:

self.on_generation = None

# Check if the on_stop exists.

if not (on_stop is None):

# Check if the on_stop is a function.

if callable(on_stop):

# Check if the on_stop function accepts 2 paramaters.

if (on_stop.__code__.co_argcount == 2):

self.on_stop = on_stop

else:

self.valid_parameters = False

raise ValueError("The function assigned to the on_stop parameter must accept 2 parameters representing the instance of the genetic algorithm and a list of the fitness values of the solutions in the last population.\nThe passed function named '{funcname}' accepts {argcount} argument(s).".format(funcname=on_stop.__code__.co_name, argcount=on_stop.__code__.co_argcount))

else:

self.valid_parameters = False

raise ValueError("The value assigned to the 'on_stop' parameter is expected to be of type function but ({on_stop_type}) found.".format(on_stop_type=type(on_stop)))

else:

self.on_stop = None

# Validate delay_after_gen

if type(delay_after_gen) in GA.supported_int_float_types:

if delay_after_gen >= 0.0:

self.delay_after_gen = delay_after_gen

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'delay_after_gen' parameter must be a non-negative number. The value passed is {delay_after_gen} of type {delay_after_gen_type}.".format(delay_after_gen=delay_after_gen, delay_after_gen_type=type(delay_after_gen)))

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'delay_after_gen' parameter must be of type int or float but ({delay_after_gen_type}) found.".format(delay_after_gen_type=type(delay_after_gen)))

# Validate save_best_solutions

if type(save_best_solutions) is bool:

if save_best_solutions == True:

if not self.suppress_warnings: warnings.warn("Use the 'save_best_solutions' parameter with caution as it may cause memory overflow when either the number of generations or number of genes is large.")

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'save_best_solutions' parameter must be of type bool but ({save_best_solutions_type}) found.".format(save_best_solutions_type=type(save_best_solutions)))

# Validate save_solutions

if type(save_solutions) is bool:

if save_solutions == True:

if not self.suppress_warnings: warnings.warn("Use the 'save_solutions' parameter with caution as it may cause memory overflow when either the number of generations, number of genes, or number of solutions in population is large.")

else:

self.valid_parameters = False

raise ValueError("The value passed to the 'save_solutions' parameter must be of type bool but ({save_solutions_type}) found.".format(save_solutions_type=type(save_solutions)))

# Validate allow_duplicate_genes

if not (type(allow_duplicate_genes) is bool):

self.valid_parameters = False

raise TypeError("The expected type of the 'allow_duplicate_genes' parameter is bool but ({allow_duplicate_genes_type}) found.".format(allow_duplicate_genes_type=type(allow_duplicate_genes)))

self.allow_duplicate_genes = allow_duplicate_genes

self.stop_criteria = []

self.supported_stop_words = ["reach", "saturate"]

if stop_criteria is None:

# None: Stop after passing through all generations.

self.stop_criteria = None

elif type(stop_criteria) is str:

# reach_{target_fitness}: Stop if the target fitness value is reached.

# saturate_{num_generations}: Stop if the fitness value does not change (saturates) for the given number of generations.

criterion = stop_criteria.split("_")

if len(criterion) == 2:

stop_word = criterion[0]

number = criterion[1]

if stop_word in self.supported_stop_words:

pass

else:

self.valid_parameters = False

raise TypeError("In the 'stop_criteria' parameter, the supported stop words are '{supported_stop_words}' but '{stop_word}' found.".format(supported_stop_words=self.supported_stop_words, stop_word=stop_word))

if number.replace(".", "").isnumeric():

number = float(number)

else:

self.valid_parameters = False

raise TypeError("The value following the stop word in the 'stop_criteria' parameter must be a number but the value '{stop_val}' of type {stop_val_type} found.".format(stop_val=number, stop_val_type=type(number)))

self.stop_criteria.append([stop_word, number])

else:

self.valid_parameters = False

raise TypeError("For format of a single criterion in the 'stop_criteria' parameter is 'word_number' but '{stop_criteria}' found.".format(stop_criteria=stop_criteria))

elif type(stop_criteria) in [list, tuple, numpy.ndarray]:

# Remove duplicate criterira by converting the list to a set then back to a list.

stop_criteria = list(set(stop_criteria))

for idx, val in enumerate(stop_criteria):

if type(val) is str:

criterion = val.split("_")

if len(criterion) == 2:

stop_word = criterion[0]

number = criterion[1]

if stop_word in self.supported_stop_words:

pass

else:

self.valid_parameters = False

raise TypeError("In the 'stop_criteria' parameter, the supported stop words are {supported_stop_words} but '{stop_word}' found.".format(supported_stop_words=self.supported_stop_words, stop_word=stop_word))

if number.replace(".", "").isnumeric():

number = float(number)

else:

self.valid_parameters = False

raise TypeError("The value following the stop word in the 'stop_criteria' parameter must be a number but the value '{stop_val}' of type {stop_val_type} found.".format(stop_val=number, stop_val_type=type(number)))

self.stop_criteria.append([stop_word, number])

else:

self.valid_parameters = False

raise TypeError("For format of a single criterion in the 'stop_criteria' parameter is 'word_number' but {stop_criteria} found.".format(stop_criteria=criterion))

else:

self.valid_parameters = False

raise TypeError("When the 'stop_criteria' parameter is assigned a tuple/list/numpy.ndarray, then its elements must be strings but the value '{stop_criteria_val}' of type {stop_criteria_val_type} found at index {stop_criteria_val_idx}.".format(stop_criteria_val=val, stop_criteria_val_type=type(val), stop_criteria_val_idx=idx))

else:

self.valid_parameters = False

raise TypeError("The expected value of the 'stop_criteria' is a single string or a list/tuple/numpy.ndarray of strings but the value {stop_criteria_val} of type {stop_criteria_type} found.".format(stop_criteria_val=stop_criteria, stop_criteria_type=type(stop_criteria)))

# The number of completed generations.

self.generations_completed = 0

# At this point, all necessary parameters validation is done successfully and we are sure that the parameters are valid.

self.valid_parameters = True # Set to True when all the parameters passed in the GA class constructor are valid.

# Parameters of the genetic algorithm.

self.num_generations = abs(num_generations)

self.parent_selection_type = parent_selection_type

# Parameters of the mutation operation.

self.mutation_percent_genes = mutation_percent_genes

self.mutation_num_genes = mutation_num_genes

# Even such this parameter is declared in the class header, it is assigned to the object here to access it after saving the object.

self.best_solutions_fitness = [] # A list holding the fitness value of the best solution for each generation.

self.best_solution_generation = -1 # The generation number at which the best fitness value is reached. It is only assigned the generation number after the `run()` method completes. Otherwise, its value is -1.

self.save_best_solutions = save_best_solutions

self.best_solutions = [] # Holds the best solution in each generation.

self.save_solutions = save_solutions

self.solutions = [] # Holds the solutions in each generation.

self.solutions_fitness = [] # Holds the fitness of the solutions in each generation.

self.last_generation_fitness = None # A list holding the fitness values of all solutions in the last generation.

self.last_generation_parents = None # A list holding the parents of the last generation.

self.last_generation_offspring_crossover = None # A list holding the offspring after applying crossover in the last generation.

self.last_generation_offspring_mutation = None # A list holding the offspring after applying mutation in the last generation.

def round_genes(self, solutions):

for gene_idx in range(self.num_genes):

if self.gene_type_single:

if not self.gene_type[1] is None:

solutions[:, gene_idx] = numpy.round(solutions[:, gene_idx], self.gene_type[1])

else:

if not self.gene_type[gene_idx][1] is None:

solutions[:, gene_idx] = numpy.round(numpy.asarray(solutions[:, gene_idx],

dtype=self.gene_type[gene_idx][0]),

self.gene_type[gene_idx][1])

return solutions

def initialize_population(self, low, high, allow_duplicate_genes, mutation_by_replacement, gene_type):

"""

# Population size = (number of chromosomes, number of genes per chromosome)

self.pop_size = (self.sol_per_pop,self.num_genes) # The population will have sol_per_pop chromosome where each chromosome has num_genes genes.

if self.gene_space is None:

# Creating the initial population randomly.

if self.gene_type_single == True:

self.population = numpy.asarray(numpy.random.uniform(low=low,

high=high,

size=self.pop_size),

dtype=self.gene_type[0]) # A NumPy array holding the initial population.

else:

# Create an empty population of dtype=object to support storing mixed data types within the same array.

self.population = numpy.zeros(shape=self.pop_size, dtype=object)

# Loop through the genes, randomly generate the values of a single gene across the entire population, and add the values of each gene to the population.

for gene_idx in range(self.num_genes):

# A vector of all values of this single gene across all solutions in the population.

gene_values = numpy.asarray(numpy.random.uniform(low=low,

high=high,

size=self.pop_size[0]),

dtype=self.gene_type[gene_idx][0])

# Adding the current gene values to the population.

self.population[:, gene_idx] = gene_values

if allow_duplicate_genes == False:

for solution_idx in range(self.population.shape[0]):

# print("Before", self.population[solution_idx])

self.population[solution_idx], _, _ = self.solve_duplicate_genes_randomly(solution=self.population[solution_idx],

min_val=low,

max_val=high,

mutation_by_replacement=True,

gene_type=gene_type,

num_trials=10)

# print("After", self.population[solution_idx])

elif self.gene_space_nested:

if self.gene_type_single == True:

self.population = numpy.zeros(shape=self.pop_size, dtype=self.gene_type[0])

for sol_idx in range(self.sol_per_pop):

for gene_idx in range(self.num_genes):

if type(self.gene_space[gene_idx]) in [list, tuple, range]:

# Check if the gene space has None values. If any, then replace it with randomly generated values according to the 3 attributes init_range_low, init_range_high, and gene_type.

if type(self.gene_space[gene_idx]) is range:

temp = self.gene_space[gene_idx]

else:

temp = self.gene_space[gene_idx].copy()

for idx, val in enumerate(self.gene_space[gene_idx]):

if val is None:

self.gene_space[gene_idx][idx] = numpy.asarray(numpy.random.uniform(low=low,

high=high,

size=1),

dtype=self.gene_type[0])[0]