output refactor

Author: w-i-l

src/base_class.py

@@ -1,3 +1,3 @@
 class BaseClass:
     def __init__(self: object):
-        self.should_print = False
+        self.should_print = True

src/codification/encode.py

@@ -13,13 +13,10 @@ def __init__(
         self.upper_bound = upper_bound            
         self.precision = precision
         super().__init__()
-        print(self.should_print)
 
     def encode(self: object, number: float) -> str:
         interval_lower_bound = self.__get_interval_lower_bound(number)
         binary = self.__convert_to_binary(interval_lower_bound)
-        if self.should_print:
-            print(f'INTERVAL {interval_lower_bound} Encoded {number} to {binary}')
         return binary
 
     def __get_bin_length(self: object):

src/combination/combination.py

@@ -26,6 +26,7 @@ def __mix_cromozoms(self: object, c1: Cromosome, c2: Cromosome) -> None:
         c2.update_binary(new_c2)
         if self.should_print:
             print(f'Combined {c1.id} with {c2.id} at point {point}')
+            print(f'Result: {new_c1} {new_c2}')
 
     def __get_cromosomes_for_combination(self: object) -> list[Cromosome]:
         return [c for c in self.population if self.__should_combine()]
@@ -48,4 +49,3 @@ def __get_possible_combinations(self: object) -> list[tuple[Cromosome, Cromosome
             second = cromosomes.pop()
             result.append((first, second))
         return result
-

src/cromosome.py

@@ -34,20 +34,16 @@ def __repr__(self: object) -> str:
         return f'{self.id}'
 
     def show(self: object):
-        print(f'{self.id}: {self.value} x= {self.binary} f={self.fitness}')
+        print(f'{self.id:<3} {self.value:<10} x={self.binary:<30} f={self.fitness:<10}')
 
     def update_value(self: object, value: float) -> None:
         self.value = value
         self.binary = Cromosome.__CODER.encoder.encode(value)
         self.fitness = Cromosome.__FUNCTION(value)
-        if self.should_print:
-            print(f'Updated value for {self.id}')
 
     def update_binary(self: object, binary: str) -> None:
         self.binary = binary
         value = Cromosome.__CODER.decoder.decode(binary)
         value = round(value, Cromosome.__CODER.precision)
         self.value = value
         self.fitness = Cromosome.__FUNCTION(self.value)
-        if self.should_print:
-            print(f'Updated binary for {self.id}')

src/main.py

@@ -6,36 +6,19 @@
 from src.selection.selector import Selector
 from src.combination.combination import Combinator
 from src.mutation.mutation import Mutator
+import random
 
 if __name__ == '__main__':
-    values = [
-        -0.914592,
-        -0.516787,
-        -0.246207,
-        1.480791,
-        0.835307,
-        1.229633,
-        0.133068,
-        -0.897179,
-        0.100578,
-        -0.311975,
-        1.411980,
-        0.404924,
-        1.954865,
-        0.359503,
-        1.255452,
-        1.124764,
-        1.527482,
-        1.573845,
-        -0.562311,
-        1.191435
-    ]
+    population_size = 20
+    generations = 50
     lower_bound = -1
     upper_bound = 2
     precision = 6
     f = lambda x: -(x ** 2) + x + 2
     combination_rate = 0.25
-    mutation_rate = 0.1
+    mutation_rate = 0.01
+
+    values = [round(random.uniform(lower_bound, upper_bound), precision) for _ in range(population_size)]
     coder = coder.Coder(lower_bound, upper_bound, precision)
     binaries = [coder.encoder.encode(x)for x in values]
     fitnesses = [f(x) for x in values]
@@ -46,30 +29,39 @@
     combinator = Combinator(population, combination_rate)
     mutator = Mutator(population, mutation_rate)
 
-    print('Initial population:')
+    SEPARATOR = '----------------------------------------\n'
+
+    print('Initial population:\n')
     for c in population:
         c.show()
-    
-    selected = selector.select()
+    print(SEPARATOR)
 
-    print('\nSelected population:')
-    for c in selected:
+    population = selector.select()
+    print('\nSelected population:\n')
+    for c in population:
         c.show()
-    population = selected
+    print(SEPARATOR)
 
-    print(f'Combination rate: {combination_rate}')
+    print(f'Combination rate: {combination_rate}\n')
     population = combinator.combine()
 
-    print('\nAfter combination:')
+    print('\nAfter combination:\n')
     for c in population:
         c.show()
+    print(SEPARATOR)
 
-    print(f'Mutation rate: {mutation_rate}')
+    print(f'Mutation rate: {mutation_rate}\n')
     population = mutator.mutate()
 
-    print('\nAfter mutation:')
+    print('\nAfter mutation:\n')
     for c in population:
         c.show()
+    print(SEPARATOR)
+
+    coder.should_print = False
+    selector.should_print = False
+    combinator.should_print = False
+    mutator.should_print = False
 
     print('\n\n\n')
     for i in range(49):

src/mutation/mutation.py

@@ -15,6 +15,8 @@ def __init__(
     def mutate(self: object) -> list[Cromosome]:
         for c in self.population:
             if self.__should_mutate():
+                if self.should_print:
+                    print(f'Mutating {c.id}')
                 self.__mutate_cromozom(c)
         return self.population
 

src/selection/selector.py

@@ -13,11 +13,12 @@ def __init__(
         super().__init__()
 
     def select(self: object) -> list[Cromosome]:
-        selected = []
+        selected = [self.__get_the_best_cromozom()]
         if self.should_print:
-            print('Intervals:')
-            for index, interval in enumerate(self.intervals):
-                print(f'Interval {index}: {interval}')
+            self.__print_cromosomes_probabilities()
+            print()
+            self.__print_intervals()
+            print()
         while len(selected) < len(self.population):
             selected.append(self.__select_cromozom())
         return selected
@@ -48,6 +49,18 @@ def __select_cromozom(self: object) -> Cromosome:
         number = self.__generate_random_number()
         index = self.__get_index_of_interval(number)
         if self.should_print:
-            print(f'Selected index: {index}')
+            print(f'u= {number} selected {self.population[index]}')
         return self.population[index]
 
+    def __print_cromosomes_probabilities(self: object):
+        print('Selection probabilities:')
+        for c in self.population:
+            print(f'Probability for {c}: {self.__get_probability_for_cromozom(c)}')
+    
+    def __print_intervals(self: object):
+        print('Intervals:')
+        for i in range(len(self.intervals) - 1):
+            print(f'Interval {i}: {self.intervals[i]} - {self.intervals[i + 1]}')
+
+    def __get_the_best_cromozom(self: object) -> Cromosome:
+        return max(self.population, key=lambda c: c.fitness)