Apply constraints with duplicates

Author: ahmedfgad

example.py

@@ -17,14 +17,17 @@ def fitness_func(ga_instance, solution, solution_idx):
                        num_genes=num_genes,
                        mutation_num_genes=6,
                        fitness_func=fitness_func,
-                       init_range_low=4,
-                       init_range_high=10,
+                       init_range_low=1,
+                       init_range_high=100,
                        # suppress_warnings=True,
-                       random_mutation_min_val=4,
-                       random_mutation_max_val=10,
+                       random_mutation_min_val=1,
+                       random_mutation_max_val=100,
                        mutation_by_replacement=True,
                        gene_type=int,
+                       allow_duplicate_genes=False,
                        # mutation_probability=0.4,
-                       gene_constraint=[lambda x: x[0]>=8,None,None,None,None,None])
+                       # gene_constraint=[lambda x: x[0]>=8,None,None,None,None,None],
+                       gene_constraint=[lambda x: x[0]>=98,lambda x: x[1]>=98,lambda x: x[2]<98,lambda x: x[3]<98,lambda x: x[4]<98,lambda x: x[5]<98],
+                       )
 
 # ga_instance.run()

pygad/__pycache__/pygad.cpython-310.pyc

@@ -9,12 +9,27 @@
 
 class Helper:
 
+    def get_gene_dtype(self, gene_index):
+
+        """
+        Returns the data type of the gene by its index.
+        It accepts a single parameter:
+            -gene_index: The index of the gene to get its data type. Only used if each gene has its own data type.
+        It returns the data type of the gene.
+        """
+
+        if self.gene_type_single == True:
+            dtype = self.gene_type
+        else:
+            dtype = self.gene_type[gene_index]
+        return dtype
+
     def get_random_mutation_range(self, gene_index):
 
         """
         Returns the minimum and maximum values of the mutation range.
         It accepts a single parameter:
-            -gene_index: The index of the gene to get its range. Only used if the gene has a specific mutation range
+            -gene_index: The index of the gene to get its range. Only used if the gene has a specific mutation range.
         It returns the minimum and maximum values of the gene mutation range.
         """
 
@@ -51,7 +66,8 @@ def generate_gene_random_value(self,
                                    gene_value,
                                    gene_idx, 
                                    mutation_by_replacement,
-                                   num_values=1):
+                                   num_values=1,
+                                   step=1):
         """
         Randomly generate one or more values for the gene.
         It accepts:
@@ -60,15 +76,39 @@ def generate_gene_random_value(self,
             -gene_value: The original gene value before applying mutation.
             -gene_idx: The index of the gene in the solution.
             -mutation_by_replacement: A flag indicating whether mutation by replacement is enabled or not. The reason is to make this helper method usable while generating the initial population. In this case, mutation_by_replacement does not matter and should be considered False.
-            -num_values: The number of random valus to generate. It tries to generate a number of values up to a maximum of num_values. But it is not always guranteed because the total number of values might not be enough or the random generator creates duplicate random values.
-        If num_values=1, it returns a single numeric value. If num_values>1, it returns an array with number of values equal to num_values.
+            -num_values: The number of random valus to generate. It tries to generate a number of values up to a maximum of num_values. But it is not always guranteed because the total number of values might not be enough or the random generator creates duplicate random values. For int data types, it could be None to keep all the values. For flaot data types, a None value returns only a single value.
+            -step (int, optional): The step size for generating candidate values. Defaults to 1. Only used with genes of an integer data type.
+
+        It returns,
+            -A single numeric value if num_values=1. Or 
+            -An array with number of values equal to num_values if num_values>1.
         """
 
-        # Generating a random value.
-        random_value = numpy.asarray(numpy.random.uniform(low=range_min, 
-                                                          high=range_max, 
-                                                          size=num_values),
-                                     dtype=object)
+        gene_type = self.get_gene_dtype(gene_index=gene_idx)
+        if gene_type[0] in pygad.GA.supported_int_types:
+            random_value = numpy.asarray(numpy.arange(range_min, 
+                                                      range_max, 
+                                                      step=step), 
+                                         dtype=gene_type[0])
+            if num_values is None:
+                # Keep all the values.
+                pass
+            else:
+                if num_values >= len(random_value):
+                    # Number of values is larger than or equal to the number of elements in random_value.
+                    # Makes no sense to create a larger sample out of the population because it just creates redundant values.
+                    pass
+                else:
+                    # Set replace=True to avoid selecting the same value more than once.
+                    random_value = numpy.random.choice(random_value, 
+                                                       size=num_values, 
+                                                       replace=False)
+        else:
+            # Generating a random value.
+            random_value = numpy.asarray(numpy.random.uniform(low=range_min, 
+                                                              high=range_max, 
+                                                              size=num_values),
+                                         dtype=object)
 
         # Change the random mutation value data type.
         for idx, val in enumerate(random_value):
@@ -97,7 +137,8 @@ def get_valid_gene_constraint_values(self,
                                          gene_idx,
                                          mutation_by_replacement,
                                          solution,
-                                         num_values=100):
+                                         num_values=100,
+                                         step=1):
         """
         Randomly generate values for the gene that satisfy the constraint.
         It accepts:
@@ -108,14 +149,21 @@ def get_valid_gene_constraint_values(self,
             -mutation_by_replacement: A flag indicating whether mutation by replacement is enabled or not. The reason is to make this helper method usable while generating the initial population. In this case, mutation_by_replacement does not matter and should be considered False.
             -solution: The solution in which the gene exists.
             -num_values: The number of random valus to generate. It tries to generate a number of values up to a maximum of num_values. But it is not always guranteed because the total number of values might not be enough or the random generator creates duplicate random values.
-        If num_values=1, it returns a single numeric value. If num_values>1, it returns an array with number of values equal to num_values.
+            -step (int, optional): The step size for generating candidate values. Defaults to 1. Only used with genes of an integer data type.
+
+        It returns,
+            -A single numeric value if num_values=1. Or 
+            -An array with number of values equal to num_values if num_values>1. Or 
+            -None if no value found that satisfies the constraint.
         """
         random_values = self.generate_gene_random_value(range_min=range_min, 
                                                         range_max=range_max, 
                                                         gene_value=gene_value,
                                                         gene_idx=gene_idx, 
                                                         mutation_by_replacement=mutation_by_replacement,
-                                                        num_values=num_values)
+                                                        num_values=num_values,
+                                                        step=step)
+        # It returns None if no value found that satisfies the constraint.
         random_values_filtered = self.mutation_filter_values_by_constraint(random_values=random_values,
                                                                            solution=solution,
                                                                            gene_idx=gene_idx)