geneticalgorithm2.crossovers

  1from typing import Callable, Tuple, Dict
  2
  3import random
  4import numpy as np
  5
  6from .utils.aliases import TypeAlias, array1D
  7
  8CrossoverFunc: TypeAlias = Callable[[array1D, array1D], Tuple[array1D, array1D]]
  9"""
 10Function (parent1, parent2) -> (child1, child2)
 11"""
 12
 13
 14def get_copies(x: array1D, y: array1D) -> Tuple[array1D, array1D]:
 15    return x.copy(), y.copy()
 16
 17
 18class Crossover:
 19    """
 20    Crossover functions static class
 21    
 22    Crossover creates 2 children from 2 parents someway, usually mixing the parents
 23    """
 24
 25    @staticmethod
 26    def crossovers_dict() -> Dict[str, CrossoverFunc]:
 27        return {
 28            n: getattr(Crossover, n)()
 29            for n in (
 30                'one_point',
 31                'two_point',
 32                'uniform',
 33                'segment',
 34                'shuffle',
 35            )
 36        }
 37    
 38    @staticmethod
 39    def one_point() -> CrossoverFunc:
 40        
 41        def func(x: array1D, y: array1D):
 42            ofs1, ofs2 = get_copies(x, y)
 43        
 44            ran = np.random.randint(0, x.size)
 45            
 46            ofs1[:ran] = y[:ran]
 47            ofs2[:ran] = x[:ran]
 48            
 49            return ofs1, ofs2
 50        return func
 51    
 52    @staticmethod
 53    def two_point() -> CrossoverFunc:
 54        
 55        def func(x: array1D, y: array1D):
 56            ofs1, ofs2 = get_copies(x, y)
 57        
 58            ran1 = np.random.randint(0, x.size)
 59            ran2 = np.random.randint(ran1, x.size)
 60            
 61            ofs1[ran1:ran2] = y[ran1:ran2]
 62            ofs2[ran1:ran2] = x[ran1:ran2]
 63
 64            return ofs1, ofs2
 65        return func
 66    
 67    @staticmethod
 68    def uniform() -> CrossoverFunc:
 69        
 70        def func(x: array1D, y: array1D):
 71            ofs1, ofs2 = get_copies(x, y)
 72        
 73            ran = np.random.random(x.size) < 0.5
 74            ofs1[ran] = y[ran]
 75            ofs2[ran] = x[ran]
 76              
 77            return ofs1, ofs2
 78        
 79        return func
 80    
 81    @staticmethod
 82    def segment(prob: int = 0.6) -> CrossoverFunc:
 83        
 84        def func(x: array1D, y: array1D):
 85            
 86            ofs1, ofs2 = get_copies(x, y)
 87            
 88            p = np.random.random(x.size) < prob
 89            
 90            for i, val in enumerate(p):
 91                if val:
 92                    ofs1[i], ofs2[i] = ofs2[i], ofs1[i]
 93            
 94            return ofs1, ofs2
 95        
 96        return func
 97    
 98    @staticmethod
 99    def shuffle() -> CrossoverFunc:
100        
101        def func(x: array1D, y: array1D):
102            
103            ofs1, ofs2 = get_copies(x, y)
104            
105            index = np.random.choice(np.arange(0, x.size), x.size, replace=False)
106            
107            ran = np.random.randint(0, x.size)
108            
109            for i in range(ran):
110                ind = index[i]
111                ofs1[ind] = y[ind]
112                ofs2[ind] = x[ind]
113            
114            return ofs1, ofs2
115            
116        return func
117    
118    @staticmethod
119    def uniform_window(window: int = 7) -> CrossoverFunc:
120
121        base_uniform = Crossover.uniform()
122
123        def func(x: np.ndarray, y: np.ndarray):
124
125            if x.size % window != 0:
126                raise ValueError(f"dimension {x.size} cannot be divided by window {window}")
127            
128            items = int(x.size/window)
129
130            zip_x, zip_y = base_uniform(np.zeros(items), np.ones(items))
131            
132            ofs1 = np.empty(x.size)
133            ofs2 = np.empty(x.size)
134            for i in range(items):
135                sls = slice(i*window, (i+1)*window, 1)
136                if zip_x[i] == 0:
137                    ofs1[sls] = x[sls]
138                    ofs2[sls] = y[sls]
139                else:
140                    ofs2[sls] = x[sls]
141                    ofs1[sls] = y[sls]                    
142
143            return ofs1, ofs2
144
145        return func
146
147    #
148    #
149    # ONLY FOR REAL VARIABLES
150    #
151    #
152    
153    @staticmethod
154    def arithmetic() -> CrossoverFunc:
155        
156        def func(x: array1D, y: array1D):
157            b = random.random()
158            a = 1-b
159            return a*x + b*y, a*y + b*x
160        
161        return func
162    
163    @staticmethod
164    def mixed(alpha: float = 0.5) -> CrossoverFunc:
165        
166        def func(x: array1D, y: array1D):
167            
168            a = np.empty(x.size)
169            b = np.empty(y.size)
170            
171            x_min = np.minimum(x, y)
172            x_max = np.maximum(x, y)
173            delta = alpha*(x_max-x_min)
174            
175            for i in range(x.size):
176                a[i] = np.random.uniform(x_min[i] - delta[i], x_max[i] + delta[i])
177                b[i] = np.random.uniform(x_min[i] + delta[i], x_max[i] - delta[i])
178            
179            return a, b
180        
181        return func
182